diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 8841086..ac1a243 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -34,7 +34,7 @@ jobs: id: set-matrix run: | # List of all available parsers - ALL_PARSERS="redshift postgresql cql snowflake" + ALL_PARSERS="redshift postgresql cql snowflake tsql" # Add more parsers here as they are added to the repository # ALL_PARSERS="redshift mysql postgresql" diff --git a/tsql/Makefile b/tsql/Makefile new file mode 100644 index 0000000..6a6f5a9 --- /dev/null +++ b/tsql/Makefile @@ -0,0 +1,7 @@ +all: build test + +build: + antlr -Dlanguage=Go -package tsql -visitor -o . TSqlLexer.g4 TSqlParser.g4 + +test: + go test -v -run TestTSQLParser diff --git a/tsql/README.md b/tsql/README.md new file mode 100644 index 0000000..602ecaf --- /dev/null +++ b/tsql/README.md @@ -0,0 +1,43 @@ +The tsql-parser is a parser for T-SQL. It is based on the [ANTLR4](https://github.com/antlr/antlr4) and use the grammar from [antlr4-grammars-plsql](https://github.com/antlr/grammars-v4/tree/master/sql/tsql). + +## Build + +Before build, you need to install the ANTLR4. + +requirements: + +- https://github.com/antlr/antlr4/blob/master/doc/getting-started.md +- https://github.com/antlr/antlr4/blob/master/doc/go-target.md + +```bash +./build.sh +``` + +## Update grammar + +### Manually change the grammar file in this project + +1. run `./build.sh` to generate the parser code. + +### From antlr4-grammars-tsql + +1. Clone the `TSqlLexer.g4` and `TSqlParser.g4` grammar files from https://github.com/antlr/grammars-v4/tree/master/sql/snowflake. +2. Clone the examples[https://github.com/antlr/grammars-v4/tree/master/sql/tsql/examples], and use it for test. +3. run `./build.sh` to generate the parser code. + +## Test the parser + +Run `TestTSQLParser` in `parser_test.go` to test the parser. + +```bash +go test -v +``` + +## References + +- ANTLR4 Getting Started https://github.com/antlr/antlr4/blob/master/doc/getting-started.md +- ANTLR4 Go Garget https://github.com/antlr/antlr4/blob/master/doc/go-target.md + +## Port + +Port folder contains the ported code in another language. diff --git a/tsql/TSqlLexer.g4 b/tsql/TSqlLexer.g4 new file mode 100644 index 0000000..f482b00 --- /dev/null +++ b/tsql/TSqlLexer.g4 @@ -0,0 +1,1303 @@ +/* +T-SQL (Transact-SQL, MSSQL) grammar. +The MIT License (MIT). +Copyright (c) 2017, Mark Adams (madams51703@gmail.com) +Copyright (c) 2015-2017, Ivan Kochurkin (kvanttt@gmail.com), Positive Technologies. +Copyright (c) 2016, Scott Ure (scott@redstormsoftware.com). +Copyright (c) 2016, Rui Zhang (ruizhang.ccs@gmail.com). +Copyright (c) 2016, Marcus Henriksson (kuseman80@gmail.com). +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +lexer grammar TSqlLexer; + +// Basic keywords (from https://msdn.microsoft.com/en-us/library/ms189822.aspx) + +options { + caseInsensitive = true; + superClass = 'TSqlBaseLexer'; +} + + +//Keywords that can exist in ID etc +//More keywords that can also be used as IDs +ABORT: 'ABORT'; +ABORT_AFTER_WAIT: 'ABORT_AFTER_WAIT'; +ABSENT: 'ABSENT'; +ABSOLUTE: 'ABSOLUTE'; +ACCELERATED_DATABASE_RECOVERY: 'ACCELERATED_DATABASE_RECOVERY'; +ACCENT_SENSITIVITY: 'ACCENT_SENSITIVITY'; +ACCESS: 'ACCESS'; +ACTION: 'ACTION'; +ACTIVATION: 'ACTIVATION'; +ACTIVE: 'ACTIVE'; +ADD: 'ADD'; +ADDRESS: 'ADDRESS'; +ADMINISTER: 'ADMINISTER'; +AES: 'AES'; +AES_128: 'AES_128'; +AES_192: 'AES_192'; +AES_256: 'AES_256'; +AFFINITY: 'AFFINITY'; +AFTER: 'AFTER'; +AGGREGATE: 'AGGREGATE'; +ALGORITHM: 'ALGORITHM'; +ALL: 'ALL'; +ALLOWED: 'ALLOWED'; +ALLOW_CONNECTIONS: 'ALLOW_CONNECTIONS'; +ALLOW_ENCRYPTED_VALUE_MODIFICATIONS: 'ALLOW_ENCRYPTED_VALUE_MODIFICATIONS'; +ALLOW_MULTIPLE_EVENT_LOSS: 'ALLOW_MULTIPLE_EVENT_LOSS'; +ALLOW_PAGE_LOCKS: 'ALLOW_PAGE_LOCKS'; +ALLOW_ROW_LOCKS: 'ALLOW_ROW_LOCKS'; +ALLOW_SINGLE_EVENT_LOSS: 'ALLOW_SINGLE_EVENT_LOSS'; +ALLOW_SNAPSHOT_ISOLATION: 'ALLOW_SNAPSHOT_ISOLATION'; +ALL_CONSTRAINTS: 'ALL_CONSTRAINTS'; +ALL_ERRORMSGS: 'ALL_ERRORMSGS'; +ALL_INDEXES: 'ALL_INDEXES'; +ALL_LEVELS: 'ALL_LEVELS'; +ALTER: 'ALTER'; +ALWAYS: 'ALWAYS'; +AND: 'AND'; +ANONYMOUS: 'ANONYMOUS'; +ANSI_DEFAULTS: 'ANSI_DEFAULTS'; +ANSI_NULLS: 'ANSI_NULLS'; +ANSI_NULL_DEFAULT: 'ANSI_NULL_DEFAULT'; +ANSI_NULL_DFLT_OFF: 'ANSI_NULL_DFLT_OFF'; +ANSI_NULL_DFLT_ON: 'ANSI_NULL_DFLT_ON'; +ANSI_PADDING: 'ANSI_PADDING'; +ANSI_WARNINGS: 'ANSI_WARNINGS'; +ANY: 'ANY'; +APPEND: 'APPEND'; +APPLICATION: 'APPLICATION'; +APPLICATION_LOG: 'APPLICATION_LOG'; +APPLOCK_MODE: 'APPLOCK_MODE'; +APPLOCK_TEST: 'APPLOCK_TEST'; +APPLY: 'APPLY'; +APP_NAME: 'APP_NAME'; +ARITHABORT: 'ARITHABORT'; +ARITHIGNORE: 'ARITHIGNORE'; +AS: 'AS'; +ASC: 'ASC'; +ASCII: 'ASCII'; +ASSEMBLY: 'ASSEMBLY'; +ASSEMBLYPROPERTY: 'ASSEMBLYPROPERTY'; +ASYMMETRIC: 'ASYMMETRIC'; +ASYNCHRONOUS_COMMIT: 'ASYNCHRONOUS_COMMIT'; +AT_KEYWORD: 'AT'; +AUDIT: 'AUDIT'; +AUDIT_GUID: 'AUDIT_GUID'; +AUTHENTICATE: 'AUTHENTICATE'; +AUTHENTICATION: 'AUTHENTICATION'; +AUTHORIZATION: 'AUTHORIZATION'; +AUTO: 'AUTO'; +AUTOGROW_ALL_FILES: 'AUTOGROW_ALL_FILES'; +AUTOGROW_SINGLE_FILE: 'AUTOGROW_SINGLE_FILE'; +AUTOMATED_BACKUP_PREFERENCE: 'AUTOMATED_BACKUP_PREFERENCE'; +AUTOMATIC: 'AUTOMATIC'; +AUTO_CLEANUP: 'AUTO_CLEANUP'; +AUTO_CLOSE: 'AUTO_CLOSE'; +AUTO_CREATE_STATISTICS: 'AUTO_CREATE_STATISTICS'; +AUTO_DROP: 'AUTO_DROP'; +AUTO_SHRINK: 'AUTO_SHRINK'; +AUTO_UPDATE_STATISTICS: 'AUTO_UPDATE_STATISTICS'; +AUTO_UPDATE_STATISTICS_ASYNC: 'AUTO_UPDATE_STATISTICS_ASYNC'; +AVAILABILITY: 'AVAILABILITY'; +AVAILABILITY_MODE: 'AVAILABILITY_MODE'; +AVG: 'AVG'; +BACKSLASH: '\\'; +BACKUP: 'BACKUP'; +BACKUP_CLONEDB: 'BACKUP_CLONEDB'; +BACKUP_PRIORITY: 'BACKUP_PRIORITY'; +BASE64: 'BASE64'; +BEFORE: 'BEFORE'; +BEGIN: 'BEGIN'; +BEGIN_DIALOG: 'BEGIN_DIALOG'; +BETWEEN: 'BETWEEN'; +BIGINT: 'BIGINT'; +BINARY_CHECKSUM: 'BINARY_CHECKSUM'; +BINARY_KEYWORD: 'BINARY'; +BINDING: 'BINDING'; +BLOB_STORAGE: 'BLOB_STORAGE'; +BLOCK: 'BLOCK'; +BLOCKERS: 'BLOCKERS'; +BLOCKING_HIERARCHY: 'BLOCKING_HIERARCHY'; +BLOCKSIZE: 'BLOCKSIZE'; +BOUNDING_BOX: 'BOUNDING_BOX'; +BREAK: 'BREAK'; +BROKER: 'BROKER'; +BROKER_INSTANCE: 'BROKER_INSTANCE'; +BROWSE: 'BROWSE'; +BUFFER: 'BUFFER'; +BUFFERCOUNT: 'BUFFERCOUNT'; +BULK: 'BULK'; +BULK_LOGGED: 'BULK_LOGGED'; +BY: 'BY'; +CACHE: 'CACHE'; +CALLED: 'CALLED'; +CALLER: 'CALLER'; +CAP_CPU_PERCENT: 'CAP_CPU_PERCENT'; +CASCADE: 'CASCADE'; +CASE: 'CASE'; +CAST: 'CAST'; +CATALOG: 'CATALOG'; +CATCH: 'CATCH'; +CELLS_PER_OBJECT: 'CELLS_PER_OBJECT'; +CERTENCODED: 'CERTENCODED'; +CERTIFICATE: 'CERTIFICATE'; +CERTPRIVATEKEY: 'CERTPRIVATEKEY'; +CERT_ID: 'CERT_ID'; +CHANGE: 'CHANGE'; +CHANGES: 'CHANGES'; +CHANGETABLE: 'CHANGETABLE'; +CHANGE_RETENTION: 'CHANGE_RETENTION'; +CHANGE_TRACKING: 'CHANGE_TRACKING'; +CHAR: 'CHAR'; +CHARINDEX: 'CHARINDEX'; +CHECK: 'CHECK'; +CHECKALLOC: 'CHECKALLOC'; +CHECKCATALOG: 'CHECKCATALOG'; +CHECKCONSTRAINTS: 'CHECKCONSTRAINTS'; +CHECKDB: 'CHECKDB'; +CHECKFILEGROUP: 'CHECKFILEGROUP'; +CHECKPOINT: 'CHECKPOINT'; +CHECKSUM: 'CHECKSUM'; +CHECKSUM_AGG: 'CHECKSUM_AGG'; +CHECKTABLE: 'CHECKTABLE'; +CHECK_EXPIRATION: 'CHECK_EXPIRATION'; +CHECK_POLICY: 'CHECK_POLICY'; +CLASSIFIER_FUNCTION: 'CLASSIFIER_FUNCTION'; +CLEANTABLE: 'CLEANTABLE'; +CLEANUP: 'CLEANUP'; +CLONEDATABASE: 'CLONEDATABASE'; +CLOSE: 'CLOSE'; +CLUSTER: 'CLUSTER'; +CLUSTERED: 'CLUSTERED'; +COALESCE: 'COALESCE'; +COLLATE: 'COLLATE'; +COLLECTION: 'COLLECTION'; +COLUMN: 'COLUMN'; +COLUMNPROPERTY: 'COLUMNPROPERTY'; +COLUMNS: 'COLUMNS'; +COLUMNSTORE: 'COLUMNSTORE'; +COLUMNSTORE_ARCHIVE: 'COLUMNSTORE_ARCHIVE'; +COLUMN_ENCRYPTION_KEY: 'COLUMN_ENCRYPTION_KEY'; +COLUMN_MASTER_KEY: 'COLUMN_MASTER_KEY'; +COL_LENGTH: 'COL_LENGTH'; +COL_NAME: 'COL_NAME'; +COMMIT: 'COMMIT'; +COMMITTED: 'COMMITTED'; +COMPATIBILITY_LEVEL: 'COMPATIBILITY_LEVEL'; +COMPRESS: 'COMPRESS'; +COMPRESSION: 'COMPRESSION'; +COMPRESSION_DELAY: 'COMPRESSION_DELAY'; +COMPRESS_ALL_ROW_GROUPS: 'COMPRESS_ALL_ROW_GROUPS'; +COMPUTE: 'COMPUTE'; +CONCAT: 'CONCAT'; +CONCAT_NULL_YIELDS_NULL: 'CONCAT_NULL_YIELDS_NULL'; +CONCAT_WS: 'CONCAT_WS'; +CONFIGURATION: 'CONFIGURATION'; +CONNECT: 'CONNECT'; +CONNECTION: 'CONNECTION'; +CONNECTIONPROPERTY: 'CONNECTIONPROPERTY'; +CONSTRAINT: 'CONSTRAINT'; +CONTAINMENT: 'CONTAINMENT'; +CONTAINS: 'CONTAINS'; +CONTAINSTABLE: 'CONTAINSTABLE'; +CONTENT: 'CONTENT'; +CONTEXT: 'CONTEXT'; +CONTEXT_INFO: 'CONTEXT_INFO'; +CONTINUE: 'CONTINUE'; +CONTINUE_AFTER_ERROR: 'CONTINUE_AFTER_ERROR'; +CONTRACT: 'CONTRACT'; +CONTRACT_NAME: 'CONTRACT_NAME'; +CONTROL: 'CONTROL'; +CONVERSATION: 'CONVERSATION'; +CONVERT: 'TRY_'? 'CONVERT'; +COOKIE: 'COOKIE'; +COPY_ONLY: 'COPY_ONLY'; +COUNT: 'COUNT'; +COUNTER: 'COUNTER'; +COUNT_BIG: 'COUNT_BIG'; +CPU: 'CPU'; +CREATE: 'CREATE'; +CREATE_NEW: 'CREATE_NEW'; +CREATION_DISPOSITION: 'CREATION_DISPOSITION'; +CREDENTIAL: 'CREDENTIAL'; +CROSS: 'CROSS'; +CRYPTOGRAPHIC: 'CRYPTOGRAPHIC'; +CUME_DIST: 'CUME_DIST'; +CURRENT: 'CURRENT'; +CURRENT_DATE: 'CURRENT_DATE'; +CURRENT_REQUEST_ID: 'CURRENT_REQUEST_ID'; +CURRENT_TIME: 'CURRENT_TIME'; +CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'; +CURRENT_TRANSACTION_ID: 'CURRENT_TRANSACTION_ID'; +CURRENT_USER: 'CURRENT_USER'; +CURSOR: 'CURSOR'; +CURSOR_CLOSE_ON_COMMIT: 'CURSOR_CLOSE_ON_COMMIT'; +CURSOR_DEFAULT: 'CURSOR_DEFAULT'; +CURSOR_STATUS: 'CURSOR_STATUS'; +CYCLE: 'CYCLE'; +DATA: 'DATA'; +DATABASE: 'DATABASE'; +DATABASEPROPERTYEX: 'DATABASEPROPERTYEX'; +DATABASE_MIRRORING: 'DATABASE_MIRRORING'; +DATABASE_PRINCIPAL_ID: 'DATABASE_PRINCIPAL_ID'; +DATALENGTH: 'DATALENGTH'; +DATASPACE: 'DATASPACE'; +DATA_COMPRESSION: 'DATA_COMPRESSION'; +DATA_PURITY: 'DATA_PURITY'; +DATA_SOURCE: 'DATA_SOURCE'; +DATEADD: 'DATEADD'; +DATEDIFF: 'DATEDIFF'; +DATENAME: 'DATENAME'; +DATEPART: 'DATEPART'; +DATE_CORRELATION_OPTIMIZATION: 'DATE_CORRELATION_OPTIMIZATION'; +DAYS: 'DAYS'; +DBCC: 'DBCC'; +DBREINDEX: 'DBREINDEX'; +DB_CHAINING: 'DB_CHAINING'; +DB_FAILOVER: 'DB_FAILOVER'; +DB_ID: 'DB_ID'; +DB_NAME: 'DB_NAME'; +DDL: 'DDL'; +DEALLOCATE: 'DEALLOCATE'; +DECLARE: 'DECLARE'; +DECOMPRESS: 'DECOMPRESS'; +DECRYPTION: 'DECRYPTION'; +DEFAULT: 'DEFAULT'; +DEFAULT_DATABASE: 'DEFAULT_DATABASE'; +DEFAULT_DOUBLE_QUOTE: ["]'DEFAULT'["]; +DEFAULT_FULLTEXT_LANGUAGE: 'DEFAULT_FULLTEXT_LANGUAGE'; +DEFAULT_LANGUAGE: 'DEFAULT_LANGUAGE'; +DEFAULT_SCHEMA: 'DEFAULT_SCHEMA'; +DEFINITION: 'DEFINITION'; +DELAY: 'DELAY'; +DELAYED_DURABILITY: 'DELAYED_DURABILITY'; +DELETE: 'DELETE'; +DELETED: 'DELETED'; +DENSE_RANK: 'DENSE_RANK'; +DENY: 'DENY'; +DEPENDENTS: 'DEPENDENTS'; +DES: 'DES'; +DESC: 'DESC'; +DESCRIPTION: 'DESCRIPTION'; +DESX: 'DESX'; +DETERMINISTIC: 'DETERMINISTIC'; +DHCP: 'DHCP'; +DIAGNOSTICS: 'DIAGNOSTICS'; +DIALOG: 'DIALOG'; +DIFFERENCE: 'DIFFERENCE'; +DIFFERENTIAL: 'DIFFERENTIAL'; +DIRECTORY_NAME: 'DIRECTORY_NAME'; +DISABLE: 'DISABLE'; +DISABLED: 'DISABLED'; +DISABLE_BROKER: 'DISABLE_BROKER'; +DISK: 'DISK'; +DISTINCT: 'DISTINCT'; +DISTRIBUTED: 'DISTRIBUTED'; +DISTRIBUTION: 'DISTRIBUTION'; +DOCUMENT: 'DOCUMENT'; +DOLLAR_PARTITION: '$PARTITION'; +DOUBLE: 'DOUBLE'; +DOUBLE_BACK_SLASH: '\\\\'; +DOUBLE_FORWARD_SLASH: '//'; +DROP: 'DROP'; +DROPCLEANBUFFERS: 'DROPCLEANBUFFERS'; +DROP_EXISTING: 'DROP_EXISTING'; +DTC_SUPPORT: 'DTC_SUPPORT'; +DUMP: 'DUMP'; +DYNAMIC: 'DYNAMIC'; +ELEMENTS: 'ELEMENTS'; +ELSE: 'ELSE'; +EMERGENCY: 'EMERGENCY'; +EMPTY: 'EMPTY'; +ENABLE: 'ENABLE'; +ENABLED: 'ENABLED'; +ENABLE_BROKER: 'ENABLE_BROKER'; +ENCRYPTED: 'ENCRYPTED'; +ENCRYPTED_VALUE: 'ENCRYPTED_VALUE'; +ENCRYPTION: 'ENCRYPTION'; +ENCRYPTION_TYPE: 'ENCRYPTION_TYPE'; +END: 'END'; +ENDPOINT: 'ENDPOINT'; +ENDPOINT_URL: 'ENDPOINT_URL'; +ERRLVL: 'ERRLVL'; +ERROR: 'ERROR'; +ERROR_BROKER_CONVERSATIONS: 'ERROR_BROKER_CONVERSATIONS'; +ERROR_LINE: 'ERROR_LINE'; +ERROR_MESSAGE: 'ERROR_MESSAGE'; +ERROR_NUMBER: 'ERROR_NUMBER'; +ERROR_PROCEDURE: 'ERROR_PROCEDURE'; +ERROR_SEVERITY: 'ERROR_SEVERITY'; +ERROR_STATE: 'ERROR_STATE'; +ESCAPE: 'ESCAPE'; +ESTIMATEONLY: 'ESTIMATEONLY'; +EVENT: 'EVENT'; +EVENTDATA: 'EVENTDATA'; +EVENT_RETENTION_MODE: 'EVENT_RETENTION_MODE'; +EXCEPT: 'EXCEPT'; +EXCLUSIVE: 'EXCLUSIVE'; +EXECUTABLE: 'EXECUTABLE'; +EXECUTABLE_FILE: 'EXECUTABLE_FILE'; +EXECUTE: 'EXEC' 'UTE'?; +EXIST: 'EXIST'; +EXISTS: 'EXISTS'; +EXIST_SQUARE_BRACKET: '[EXIST]'; +EXIT: 'EXIT'; +EXPAND: 'EXPAND'; +EXPIREDATE: 'EXPIREDATE'; +EXPIRY_DATE: 'EXPIRY_DATE'; +EXPLICIT: 'EXPLICIT'; +EXTENDED_LOGICAL_CHECKS: 'EXTENDED_LOGICAL_CHECKS'; +EXTENSION: 'EXTENSION'; +EXTERNAL: 'EXTERNAL'; +EXTERNAL_ACCESS: 'EXTERNAL_ACCESS'; +FAILOVER: 'FAILOVER'; +FAILOVER_MODE: 'FAILOVER_MODE'; +FAILURE: 'FAILURE'; +FAILURECONDITIONLEVEL: 'FAILURECONDITIONLEVEL'; +FAILURE_CONDITION_LEVEL: 'FAILURE_CONDITION_LEVEL'; +FAIL_OPERATION: 'FAIL_OPERATION'; +FAN_IN: 'FAN_IN'; +FAST: 'FAST'; +FAST_FORWARD: 'FAST_FORWARD'; +FETCH: 'FETCH'; +FILE: 'FILE'; +FILEGROUP: 'FILEGROUP'; +FILEGROUPPROPERTY: 'FILEGROUPPROPERTY'; +FILEGROUP_ID: 'FILEGROUP_ID'; +FILEGROUP_NAME: 'FILEGROUP_NAME'; +FILEGROWTH: 'FILEGROWTH'; +FILENAME: 'FILENAME'; +FILEPATH: 'FILEPATH'; +FILEPROPERTY: 'FILEPROPERTY'; +FILEPROPERTYEX: 'FILEPROPERTYEX'; +FILESTREAM: 'FILESTREAM'; +FILESTREAM_ON: 'FILESTREAM_ON'; +FILE_ID: 'FILE_ID'; +FILE_IDEX: 'FILE_IDEX'; +FILE_NAME: 'FILE_NAME'; +FILE_SNAPSHOT: 'FILE_SNAPSHOT'; +FILLFACTOR: 'FILLFACTOR'; +FILTER: 'FILTER'; +FIRST: 'FIRST'; +FIRST_VALUE: 'FIRST_VALUE'; +FMTONLY: 'FMTONLY'; +FOLLOWING: 'FOLLOWING'; +FOR: 'FOR'; +FORCE: 'FORCE'; +FORCED: 'FORCED'; +FORCEPLAN: 'FORCEPLAN'; +FORCESCAN: 'FORCESCAN'; +FORCESEEK: 'FORCESEEK'; +FORCE_FAILOVER_ALLOW_DATA_LOSS: 'FORCE_FAILOVER_ALLOW_DATA_LOSS'; +FORCE_SERVICE_ALLOW_DATA_LOSS: 'FORCE_SERVICE_ALLOW_DATA_LOSS'; +FOREIGN: 'FOREIGN'; +FORMAT: 'FORMAT'; +FORMATMESSAGE: 'FORMATMESSAGE'; +FORWARD_ONLY: 'FORWARD_ONLY'; +FREE: 'FREE'; +FREETEXT: 'FREETEXT'; +FREETEXTTABLE: 'FREETEXTTABLE'; +FROM: 'FROM'; +FULL: 'FULL'; +FULLSCAN: 'FULLSCAN'; +FULLTEXT: 'FULLTEXT'; +FULLTEXTCATALOGPROPERTY: 'FULLTEXTCATALOGPROPERTY'; +FULLTEXTSERVICEPROPERTY: 'FULLTEXTSERVICEPROPERTY'; +FUNCTION: 'FUNCTION'; +GB: 'GB'; +GENERATED: 'GENERATED'; +GEOGRAPHY: 'GEOGRAPHY'; +GEOGRAPHY_AUTO_GRID: 'GEOGRAPHY_AUTO_GRID'; +GEOGRAPHY_GRID: 'GEOGRAPHY_GRID'; +GEOMETRY: 'GEOMETRY'; +GEOMETRY_AUTO_GRID: 'GEOMETRY_AUTO_GRID'; +GEOMETRY_GRID: 'GEOMETRY_GRID'; +GET: 'GET'; +GRIDS: 'GRIDS'; +GETANCESTOR: 'GETANCESTOR'; +GETANSINULL: 'GETANSINULL'; +GETDATE: 'GETDATE'; +GETDESCENDANT: 'GETDESCENDANT'; +GETLEVEL: 'GETLEVEL'; +GETREPARENTEDVALUE: 'GETREPARENTEDVALUE'; +GETROOT: 'GETROOT'; +GETUTCDATE: 'GETUTCDATE'; +GET_FILESTREAM_TRANSACTION_CONTEXT: 'GET_FILESTREAM_TRANSACTION_CONTEXT'; +GLOBAL: 'GLOBAL'; +GO: 'GO'; +GOTO: 'GOTO'; +GOVERNOR: 'GOVERNOR'; +GRANT: 'GRANT'; +GREATEST: 'GREATEST'; +GROUP: 'GROUP'; +GROUPING: 'GROUPING'; +GROUPING_ID: 'GROUPING_ID'; +GROUP_MAX_REQUESTS: 'GROUP_MAX_REQUESTS'; +HADR: 'HADR'; +HASH: 'HASH'; +HASHED: 'HASHED'; +HAS_DBACCESS: 'HAS_DBACCESS'; +HAS_PERMS_BY_NAME: 'HAS_PERMS_BY_NAME'; +HAVING: 'HAVING'; +HEALTHCHECKTIMEOUT: 'HEALTHCHECKTIMEOUT'; +HEALTH_CHECK_TIMEOUT: 'HEALTH_CHECK_TIMEOUT'; +HEAP: 'HEAP'; +HIDDEN_KEYWORD: 'HIDDEN'; +HIERARCHYID: 'HIERARCHYID'; +HIGH: 'HIGH'; +HOLDLOCK: 'HOLDLOCK'; +HONOR_BROKER_PRIORITY: 'HONOR_BROKER_PRIORITY'; +HOST_ID: 'HOST_ID'; +HOST_NAME: 'HOST_NAME'; +HOURS: 'HOURS'; +IDENTITY: 'IDENTITY'; +IDENTITYCOL: 'IDENTITYCOL'; +IDENTITY_INSERT: 'IDENTITY_INSERT'; +IDENTITY_VALUE: 'IDENTITY_VALUE'; +IDENT_CURRENT: 'IDENT_CURRENT'; +IDENT_INCR: 'IDENT_INCR'; +IDENT_SEED: 'IDENT_SEED'; +IF: 'IF'; +IGNORE_CONSTRAINTS: 'IGNORE_CONSTRAINTS'; +IGNORE_DUP_KEY: 'IGNORE_DUP_KEY'; +IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX: 'IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX'; +IGNORE_REPLICATED_TABLE_CACHE: 'IGNORE_REPLICATED_TABLE_CACHE'; +IGNORE_TRIGGERS: 'IGNORE_TRIGGERS'; +IIF: 'IIF'; +IMMEDIATE: 'IMMEDIATE'; +IMPERSONATE: 'IMPERSONATE'; +IMPLICIT_TRANSACTIONS: 'IMPLICIT_TRANSACTIONS'; +IMPORTANCE: 'IMPORTANCE'; +IN: 'IN'; +INCLUDE: 'INCLUDE'; +INCLUDE_NULL_VALUES: 'INCLUDE_NULL_VALUES'; +INCREMENT: 'INCREMENT'; +INCREMENTAL: 'INCREMENTAL'; +INDEX: 'INDEX'; +INDEXKEY_PROPERTY: 'INDEXKEY_PROPERTY'; +INDEXPROPERTY: 'INDEXPROPERTY'; +INDEX_COL: 'INDEX_COL'; +INFINITE: 'INFINITE'; +INIT: 'INIT'; +INITIATOR: 'INITIATOR'; +INNER: 'INNER'; +INPUT: 'INPUT'; +INSENSITIVE: 'INSENSITIVE'; +INSERT: 'INSERT'; +INSERTED: 'INSERTED'; +INSTEAD: 'INSTEAD'; +INT: 'INT'; +INTERSECT: 'INTERSECT'; +INTO: 'INTO'; +IO: 'IO'; +IP: 'IP'; +IS: 'IS'; +ISDESCENDANTOF: 'ISDESCENDANTOF'; +ISJSON: 'ISJSON'; +ISNULL: 'ISNULL'; +ISNUMERIC: 'ISNUMERIC'; +ISOLATION: 'ISOLATION'; +IS_MEMBER: 'IS_MEMBER'; +IS_ROLEMEMBER: 'IS_ROLEMEMBER'; +IS_SRVROLEMEMBER: 'IS_SRVROLEMEMBER'; +JOB: 'JOB'; +JOIN: 'JOIN'; +JSON: 'JSON'; +JSON_ARRAY: 'JSON_ARRAY'; +JSON_MODIFY: 'JSON_MODIFY'; +JSON_OBJECT: 'JSON_OBJECT'; +JSON_PATH_EXISTS: 'JSON_PATH_EXISTS'; +JSON_QUERY: 'JSON_QUERY'; +JSON_VALUE: 'JSON_VALUE'; +KB: 'KB'; +KEEP: 'KEEP'; +KEEPDEFAULTS: 'KEEPDEFAULTS'; +KEEPFIXED: 'KEEPFIXED'; +KEEPIDENTITY: 'KEEPIDENTITY'; +KERBEROS: 'KERBEROS'; +KEY: 'KEY'; +KEYS: 'KEYS'; +KEYSET: 'KEYSET'; +KEY_PATH: 'KEY_PATH'; +KEY_SOURCE: 'KEY_SOURCE'; +KEY_STORE_PROVIDER_NAME: 'KEY_STORE_PROVIDER_NAME'; +KILL: 'KILL'; +LAG: 'LAG'; +LANGUAGE: 'LANGUAGE'; +LAST: 'LAST'; +LAST_VALUE: 'LAST_VALUE'; +LEAD: 'LEAD'; +LEAST: 'LEAST'; +LEFT: 'LEFT'; +LEN: 'LEN'; +LEVEL: 'LEVEL'; +LEVEL_1: 'LEVEL_1'; +LEVEL_2: 'LEVEL_2'; +LEVEL_3: 'LEVEL_3'; +LEVEL_4: 'LEVEL_4'; +LIBRARY: 'LIBRARY'; +LIFETIME: 'LIFETIME'; +LIKE: 'LIKE'; +LINENO: 'LINENO'; +LINKED: 'LINKED'; +LINUX: 'LINUX'; +LIST: 'LIST'; +LISTENER: 'LISTENER'; +LISTENER_IP: 'LISTENER_IP'; +LISTENER_PORT: 'LISTENER_PORT'; +LISTENER_URL: 'LISTENER_URL'; +LOAD: 'LOAD'; +LOB_COMPACTION: 'LOB_COMPACTION'; +LOCAL: 'LOCAL'; +LOCAL_SERVICE_NAME: 'LOCAL_SERVICE_NAME'; +LOCATION: 'LOCATION'; +LOCK: 'LOCK'; +LOCK_ESCALATION: 'LOCK_ESCALATION'; +LOG: 'LOG'; +LOGIN: 'LOGIN'; +LOGINPROPERTY: 'LOGINPROPERTY'; +LOOP: 'LOOP'; +LOW: 'LOW'; +LOWER: 'LOWER'; +LTRIM: 'LTRIM'; +MANUAL: 'MANUAL'; +MARK: 'MARK'; +MASK: 'MASK'; +MASKED: 'MASKED'; +MASTER: 'MASTER'; +MATCHED: 'MATCHED'; +MATERIALIZED: 'MATERIALIZED'; +MAX: 'MAX'; +MAXDOP: 'MAXDOP'; +MAXRECURSION: 'MAXRECURSION'; +MAXSIZE: 'MAXSIZE'; +MAXTRANSFER: 'MAXTRANSFER'; +MAXVALUE: 'MAXVALUE'; +MAX_CPU_PERCENT: 'MAX_CPU_PERCENT'; +MAX_DISPATCH_LATENCY: 'MAX_DISPATCH_LATENCY'; +MAX_DOP: 'MAX_DOP'; +MAX_DURATION: 'MAX_DURATION'; +MAX_EVENT_SIZE: 'MAX_EVENT_SIZE'; +MAX_FILES: 'MAX_FILES'; +MAX_IOPS_PER_VOLUME: 'MAX_IOPS_PER_VOLUME'; +MAX_MEMORY: 'MAX_MEMORY'; +MAX_MEMORY_PERCENT: 'MAX_MEMORY_PERCENT'; +MAX_OUTSTANDING_IO_PER_VOLUME: 'MAX_OUTSTANDING_IO_PER_VOLUME'; +MAX_PROCESSES: 'MAX_PROCESSES'; +MAX_QUEUE_READERS: 'MAX_QUEUE_READERS'; +MAX_ROLLOVER_FILES: 'MAX_ROLLOVER_FILES'; +MAX_SIZE: 'MAX_SIZE'; +MB: 'MB'; +MEDIADESCRIPTION: 'MEDIADESCRIPTION'; +MEDIANAME: 'MEDIANAME'; +MEDIUM: 'MEDIUM'; +MEMBER: 'MEMBER'; +MEMORY_OPTIMIZED_DATA: 'MEMORY_OPTIMIZED_DATA'; +MEMORY_PARTITION_MODE: 'MEMORY_PARTITION_MODE'; +MERGE: 'MERGE'; +MESSAGE: 'MESSAGE'; +MESSAGE_FORWARDING: 'MESSAGE_FORWARDING'; +MESSAGE_FORWARD_SIZE: 'MESSAGE_FORWARD_SIZE'; +MIN: 'MIN'; +MINUTES: 'MINUTES'; +MINVALUE: 'MINVALUE'; +MIN_ACTIVE_ROWVERSION: 'MIN_ACTIVE_ROWVERSION'; +MIN_CPU_PERCENT: 'MIN_CPU_PERCENT'; +MIN_IOPS_PER_VOLUME: 'MIN_IOPS_PER_VOLUME'; +MIN_MEMORY_PERCENT: 'MIN_MEMORY_PERCENT'; +MIRROR: 'MIRROR'; +MIRROR_ADDRESS: 'MIRROR_ADDRESS'; +MIXED_PAGE_ALLOCATION: 'MIXED_PAGE_ALLOCATION'; +MODE: 'MODE'; +MODIFY: 'MODIFY'; +MODIFY_SQUARE_BRACKET: '[MODIFY]'; +MOVE: 'MOVE'; +MULTI_USER: 'MULTI_USER'; +MUST_CHANGE: 'MUST_CHANGE'; +NAME: 'NAME'; +NATIONAL: 'NATIONAL'; +NCHAR: 'NCHAR'; +NEGOTIATE: 'NEGOTIATE'; +NESTED_TRIGGERS: 'NESTED_TRIGGERS'; +NEWID: 'NEWID'; +NEWNAME: 'NEWNAME'; +NEWSEQUENTIALID: 'NEWSEQUENTIALID'; +NEW_ACCOUNT: 'NEW_ACCOUNT'; +NEW_BROKER: 'NEW_BROKER'; +NEW_PASSWORD: 'NEW_PASSWORD'; +NEXT: 'NEXT'; +NO: 'NO'; +NOCHECK: 'NOCHECK'; +NOCOUNT: 'NOCOUNT'; +NODES: 'NODES'; +NOEXEC: 'NOEXEC'; +NOEXPAND: 'NOEXPAND'; +NOFORMAT: 'NOFORMAT'; +NOHOLDLOCK: 'NOHOLDLOCK'; +NOINDEX: 'NOINDEX'; +NOINIT: 'NOINIT'; +NOLOCK: 'NOLOCK'; +NONCLUSTERED: 'NONCLUSTERED'; +NONE: 'NONE'; +NON_TRANSACTED_ACCESS: 'NON_TRANSACTED_ACCESS'; +NORECOMPUTE: 'NORECOMPUTE'; +NORECOVERY: 'NORECOVERY'; +NOREWIND: 'NOREWIND'; +NOSKIP: 'NOSKIP'; +NOT: 'NOT'; +NOTIFICATION: 'NOTIFICATION'; +NOTIFICATIONS: 'NOTIFICATIONS'; +NOUNLOAD: 'NOUNLOAD'; +NOWAIT: 'NOWAIT'; +NO_CHECKSUM: 'NO_CHECKSUM'; +NO_COMPRESSION: 'NO_COMPRESSION'; +NO_EVENT_LOSS: 'NO_EVENT_LOSS'; +NO_INFOMSGS: 'NO_INFOMSGS'; +NO_QUERYSTORE: 'NO_QUERYSTORE'; +NO_STATISTICS: 'NO_STATISTICS'; +NO_TRUNCATE: 'NO_TRUNCATE'; +NO_WAIT: 'NO_WAIT'; +NTILE: 'NTILE'; +NTLM: 'NTLM'; +NULLIF: 'NULLIF'; +NULL_: 'NULL'; +NULL_DOUBLE_QUOTE: ["]'NULL'["]; +NUMANODE: 'NUMANODE'; +NUMBER: 'NUMBER'; +NUMERIC_ROUNDABORT: 'NUMERIC_ROUNDABORT'; +OBJECT: 'OBJECT'; +OBJECTPROPERTY: 'OBJECTPROPERTY'; +OBJECTPROPERTYEX: 'OBJECTPROPERTYEX'; +OBJECT_DEFINITION: 'OBJECT_DEFINITION'; +OBJECT_ID: 'OBJECT_ID'; +OBJECT_NAME: 'OBJECT_NAME'; +OBJECT_SCHEMA_NAME: 'OBJECT_SCHEMA_NAME'; +OF: 'OF'; +OFF: 'OFF'; +OFFLINE: 'OFFLINE'; +OFFSET: 'OFFSET'; +OFFSETS: 'OFFSETS'; +OLD_ACCOUNT: 'OLD_ACCOUNT'; +OLD_PASSWORD: 'OLD_PASSWORD'; +ON: 'ON'; +ONLINE: 'ONLINE'; +ONLY: 'ONLY'; +ON_FAILURE: 'ON_FAILURE'; +OPEN: 'OPEN'; +OPENDATASOURCE: 'OPENDATASOURCE'; +OPENJSON: 'OPENJSON'; +OPENQUERY: 'OPENQUERY'; +OPENROWSET: 'OPENROWSET'; +OPENXML: 'OPENXML'; +OPEN_EXISTING: 'OPEN_EXISTING'; +OPERATIONS: 'OPERATIONS'; +OPTIMISTIC: 'OPTIMISTIC'; +OPTIMIZE: 'OPTIMIZE'; +OPTIMIZE_FOR_SEQUENTIAL_KEY: 'OPTIMIZE_FOR_SEQUENTIAL_KEY'; +OPTION: 'OPTION'; +OR: 'OR'; +ORDER: 'ORDER'; +ORIGINAL_DB_NAME: 'ORIGINAL_DB_NAME'; +ORIGINAL_LOGIN: 'ORIGINAL_LOGIN'; +OUT: 'OUT'; +OUTER: 'OUTER'; +OUTPUT: 'OUTPUT'; +OVER: 'OVER'; +OVERRIDE: 'OVERRIDE'; +OWNER: 'OWNER'; +OWNERSHIP: 'OWNERSHIP'; +PAD_INDEX: 'PAD_INDEX'; +PAGE: 'PAGE'; +PAGECOUNT: 'PAGECOUNT'; +PAGE_VERIFY: 'PAGE_VERIFY'; +PAGLOCK: 'PAGLOCK'; +PARAMETERIZATION: 'PARAMETERIZATION'; +PARAM_NODE: 'PARAM_NODE'; +PARSE: 'TRY_'? 'PARSE'; +PARSENAME: 'PARSENAME'; +PARSEONLY: 'PARSEONLY'; +PARTIAL: 'PARTIAL'; +PARTITION: 'PARTITION'; +PARTITIONS: 'PARTITIONS'; +PARTNER: 'PARTNER'; +PASSWORD: 'PASSWORD'; +PATH: 'PATH'; +PATINDEX: 'PATINDEX'; +PAUSE: 'PAUSE'; +PDW_SHOWSPACEUSED: 'PDW_SHOWSPACEUSED'; +PERCENT: 'PERCENT'; +PERCENTILE_CONT: 'PERCENTILE_CONT'; +PERCENTILE_DISC: 'PERCENTILE_DISC'; +PERCENT_RANK: 'PERCENT_RANK'; +PERMISSIONS: 'PERMISSIONS'; +PERMISSION_SET: 'PERMISSION_SET'; +PERSISTED: 'PERSISTED'; +PERSIST_SAMPLE_PERCENT: 'PERSIST_SAMPLE_PERCENT'; +PER_CPU: 'PER_CPU'; +PER_DB: 'PER_DB'; +PER_NODE: 'PER_NODE'; +PHYSICAL_ONLY: 'PHYSICAL_ONLY'; +PIVOT: 'PIVOT'; +PLAN: 'PLAN'; +PLATFORM: 'PLATFORM'; +POISON_MESSAGE_HANDLING: 'POISON_MESSAGE_HANDLING'; +POLICY: 'POLICY'; +POOL: 'POOL'; +PORT: 'PORT'; +PRECEDING: 'PRECEDING'; +PRECISION: 'PRECISION'; +PREDICATE: 'PREDICATE'; +PRIMARY: 'PRIMARY'; +PRIMARY_ROLE: 'PRIMARY_ROLE'; +PRINT: 'PRINT'; +PRIOR: 'PRIOR'; +PRIORITY: 'PRIORITY'; +PRIORITY_LEVEL: 'PRIORITY_LEVEL'; +PRIVATE: 'PRIVATE'; +PRIVATE_KEY: 'PRIVATE_KEY'; +PRIVILEGES: 'PRIVILEGES'; +PROC: 'PROC'; +PROCCACHE: 'PROCCACHE'; +PROCEDURE: 'PROCEDURE'; +PROCEDURE_NAME: 'PROCEDURE_NAME'; +PROCESS: 'PROCESS'; +PROFILE: 'PROFILE'; +PROPERTY: 'PROPERTY'; +PROVIDER: 'PROVIDER'; +PROVIDER_KEY_NAME: 'PROVIDER_KEY_NAME'; +PUBLIC: 'PUBLIC'; +PWDCOMPARE: 'PWDCOMPARE'; +PWDENCRYPT: 'PWDENCRYPT'; +PYTHON: 'PYTHON'; +QUERY: 'QUERY'; +QUERY_SQUARE_BRACKET: '[QUERY]'; +QUEUE: 'QUEUE'; +QUEUE_DELAY: 'QUEUE_DELAY'; +QUOTED_IDENTIFIER: 'QUOTED_IDENTIFIER'; +QUOTENAME: 'QUOTENAME'; +R: 'R'; +RAISERROR: 'RAISERROR'; +RANDOMIZED: 'RANDOMIZED'; +RANGE: 'RANGE'; +RANK: 'RANK'; +RAW: 'RAW'; +RC2: 'RC2'; +RC4: 'RC4'; +RC4_128: 'RC4_128'; +READ: 'READ'; +READCOMMITTED: 'READCOMMITTED'; +READCOMMITTEDLOCK: 'READCOMMITTEDLOCK'; +READONLY: 'READONLY'; +READPAST: 'READPAST'; +READTEXT: 'READTEXT'; +READUNCOMMITTED: 'READUNCOMMITTED'; +READWRITE: 'READWRITE'; +READ_COMMITTED_SNAPSHOT: 'READ_COMMITTED_SNAPSHOT'; +READ_ONLY: 'READ_ONLY'; +READ_ONLY_ROUTING_LIST: 'READ_ONLY_ROUTING_LIST'; +READ_WRITE: 'READ_WRITE'; +READ_WRITE_FILEGROUPS: 'READ_WRITE_FILEGROUPS'; +REBUILD: 'REBUILD'; +RECEIVE: 'RECEIVE'; +RECOMPILE: 'RECOMPILE'; +RECONFIGURE: 'RECONFIGURE'; +RECOVERY: 'RECOVERY'; +RECURSIVE_TRIGGERS: 'RECURSIVE_TRIGGERS'; +REFERENCES: 'REFERENCES'; +REGENERATE: 'REGENERATE'; +RELATED_CONVERSATION: 'RELATED_CONVERSATION'; +RELATED_CONVERSATION_GROUP: 'RELATED_CONVERSATION_GROUP'; +RELATIVE: 'RELATIVE'; +REMOTE: 'REMOTE'; +REMOTE_PROC_TRANSACTIONS: 'REMOTE_PROC_TRANSACTIONS'; +REMOTE_SERVICE_NAME: 'REMOTE_SERVICE_NAME'; +REMOVE: 'REMOVE'; +REORGANIZE: 'REORGANIZE'; +REPAIR_ALLOW_DATA_LOSS: 'REPAIR_ALLOW_DATA_LOSS'; +REPAIR_FAST: 'REPAIR_FAST'; +REPAIR_REBUILD: 'REPAIR_REBUILD'; +REPEATABLE: 'REPEATABLE'; +REPEATABLEREAD: 'REPEATABLEREAD'; +REPLACE: 'REPLACE'; +REPLICA: 'REPLICA'; +REPLICATE: 'REPLICATE'; +REPLICATION: 'REPLICATION'; +REQUEST_MAX_CPU_TIME_SEC: 'REQUEST_MAX_CPU_TIME_SEC'; +REQUEST_MAX_MEMORY_GRANT_PERCENT: 'REQUEST_MAX_MEMORY_GRANT_PERCENT'; +REQUEST_MEMORY_GRANT_TIMEOUT_SEC: 'REQUEST_MEMORY_GRANT_TIMEOUT_SEC'; +REQUIRED: 'REQUIRED'; +REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT: 'REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT'; +RESAMPLE: 'RESAMPLE'; +RESERVE_DISK_SPACE: 'RESERVE_DISK_SPACE'; +RESET: 'RESET'; +RESOURCE: 'RESOURCE'; +RESOURCES: 'RESOURCES'; +RESOURCE_MANAGER_LOCATION: 'RESOURCE_MANAGER_LOCATION'; +RESTART: 'RESTART'; +RESTORE: 'RESTORE'; +RESTRICT: 'RESTRICT'; +RESTRICTED_USER: 'RESTRICTED_USER'; +RESUMABLE: 'RESUMABLE'; +RESUME: 'RESUME'; +RETAINDAYS: 'RETAINDAYS'; +RETENTION: 'RETENTION'; +RETURN: 'RETURN'; +RETURNS: 'RETURNS'; +REVERSE: 'REVERSE'; +REVERT: 'REVERT'; +REVOKE: 'REVOKE'; +REWIND: 'REWIND'; +RIGHT: 'RIGHT'; +ROBUST: 'ROBUST'; +ROLE: 'ROLE'; +ROLLBACK: 'ROLLBACK'; +ROOT: 'ROOT'; +ROUND_ROBIN: 'ROUND_ROBIN'; +ROUTE: 'ROUTE'; +ROW: 'ROW'; +ROWCOUNT: 'ROWCOUNT'; +ROWCOUNT_BIG: 'ROWCOUNT_BIG'; +ROWGUID: 'ROWGUID'; +ROWGUIDCOL: 'ROWGUIDCOL'; +ROWLOCK: 'ROWLOCK'; +ROWS: 'ROWS'; +ROW_NUMBER: 'ROW_NUMBER'; +RSA_1024: 'RSA_1024'; +RSA_2048: 'RSA_2048'; +RSA_3072: 'RSA_3072'; +RSA_4096: 'RSA_4096'; +RSA_512: 'RSA_512'; +RTRIM: 'RTRIM'; +RULE: 'RULE'; +SAFE: 'SAFE'; +SAFETY: 'SAFETY'; +SAMPLE: 'SAMPLE'; +SAVE: 'SAVE'; +SCHEDULER: 'SCHEDULER'; +SCHEMA: 'SCHEMA'; +SCHEMABINDING: 'SCHEMABINDING'; +SCHEMA_ID: 'SCHEMA_ID'; +SCHEMA_NAME: 'SCHEMA_NAME'; +SCHEME: 'SCHEME'; +SCOPED: 'SCOPED'; +SCOPE_IDENTITY: 'SCOPE_IDENTITY'; +SCRIPT: 'SCRIPT'; +SCROLL: 'SCROLL'; +SCROLL_LOCKS: 'SCROLL_LOCKS'; +SEARCH: 'SEARCH'; +SECONDARY: 'SECONDARY'; +SECONDARY_ONLY: 'SECONDARY_ONLY'; +SECONDARY_ROLE: 'SECONDARY_ROLE'; +SECONDS: 'SECONDS'; +SECRET: 'SECRET'; +SECURABLES: 'SECURABLES'; +SECURITY: 'SECURITY'; +SECURITYAUDIT: 'SECURITYAUDIT'; +SECURITY_LOG: 'SECURITY_LOG'; +SEEDING_MODE: 'SEEDING_MODE'; +SELECT: 'SELECT'; +SELF: 'SELF'; +SEMANTICKEYPHRASETABLE: 'SEMANTICKEYPHRASETABLE'; +SEMANTICSIMILARITYDETAILSTABLE: 'SEMANTICSIMILARITYDETAILSTABLE'; +SEMANTICSIMILARITYTABLE: 'SEMANTICSIMILARITYTABLE'; +SEMI_SENSITIVE: 'SEMI_SENSITIVE'; +SEND: 'SEND'; +SENT: 'SENT'; +SEQUENCE: 'SEQUENCE'; +SEQUENCE_NUMBER: 'SEQUENCE_NUMBER'; +SERIALIZABLE: 'SERIALIZABLE'; +SERVER: 'SERVER'; +SERVERPROPERTY: 'SERVERPROPERTY'; +SERVICE: 'SERVICE'; +SERVICEBROKER: 'SERVICEBROKER'; +SERVICE_BROKER: 'SERVICE_BROKER'; +SERVICE_NAME: 'SERVICE_NAME'; +SESSION: 'SESSION'; +SESSIONPROPERTY: 'SESSIONPROPERTY'; +SESSION_CONTEXT: 'SESSION_CONTEXT'; +SESSION_TIMEOUT: 'SESSION_TIMEOUT'; +SESSION_USER: 'SESSION_USER'; +SET: 'SET'; +SETERROR: 'SETERROR'; +SETS: 'SETS'; +SETTINGS: 'SETTINGS'; +SETUSER: 'SETUSER'; +SHARE: 'SHARE'; +SHARED: 'SHARED'; +SHOWCONTIG: 'SHOWCONTIG'; +SHOWPLAN: 'SHOWPLAN'; +SHOWPLAN_ALL: 'SHOWPLAN_ALL'; +SHOWPLAN_TEXT: 'SHOWPLAN_TEXT'; +SHOWPLAN_XML: 'SHOWPLAN_XML'; +SHRINKLOG: 'SHRINKLOG'; +SHUTDOWN: 'SHUTDOWN'; +SID: 'SID'; +SIGNATURE: 'SIGNATURE'; +SIMPLE: 'SIMPLE'; +SINGLE_USER: 'SINGLE_USER'; +SIZE: 'SIZE'; +SKIP_KEYWORD: 'SKIP'; +SMALLINT: 'SMALLINT'; +SNAPSHOT: 'SNAPSHOT'; +SOFTNUMA: 'SOFTNUMA'; +SOME: 'SOME'; +SORT_IN_TEMPDB: 'SORT_IN_TEMPDB'; +SOUNDEX: 'SOUNDEX'; +SOURCE: 'SOURCE'; +SPACE_KEYWORD: 'SPACE'; +SPARSE: 'SPARSE'; +SPATIAL: 'SPATIAL'; +SPATIAL_WINDOW_MAX_CELLS: 'SPATIAL_WINDOW_MAX_CELLS'; +SPECIFICATION: 'SPECIFICATION'; +SPLIT: 'SPLIT'; +SQL: 'SQL'; +SQLDUMPERFLAGS: 'SQLDUMPERFLAGS'; +SQLDUMPERPATH: 'SQLDUMPERPATH'; +SQLDUMPERTIMEOUT: 'SQLDUMPERTIMEOUT'; +SQL_VARIANT_PROPERTY: 'SQL_VARIANT_PROPERTY'; +STANDBY: 'STANDBY'; +START: 'START'; +STARTED: 'STARTED'; +STARTUP_STATE: 'STARTUP_STATE'; +START_DATE: 'START_DATE'; +STATE: 'STATE'; +STATIC: 'STATIC'; +STATISTICS: 'STATISTICS'; +STATISTICS_INCREMENTAL: 'STATISTICS_INCREMENTAL'; +STATISTICS_NORECOMPUTE: 'STATISTICS_NORECOMPUTE'; +STATS: 'STATS'; +STATS_DATE: 'STATS_DATE'; +STATS_STREAM: 'STATS_STREAM'; +STATUS: 'STATUS'; +STATUSONLY: 'STATUSONLY'; +STDEV: 'STDEV'; +STDEVP: 'STDEVP'; +STOP: 'STOP'; +STOPLIST: 'STOPLIST'; +STOPPED: 'STOPPED'; +STOP_ON_ERROR: 'STOP_ON_ERROR'; +STR: 'STR'; +STRING_AGG: 'STRING_AGG'; +STRING_ESCAPE: 'STRING_ESCAPE'; +STUFF: 'STUFF'; +SUBJECT: 'SUBJECT'; +SUBSCRIBE: 'SUBSCRIBE'; +SUBSCRIPTION: 'SUBSCRIPTION'; +SUBSTRING: 'SUBSTRING'; +SUM: 'SUM'; +SUPPORTED: 'SUPPORTED'; +SUSER_ID: 'SUSER_ID'; +SUSER_NAME: 'SUSER_NAME'; +SUSER_SID: 'SUSER_SID'; +SUSER_SNAME: 'SUSER_SNAME'; +SUSPEND: 'SUSPEND'; +SWITCH: 'SWITCH'; +SYMMETRIC: 'SYMMETRIC'; +SYNCHRONOUS_COMMIT: 'SYNCHRONOUS_COMMIT'; +SYNONYM: 'SYNONYM'; +SYSTEM: 'SYSTEM'; +SYSTEM_USER: 'SYSTEM_USER'; +TABLE: 'TABLE'; +TABLERESULTS: 'TABLERESULTS'; +TABLESAMPLE: 'TABLESAMPLE'; +TABLOCK: 'TABLOCK'; +TABLOCKX: 'TABLOCKX'; +TAKE: 'TAKE'; +TAPE: 'TAPE'; +TARGET: 'TARGET'; +TARGET_RECOVERY_TIME: 'TARGET_RECOVERY_TIME'; +TB: 'TB'; +TCP: 'TCP'; +TEXTIMAGE_ON: 'TEXTIMAGE_ON'; +TEXTSIZE: 'TEXTSIZE'; +THEN: 'THEN'; +THROW: 'THROW'; +TIES: 'TIES'; +TIME: 'TIME'; +TIMEOUT: 'TIMEOUT'; +TIMER: 'TIMER'; +TINYINT: 'TINYINT'; +TO: 'TO'; +TOP: 'TOP'; +TORN_PAGE_DETECTION: 'TORN_PAGE_DETECTION'; +TOSTRING: 'TOSTRING'; +TRACE: 'TRACE'; +TRACKING: 'TRACKING'; +TRACK_CAUSALITY: 'TRACK_CAUSALITY'; +TRAN: 'TRAN'; +TRANSACTION: 'TRANSACTION'; +TRANSACTION_ID: 'TRANSACTION_ID'; +TRANSFER: 'TRANSFER'; +TRANSFORM_NOISE_WORDS: 'TRANSFORM_NOISE_WORDS'; +TRANSLATE: 'TRANSLATE'; +TRIGGER: 'TRIGGER'; +TRIM: 'TRIM'; +TRIPLE_DES: 'TRIPLE_DES'; +TRIPLE_DES_3KEY: 'TRIPLE_DES_3KEY'; +TRUNCATE: 'TRUNCATE'; +TRUSTWORTHY: 'TRUSTWORTHY'; +TRY: 'TRY'; +TRY_CAST: 'TRY_CAST'; +TSEQUAL: 'TSEQUAL'; +TSQL: 'TSQL'; +TWO_DIGIT_YEAR_CUTOFF: 'TWO_DIGIT_YEAR_CUTOFF'; +TYPE: 'TYPE'; +TYPEPROPERTY: 'TYPEPROPERTY'; +TYPE_ID: 'TYPE_ID'; +TYPE_NAME: 'TYPE_NAME'; +TYPE_WARNING: 'TYPE_WARNING'; +UNBOUNDED: 'UNBOUNDED'; +UNCHECKED: 'UNCHECKED'; +UNCOMMITTED: 'UNCOMMITTED'; +UNICODE: 'UNICODE'; +UNION: 'UNION'; +UNIQUE: 'UNIQUE'; +UNKNOWN: 'UNKNOWN'; +UNLIMITED: 'UNLIMITED'; +UNLOCK: 'UNLOCK'; +UNMASK: 'UNMASK'; +UNPIVOT: 'UNPIVOT'; +UNSAFE: 'UNSAFE'; +UOW: 'UOW'; +UPDATE: 'UPDATE'; +UPDATETEXT: 'UPDATETEXT'; +UPDLOCK: 'UPDLOCK'; +UPPER: 'UPPER'; +URL: 'URL'; +USE: 'USE'; +USED: 'USED'; +USER: 'USER'; +USER_ID: 'USER_ID'; +USER_NAME: 'USER_NAME'; +USING: 'USING'; +VALIDATION: 'VALIDATION'; +VALID_XML: 'VALID_XML'; +VALUE: 'VALUE'; +VALUES: 'VALUES'; +VALUE_SQUARE_BRACKET: '[VALUE]'; +VAR: 'VAR'; +VARBINARY_KEYWORD: 'VARBINARY'; +VARP: 'VARP'; +VARYING: 'VARYING'; +VERBOSELOGGING: 'VERBOSELOGGING'; +VERIFY_CLONEDB: 'VERIFY_CLONEDB'; +VERSION: 'VERSION'; +VIEW: 'VIEW'; +VIEWS: 'VIEWS'; +VIEW_METADATA: 'VIEW_METADATA'; +VISIBILITY: 'VISIBILITY'; +WAIT: 'WAIT'; +WAITFOR: 'WAITFOR'; +WAIT_AT_LOW_PRIORITY: 'WAIT_AT_LOW_PRIORITY'; +WELL_FORMED_XML: 'WELL_FORMED_XML'; +WHEN: 'WHEN'; +WHERE: 'WHERE'; +WHILE: 'WHILE'; +WINDOWS: 'WINDOWS'; +WITH: 'WITH'; +WITHIN: 'WITHIN'; +WITHOUT: 'WITHOUT'; +WITHOUT_ARRAY_WRAPPER: 'WITHOUT_ARRAY_WRAPPER'; +WITNESS: 'WITNESS'; +WORK: 'WORK'; +WORKLOAD: 'WORKLOAD'; +WRITETEXT: 'WRITETEXT'; +XACT_ABORT: 'XACT_ABORT'; +XACT_STATE: 'XACT_STATE'; +XLOCK: 'XLOCK'; +XML: 'XML'; +XMLDATA: 'XMLDATA'; +XMLNAMESPACES: 'XMLNAMESPACES'; +XMLSCHEMA: 'XMLSCHEMA'; +XML_COMPRESSION: 'XML_COMPRESSION'; +XSINIL: 'XSINIL'; +ZONE: 'ZONE'; + +ABS: 'ABS'; +ACOS: 'ACOS'; +ASIN: 'ASIN'; +ATAN: 'ATAN'; +ATN2: 'ATN2'; +CEILING: 'CEILING'; +COS: 'COS'; +COT: 'COT'; +DEGREES: 'DEGREES'; +EXP: 'EXP'; +FLOOR: 'FLOOR'; +LOG10: 'LOG10'; +PI: 'PI'; +POWER: 'POWER'; +RADIANS: 'RADIANS'; +RAND: 'RAND'; +ROUND: 'ROUND'; +SIGN: 'SIGN'; +SIN: 'SIN'; +SQRT: 'SQRT'; +SQUARE: 'SQUARE'; +TAN: 'TAN'; + +CURRENT_TIMEZONE: 'CURRENT_TIMEZONE'; +CURRENT_TIMEZONE_ID: 'CURRENT_TIMEZONE_ID'; +DATE_BUCKET: 'DATE_BUCKET'; +DATEDIFF_BIG: 'DATEDIFF_BIG'; +DATEFROMPARTS: 'DATEFROMPARTS'; +DATETIME2FROMPARTS: 'DATETIME2FROMPARTS'; +DATETIMEFROMPARTS: 'DATETIMEFROMPARTS'; +DATETIMEOFFSETFROMPARTS: 'DATETIMEOFFSETFROMPARTS'; +DATETRUNC: 'DATETRUNC'; +DAY: 'DAY'; +EOMONTH: 'EOMONTH'; +ISDATE: 'ISDATE'; +MONTH: 'MONTH'; +SMALLDATETIMEFROMPARTS: 'SMALLDATETIMEFROMPARTS'; +SWITCHOFFSET: 'SWITCHOFFSET'; +SYSDATETIME: 'SYSDATETIME'; +SYSDATETIMEOFFSET: 'SYSDATETIMEOFFSET'; +SYSUTCDATETIME: 'SYSUTCDATETIME'; +TIMEFROMPARTS: 'TIMEFROMPARTS'; +TODATETIMEOFFSET: 'TODATETIMEOFFSET'; +YEAR: 'YEAR'; + +QUARTER: 'QUARTER'; +DAYOFYEAR: 'DAYOFYEAR'; +WEEK: 'WEEK'; +HOUR: 'HOUR'; +MINUTE: 'MINUTE'; +SECOND: 'SECOND'; +MILLISECOND: 'MILLISECOND'; +MICROSECOND: 'MICROSECOND'; +NANOSECOND: 'NANOSECOND'; +TZOFFSET: 'TZOFFSET'; +ISO_WEEK: 'ISO_WEEK'; +WEEKDAY: 'WEEKDAY'; + +YEAR_ABBR: 'yy' | 'yyyy'; +QUARTER_ABBR: 'qq' | 'q'; +MONTH_ABBR: 'mm' | 'm'; +DAYOFYEAR_ABBR: 'dy' | 'y'; +DAY_ABBR: 'dd' | 'd'; +WEEK_ABBR: 'wk' | 'ww'; +HOUR_ABBR: 'hh'; +MINUTE_ABBR: 'mi' | 'n'; +SECOND_ABBR: 'ss' | 's'; +MILLISECOND_ABBR: 'ms'; +MICROSECOND_ABBR: 'mcs'; +NANOSECOND_ABBR: 'ns'; +TZOFFSET_ABBR: 'tz'; +ISO_WEEK_ABBR: 'isowk' | 'isoww'; +WEEKDAY_ABBR: 'dw'; + +SP_EXECUTESQL: 'SP_EXECUTESQL'; + +//Build-ins: +VARCHAR: 'VARCHAR'; +NVARCHAR: 'NVARCHAR'; + +//Combinations that cannot be used as IDs +DISK_DRIVE: [A-Z][:]; +DOLLAR_ACTION: '$ACTION'; + +// Functions starting with double at signs +// https://learn.microsoft.com/en-us/sql/t-sql/language-elements/variables-transact-sql?view=sql-server-ver16 +CURSOR_ROWS: '@@CURSOR_ROWS'; +FETCH_STATUS: '@@FETCH_STATUS'; + +IPV4_ADDR: DEC_DIGIT+ '.' DEC_DIGIT+ '.' DEC_DIGIT+ '.' DEC_DIGIT+; + +SPACE: [ \t\r\n] -> channel(HIDDEN); +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/slash-star-comment-transact-sql +COMMENT: '/*' (COMMENT | .)*? '*/' -> channel(HIDDEN); +LINE_COMMENT: '--' ~[\r\n]* -> channel(HIDDEN); + +// TODO: ID can be not only Latin. +DOUBLE_QUOTE_ID: '"' ~'"'+ '"'; +DOUBLE_QUOTE_BLANK: '""'; +SINGLE_QUOTE: '\''; +SQUARE_BRACKET_ID: '[' (~']' | ']' ']')* ']'; +LOCAL_ID: '@' ([A-Z_$@#0-9] | FullWidthLetter)*; +TEMP_ID: '#' ([A-Z_$@#0-9] | FullWidthLetter)*; +DECIMAL: DEC_DIGIT+; +ID: ( [A-Z_#] | FullWidthLetter) ( [A-Z_#$@0-9] | FullWidthLetter )*; +STRING options { caseInsensitive=false; } : 'N'? '\'' (~'\'' | '\'\'')* '\''; +BINARY: '0' 'X' HEX_DIGIT*; +FLOAT: DEC_DOT_DEC; +REAL: (DECIMAL | DEC_DOT_DEC) ('E' [+-]? DEC_DIGIT+); + +EQUAL: '='; + +GREATER: '>'; +LESS: '<'; +EXCLAMATION: '!'; + +PLUS_ASSIGN: '+='; +MINUS_ASSIGN: '-='; +MULT_ASSIGN: '*='; +DIV_ASSIGN: '/='; +MOD_ASSIGN: '%='; +AND_ASSIGN: '&='; +XOR_ASSIGN: '^='; +OR_ASSIGN: '|='; + +DOUBLE_BAR: '||'; +DOT: '.'; +UNDERLINE: '_'; +AT: '@'; +SHARP: '#'; +DOLLAR: '$'; +LR_BRACKET: '('; +RR_BRACKET: ')'; +COMMA: ','; +SEMI: ';'; +COLON: ':'; +DOUBLE_COLON: '::'; +STAR: '*'; +DIVIDE: '/'; +MODULE: '%'; +PLUS: '+'; +MINUS: '-'; +BIT_NOT: '~'; +BIT_OR: '|'; +BIT_AND: '&'; +BIT_XOR: '^'; + +PLACEHOLDER: '?'; + +fragment LETTER: [A-Z_]; +fragment DEC_DOT_DEC: (DEC_DIGIT+ '.' DEC_DIGIT+ | DEC_DIGIT+ '.' | '.' DEC_DIGIT+); +fragment HEX_DIGIT: [0-9A-F]; +fragment DEC_DIGIT: [0-9]; + + +fragment FullWidthLetter options { caseInsensitive=false; } + : '\u00c0'..'\u00d6' + | '\u00d8'..'\u00f6' + | '\u00f8'..'\u00ff' + | '\u0100'..'\u1fff' + | '\u2c00'..'\u2fff' + | '\u3040'..'\u318f' + | '\u3300'..'\u337f' + | '\u3400'..'\u3fff' + | '\u4e00'..'\u9fff' + | '\ua000'..'\ud7ff' + | '\uf900'..'\ufaff' + | '\uff00'..'\ufff0' + // | '\u10000'..'\u1F9FF' //not support four bytes chars + // | '\u20000'..'\u2FA1F' + ; diff --git a/tsql/TSqlParser.g4 b/tsql/TSqlParser.g4 new file mode 100644 index 0000000..b90b384 --- /dev/null +++ b/tsql/TSqlParser.g4 @@ -0,0 +1,6147 @@ +/* +T-SQL (Transact-SQL, MSSQL) grammar. +The MIT License (MIT). +Copyright (c) 2017, Mark Adams (madams51703@gmail.com) +Copyright (c) 2015-2017, Ivan Kochurkin (kvanttt@gmail.com), Positive Technologies. +Copyright (c) 2016, Scott Ure (scott@redstormsoftware.com). +Copyright (c) 2016, Rui Zhang (ruizhang.ccs@gmail.com). +Copyright (c) 2016, Marcus Henriksson (kuseman80@gmail.com). +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +parser grammar TSqlParser; + +options { tokenVocab=TSqlLexer; } + +tsql_file + : go_statement* EOF + | batch_without_go (go_statement batch_without_go?)* go_statement? EOF + ; + +batch_without_go + : sql_clauses+ + | batch_level_statement + | execute_body_batch sql_clauses* + ; + +batch_level_statement + : create_or_alter_function + | create_or_alter_procedure + | create_or_alter_trigger + | create_view + ; +sql_clauses + : dml_clause SEMI? + | cfl_statement SEMI? + | another_statement SEMI? + | ddl_clause SEMI? + | dbcc_clause SEMI? + | backup_statement SEMI? + | SEMI + ; + +// Data Manipulation Language: https://msdn.microsoft.com/en-us/library/ff848766(v=sql.120).aspx +dml_clause + : merge_statement + | delete_statement + | insert_statement + | select_statement_standalone + | update_statement + ; + +// Data Definition Language: https://msdn.microsoft.com/en-us/library/ff848799.aspx) +ddl_clause + : alter_application_role + | alter_assembly + | alter_asymmetric_key + | alter_authorization + | alter_authorization_for_azure_dw + | alter_authorization_for_parallel_dw + | alter_authorization_for_sql_database + | alter_availability_group + | alter_certificate + | alter_column_encryption_key + | alter_credential + | alter_cryptographic_provider + | alter_database + | alter_database_audit_specification + | alter_db_role + | alter_endpoint + | alter_external_data_source + | alter_external_library + | alter_external_resource_pool + | alter_fulltext_catalog + | alter_fulltext_stoplist + | alter_index + | alter_login_azure_sql + | alter_login_azure_sql_dw_and_pdw + | alter_login_sql_server + | alter_master_key_azure_sql + | alter_master_key_sql_server + | alter_message_type + | alter_partition_function + | alter_partition_scheme + | alter_remote_service_binding + | alter_resource_governor + | alter_schema_azure_sql_dw_and_pdw + | alter_schema_sql + | alter_sequence + | alter_server_audit + | alter_server_audit_specification + | alter_server_configuration + | alter_server_role + | alter_server_role_pdw + | alter_service + | alter_service_master_key + | alter_symmetric_key + | alter_table + | alter_user + | alter_user_azure_sql + | alter_workload_group + | alter_xml_schema_collection + | create_application_role + | create_assembly + | create_asymmetric_key + | create_column_encryption_key + | create_column_master_key + | create_columnstore_index + | create_credential + | create_cryptographic_provider + | create_database + | create_database_audit_specification + | create_db_role + | create_endpoint + | create_event_notification + | create_external_library + | create_external_resource_pool + | create_fulltext_catalog + | create_fulltext_stoplist + | create_index + | create_login_azure_sql + | create_login_pdw + | create_login_sql_server + | create_master_key_azure_sql + | create_master_key_sql_server + | create_nonclustered_columnstore_index + | create_or_alter_broker_priority + | create_or_alter_event_session + | create_partition_function + | create_partition_scheme + | create_remote_service_binding + | create_resource_pool + | create_route + | create_rule + | create_schema + | create_schema_azure_sql_dw_and_pdw + | create_spatial_index + | create_search_property_list + | create_security_policy + | create_sequence + | create_server_audit + | create_server_audit_specification + | create_server_role + | create_service + | create_statistics + | create_synonym + | create_table + | create_type + | create_user + | create_user_azure_sql_dw + | create_workload_group + | create_xml_index + | create_xml_schema_collection + | disable_trigger + | drop_aggregate + | drop_application_role + | drop_assembly + | drop_asymmetric_key + | drop_availability_group + | drop_broker_priority + | drop_certificate + | drop_column_encryption_key + | drop_column_master_key + | drop_contract + | drop_credential + | drop_cryptograhic_provider + | drop_database + | drop_database_audit_specification + | drop_database_encryption_key + | drop_database_scoped_credential + | drop_db_role + | drop_default + | drop_endpoint + | drop_event_notifications + | drop_event_session + | drop_external_data_source + | drop_external_file_format + | drop_external_library + | drop_external_resource_pool + | drop_external_table + | drop_fulltext_catalog + | drop_fulltext_index + | drop_fulltext_stoplist + | drop_function + | drop_index + | drop_login + | drop_master_key + | drop_message_type + | drop_partition_function + | drop_partition_scheme + | drop_procedure + | drop_queue + | drop_remote_service_binding + | drop_resource_pool + | drop_route + | drop_rule + | drop_schema + | drop_search_property_list + | drop_security_policy + | drop_sequence + | drop_server_audit + | drop_server_audit_specification + | drop_server_role + | drop_service + | drop_signature + | drop_statistics + | drop_statistics_name_azure_dw_and_pdw + | drop_symmetric_key + | drop_synonym + | drop_table + | drop_trigger + | drop_type + | drop_user + | drop_view + | drop_workload_group + | drop_xml_schema_collection + | enable_trigger + | lock_table + | truncate_table + | update_statistics + ; + +backup_statement + : backup_database + | backup_log + | backup_certificate + | backup_master_key + | backup_service_master_key + ; + +// Control-of-Flow Language: https://docs.microsoft.com/en-us/sql/t-sql/language-elements/control-of-flow +cfl_statement + : block_statement + | break_statement + | continue_statement + | goto_statement + | if_statement + | print_statement + | raiseerror_statement + | return_statement + | throw_statement + | try_catch_statement + | waitfor_statement + | while_statement + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/begin-end-transact-sql +block_statement + : BEGIN ';'? sql_clauses* END ';'? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/break-transact-sql +break_statement + : BREAK ';'? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/continue-transact-sql +continue_statement + : CONTINUE ';'? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/goto-transact-sql +goto_statement + : GOTO id_ ';'? + | id_ ':' ';'? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/return-transact-sql +return_statement + : RETURN expression? ';'? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/if-else-transact-sql +if_statement + : IF search_condition sql_clauses (ELSE sql_clauses)? ';'? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/throw-transact-sql +throw_statement + : THROW (throw_error_number ',' throw_message ',' throw_state)? ';'? + ; + +throw_error_number + : DECIMAL | LOCAL_ID + ; + +throw_message + : STRING | LOCAL_ID + ; + +throw_state + : DECIMAL | LOCAL_ID + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/try-catch-transact-sql +try_catch_statement + : BEGIN TRY ';'? try_clauses=sql_clauses+ END TRY ';'? BEGIN CATCH ';'? catch_clauses=sql_clauses* END CATCH ';'? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/waitfor-transact-sql +waitfor_statement + : WAITFOR receive_statement? ','? ((DELAY | TIME | TIMEOUT) time)? expression? ';'? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/while-transact-sql +while_statement + : WHILE search_condition (sql_clauses | BREAK ';'? | CONTINUE ';'?) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/print-transact-sql +print_statement + : PRINT (expression | DOUBLE_QUOTE_ID) (',' LOCAL_ID)* ';'? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/raiserror-transact-sql +raiseerror_statement + : RAISERROR '(' msg=(DECIMAL | STRING | LOCAL_ID) ',' severity=constant_LOCAL_ID ',' + state=constant_LOCAL_ID (',' (constant_LOCAL_ID | NULL_))* ')' (WITH (LOG | SETERROR | NOWAIT))? ';'? + | RAISERROR DECIMAL formatstring=(STRING | LOCAL_ID | DOUBLE_QUOTE_ID) (',' argument=(DECIMAL | STRING | LOCAL_ID))* + ; + +empty_statement + : ';' + ; + +another_statement + : alter_queue + | checkpoint_statement + | conversation_statement + | create_contract + | create_queue + | cursor_statement + | declare_statement + | execute_statement + | kill_statement + | message_statement + | reconfigure_statement + | security_statement + | set_statement + | setuser_statement + | shutdown_statement + | transaction_statement + | use_statement + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-application-role-transact-sql +alter_application_role + : ALTER APPLICATION ROLE appliction_role=id_ WITH (COMMA? NAME EQUAL new_application_role_name=id_)? (COMMA? PASSWORD EQUAL application_role_password=STRING)? (COMMA? DEFAULT_SCHEMA EQUAL app_role_default_schema=id_)? + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/statements/alter-xml-schema-collection-transact-sql?view=sql-server-ver16 +alter_xml_schema_collection + : ALTER XML SCHEMA COLLECTION (id_ '.')? id_ ADD STRING + ; + +create_application_role + : CREATE APPLICATION ROLE appliction_role=id_ WITH (COMMA? PASSWORD EQUAL application_role_password=STRING)? (COMMA? DEFAULT_SCHEMA EQUAL app_role_default_schema=id_)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-aggregate-transact-sql + +drop_aggregate + : DROP AGGREGATE ( IF EXISTS )? ( schema_name=id_ DOT )? aggregate_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-application-role-transact-sql +drop_application_role + : DROP APPLICATION ROLE rolename=id_ + ; + +alter_assembly + : alter_assembly_start assembly_name=id_ alter_assembly_clause + ; + +alter_assembly_start + : ALTER ASSEMBLY + ; + +alter_assembly_clause + : alter_assembly_from_clause? alter_assembly_with_clause? alter_assembly_drop_clause? alter_assembly_add_clause? + ; + +alter_assembly_from_clause + : alter_assembly_from_clause_start (client_assembly_specifier | alter_assembly_file_bits ) + ; + +alter_assembly_from_clause_start + : FROM + ; + +alter_assembly_drop_clause + : alter_assembly_drop alter_assembly_drop_multiple_files + ; + +alter_assembly_drop_multiple_files + : ALL + | multiple_local_files + ; + +alter_assembly_drop + : DROP + ; + +alter_assembly_add_clause + : alter_asssembly_add_clause_start alter_assembly_client_file_clause + ; + +alter_asssembly_add_clause_start + : ADD FILE FROM + ; + +// need to implement +alter_assembly_client_file_clause + : alter_assembly_file_name (alter_assembly_as id_)? + ; + +alter_assembly_file_name + : STRING + ; + +//need to implement +alter_assembly_file_bits + : alter_assembly_as id_ + ; + +alter_assembly_as + : AS + ; + +alter_assembly_with_clause + : alter_assembly_with assembly_option + ; + +alter_assembly_with + : WITH + ; + +client_assembly_specifier + : network_file_share + | local_file + | STRING + ; + +assembly_option + : PERMISSION_SET EQUAL (SAFE|EXTERNAL_ACCESS|UNSAFE) + | VISIBILITY EQUAL on_off + | UNCHECKED DATA + | assembly_option COMMA + ; + +network_file_share + : network_file_start network_computer file_path + ; + +network_computer + : computer_name=id_ + ; + +network_file_start + : DOUBLE_BACK_SLASH + ; + +file_path + : file_directory_path_separator file_path + | id_ + ; + +file_directory_path_separator + : '\\' + ; + +local_file + : local_drive file_path + ; + +local_drive + : + DISK_DRIVE + ; +multiple_local_files + : + multiple_local_file_start local_file SINGLE_QUOTE COMMA + | local_file + ; + +multiple_local_file_start + : SINGLE_QUOTE + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-assembly-transact-sql +create_assembly + : CREATE ASSEMBLY assembly_name=id_ (AUTHORIZATION owner_name=id_)? + FROM (COMMA? (STRING|BINARY) )+ + (WITH PERMISSION_SET EQUAL (SAFE|EXTERNAL_ACCESS|UNSAFE) )? + + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-assembly-transact-sql +drop_assembly + : DROP ASSEMBLY ( IF EXISTS )? (COMMA? assembly_name=id_)+ + ( WITH NO DEPENDENTS )? + ; +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-asymmetric-key-transact-sql + +alter_asymmetric_key + : alter_asymmetric_key_start Asym_Key_Name=id_ (asymmetric_key_option | REMOVE PRIVATE KEY ) + ; + +alter_asymmetric_key_start + : ALTER ASYMMETRIC KEY + ; + +asymmetric_key_option + : asymmetric_key_option_start asymmetric_key_password_change_option ( COMMA asymmetric_key_password_change_option)? RR_BRACKET + ; + +asymmetric_key_option_start + : WITH PRIVATE KEY LR_BRACKET + ; + +asymmetric_key_password_change_option + : DECRYPTION BY PASSWORD EQUAL STRING + | ENCRYPTION BY PASSWORD EQUAL STRING + ; + + +//https://docs.microsoft.com/en-us/sql/t-sql/statements/create-asymmetric-key-transact-sql + +create_asymmetric_key + : CREATE ASYMMETRIC KEY Asym_Key_Nam=id_ + (AUTHORIZATION database_principal_name=id_)? + ( FROM (FILE EQUAL STRING |EXECUTABLE_FILE EQUAL STRING|ASSEMBLY Assembly_Name=id_ | PROVIDER Provider_Name=id_) )? + (WITH (ALGORITHM EQUAL ( RSA_4096 | RSA_3072 | RSA_2048 | RSA_1024 | RSA_512) |PROVIDER_KEY_NAME EQUAL provider_key_name=STRING | CREATION_DISPOSITION EQUAL (CREATE_NEW|OPEN_EXISTING) ) )? + (ENCRYPTION BY PASSWORD EQUAL asymmetric_key_password=STRING )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-asymmetric-key-transact-sql +drop_asymmetric_key + : DROP ASYMMETRIC KEY key_name=id_ ( REMOVE PROVIDER KEY )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-authorization-transact-sql + +alter_authorization + : alter_authorization_start (class_type colon_colon)? entity=entity_name entity_to authorization_grantee + ; + +authorization_grantee + : principal_name=id_ + | SCHEMA OWNER + ; + +entity_to + : TO + ; + +colon_colon + : DOUBLE_COLON + ; + +alter_authorization_start + : ALTER AUTHORIZATION ON + ; + +alter_authorization_for_sql_database + : alter_authorization_start (class_type_for_sql_database colon_colon)? entity=entity_name entity_to authorization_grantee + ; + +alter_authorization_for_azure_dw + : alter_authorization_start (class_type_for_azure_dw colon_colon)? entity=entity_name_for_azure_dw entity_to authorization_grantee + ; + +alter_authorization_for_parallel_dw + : alter_authorization_start (class_type_for_parallel_dw colon_colon)? entity=entity_name_for_parallel_dw entity_to authorization_grantee + ; + + +class_type + : OBJECT + | ASSEMBLY + | ASYMMETRIC KEY + | AVAILABILITY GROUP + | CERTIFICATE + | CONTRACT + | TYPE + | DATABASE + | ENDPOINT + | FULLTEXT CATALOG + | FULLTEXT STOPLIST + | MESSAGE TYPE + | REMOTE SERVICE BINDING + | ROLE + | ROUTE + | SCHEMA + | SEARCH PROPERTY LIST + | SERVER ROLE + | SERVICE + | SYMMETRIC KEY + | XML SCHEMA COLLECTION + ; + +class_type_for_sql_database + : OBJECT + | ASSEMBLY + | ASYMMETRIC KEY + | CERTIFICATE + | TYPE + | DATABASE + | FULLTEXT CATALOG + | FULLTEXT STOPLIST + | ROLE + | SCHEMA + | SEARCH PROPERTY LIST + | SYMMETRIC KEY + | XML SCHEMA COLLECTION + ; + +class_type_for_azure_dw + : SCHEMA + | OBJECT + ; + +class_type_for_parallel_dw + : DATABASE + | SCHEMA + | OBJECT + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/grant-transact-sql?view=sql-server-ver15 +// SELECT DISTINCT '| ' + CLASS_DESC +// FROM sys.dm_audit_actions +// ORDER BY 1 +class_type_for_grant + : APPLICATION ROLE + | ASSEMBLY + | ASYMMETRIC KEY + | AUDIT + | AVAILABILITY GROUP + | BROKER PRIORITY + | CERTIFICATE + | COLUMN ( ENCRYPTION | MASTER ) KEY + | CONTRACT + | CREDENTIAL + | CRYPTOGRAPHIC PROVIDER + | DATABASE ( AUDIT SPECIFICATION + | ENCRYPTION KEY + | EVENT SESSION + | SCOPED ( CONFIGURATION + | CREDENTIAL + | RESOURCE GOVERNOR ) + )? + | ENDPOINT + | EVENT SESSION + | NOTIFICATION (DATABASE | OBJECT | SERVER) + | EXTERNAL ( DATA SOURCE + | FILE FORMAT + | LIBRARY + | RESOURCE POOL + | TABLE + | CATALOG + | STOPLIST + ) + | LOGIN + | MASTER KEY + | MESSAGE TYPE + | OBJECT + | PARTITION ( FUNCTION | SCHEME) + | REMOTE SERVICE BINDING + | RESOURCE GOVERNOR + | ROLE + | ROUTE + | SCHEMA + | SEARCH PROPERTY LIST + | SERVER ( ( AUDIT SPECIFICATION? ) | ROLE )? + | SERVICE + | SQL LOGIN + | SYMMETRIC KEY + | TRIGGER ( DATABASE | SERVER) + | TYPE + | USER + | XML SCHEMA COLLECTION + ; + + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-availability-group-transact-sql +drop_availability_group + : DROP AVAILABILITY GROUP group_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-availability-group-transact-sql +alter_availability_group + : alter_availability_group_start alter_availability_group_options + ; + +alter_availability_group_start + : ALTER AVAILABILITY GROUP group_name=id_ + ; + +alter_availability_group_options + : SET LR_BRACKET ( ( AUTOMATED_BACKUP_PREFERENCE EQUAL ( PRIMARY | SECONDARY_ONLY| SECONDARY | NONE ) | FAILURE_CONDITION_LEVEL EQUAL DECIMAL | HEALTH_CHECK_TIMEOUT EQUAL milliseconds=DECIMAL | DB_FAILOVER EQUAL ( ON | OFF ) | REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT EQUAL DECIMAL ) RR_BRACKET ) + | ADD DATABASE database_name=id_ + | REMOVE DATABASE database_name=id_ + | ADD REPLICA ON server_instance=STRING (WITH LR_BRACKET ( (ENDPOINT_URL EQUAL STRING)? (COMMA? AVAILABILITY_MODE EQUAL (SYNCHRONOUS_COMMIT| ASYNCHRONOUS_COMMIT))? (COMMA? FAILOVER_MODE EQUAL (AUTOMATIC|MANUAL) )? (COMMA? SEEDING_MODE EQUAL (AUTOMATIC|MANUAL) )? (COMMA? BACKUP_PRIORITY EQUAL DECIMAL)? ( COMMA? PRIMARY_ROLE LR_BRACKET ALLOW_CONNECTIONS EQUAL ( READ_WRITE | ALL ) RR_BRACKET)? ( COMMA? SECONDARY_ROLE LR_BRACKET ALLOW_CONNECTIONS EQUAL ( READ_ONLY ) RR_BRACKET )? ) +) RR_BRACKET + |SECONDARY_ROLE LR_BRACKET (ALLOW_CONNECTIONS EQUAL (NO|READ_ONLY|ALL) | READ_ONLY_ROUTING_LIST EQUAL ( LR_BRACKET ( ( STRING) ) RR_BRACKET ) ) + |PRIMARY_ROLE LR_BRACKET (ALLOW_CONNECTIONS EQUAL (NO|READ_ONLY|ALL) | READ_ONLY_ROUTING_LIST EQUAL ( LR_BRACKET ( (COMMA? STRING)*|NONE ) RR_BRACKET ) + | SESSION_TIMEOUT EQUAL session_timeout=DECIMAL +) + | MODIFY REPLICA ON server_instance=STRING (WITH LR_BRACKET (ENDPOINT_URL EQUAL STRING| AVAILABILITY_MODE EQUAL (SYNCHRONOUS_COMMIT| ASYNCHRONOUS_COMMIT) | FAILOVER_MODE EQUAL (AUTOMATIC|MANUAL) | SEEDING_MODE EQUAL (AUTOMATIC|MANUAL) | BACKUP_PRIORITY EQUAL DECIMAL ) + |SECONDARY_ROLE LR_BRACKET (ALLOW_CONNECTIONS EQUAL (NO|READ_ONLY|ALL) | READ_ONLY_ROUTING_LIST EQUAL ( LR_BRACKET ( ( STRING) ) RR_BRACKET ) ) + |PRIMARY_ROLE LR_BRACKET (ALLOW_CONNECTIONS EQUAL (NO|READ_ONLY|ALL) | READ_ONLY_ROUTING_LIST EQUAL ( LR_BRACKET ( (COMMA? STRING)*|NONE ) RR_BRACKET ) + | SESSION_TIMEOUT EQUAL session_timeout=DECIMAL +) ) RR_BRACKET + | REMOVE REPLICA ON STRING + | JOIN + | JOIN AVAILABILITY GROUP ON (COMMA? ag_name=STRING WITH LR_BRACKET ( LISTENER_URL EQUAL STRING COMMA AVAILABILITY_MODE EQUAL (SYNCHRONOUS_COMMIT|ASYNCHRONOUS_COMMIT) COMMA FAILOVER_MODE EQUAL MANUAL COMMA SEEDING_MODE EQUAL (AUTOMATIC|MANUAL) RR_BRACKET ) )+ + | MODIFY AVAILABILITY GROUP ON (COMMA? ag_name_modified=STRING WITH LR_BRACKET (LISTENER_URL EQUAL STRING (COMMA? AVAILABILITY_MODE EQUAL (SYNCHRONOUS_COMMIT|ASYNCHRONOUS_COMMIT) )? (COMMA? FAILOVER_MODE EQUAL MANUAL )? (COMMA? SEEDING_MODE EQUAL (AUTOMATIC|MANUAL))? RR_BRACKET ) )+ + |GRANT CREATE ANY DATABASE + | DENY CREATE ANY DATABASE + | FAILOVER + | FORCE_FAILOVER_ALLOW_DATA_LOSS + | ADD LISTENER listener_name=STRING LR_BRACKET ( WITH DHCP (ON LR_BRACKET ip_v4_failover ip_v4_failover RR_BRACKET ) | WITH IP LR_BRACKET ( (COMMA? LR_BRACKET ( ip_v4_failover COMMA ip_v4_failover | ip_v6_failover ) RR_BRACKET)+ RR_BRACKET (COMMA PORT EQUAL DECIMAL)? ) ) RR_BRACKET + | MODIFY LISTENER (ADD IP LR_BRACKET (ip_v4_failover ip_v4_failover | ip_v6_failover) RR_BRACKET | PORT EQUAL DECIMAL ) + |RESTART LISTENER STRING + |REMOVE LISTENER STRING + |OFFLINE + | WITH LR_BRACKET DTC_SUPPORT EQUAL PER_DB RR_BRACKET + ; + +ip_v4_failover + : STRING + ; + +ip_v6_failover + : STRING + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-broker-priority-transact-sql +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-broker-priority-transact-sql +create_or_alter_broker_priority + : (CREATE | ALTER) BROKER PRIORITY ConversationPriorityName=id_ FOR CONVERSATION + SET LR_BRACKET + ( CONTRACT_NAME EQUAL ( ( id_) | ANY ) COMMA? )? + ( LOCAL_SERVICE_NAME EQUAL (DOUBLE_FORWARD_SLASH? id_ | ANY ) COMMA? )? + ( REMOTE_SERVICE_NAME EQUAL (RemoteServiceName=STRING | ANY ) COMMA? )? + ( PRIORITY_LEVEL EQUAL ( PriorityValue=DECIMAL | DEFAULT ) ) ? + RR_BRACKET + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-broker-priority-transact-sql +drop_broker_priority + : DROP BROKER PRIORITY ConversationPriorityName=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-certificate-transact-sql +alter_certificate + : ALTER CERTIFICATE certificate_name=id_ (REMOVE PRIVATE_KEY | WITH PRIVATE KEY LR_BRACKET ( FILE EQUAL STRING COMMA? | DECRYPTION BY PASSWORD EQUAL STRING COMMA?| ENCRYPTION BY PASSWORD EQUAL STRING COMMA?)+ RR_BRACKET | WITH ACTIVE FOR BEGIN_DIALOG EQUAL ( ON | OFF ) ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-column-encryption-key-transact-sql +alter_column_encryption_key + : ALTER COLUMN ENCRYPTION KEY column_encryption_key=id_ (ADD | DROP) VALUE LR_BRACKET COLUMN_MASTER_KEY EQUAL column_master_key_name=id_ ( COMMA ALGORITHM EQUAL algorithm_name=STRING COMMA ENCRYPTED_VALUE EQUAL BINARY)? RR_BRACKET + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-column-encryption-key-transact-sql +create_column_encryption_key + : CREATE COLUMN ENCRYPTION KEY column_encryption_key=id_ + WITH VALUES + (LR_BRACKET COMMA? COLUMN_MASTER_KEY EQUAL column_master_key_name=id_ COMMA + ALGORITHM EQUAL algorithm_name=STRING COMMA + ENCRYPTED_VALUE EQUAL encrypted_value=BINARY RR_BRACKET COMMA?)+ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-certificate-transact-sql +drop_certificate + : DROP CERTIFICATE certificate_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-column-encryption-key-transact-sql +drop_column_encryption_key + : DROP COLUMN ENCRYPTION KEY key_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-column-master-key-transact-sql +drop_column_master_key + : DROP COLUMN MASTER KEY key_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-contract-transact-sql +drop_contract + : DROP CONTRACT dropped_contract_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-credential-transact-sql +drop_credential + : DROP CREDENTIAL credential_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-cryptographic-provider-transact-sql +drop_cryptograhic_provider + : DROP CRYPTOGRAPHIC PROVIDER provider_name=id_ + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-database-transact-sql +drop_database + : DROP DATABASE ( IF EXISTS )? (COMMA? database_name_or_database_snapshot_name=id_)+ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-database-audit-specification-transact-sql +drop_database_audit_specification + : DROP DATABASE AUDIT SPECIFICATION audit_specification_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-database-encryption-key-transact-sql?view=sql-server-ver15 +drop_database_encryption_key + : DROP DATABASE ENCRYPTION KEY + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-database-scoped-credential-transact-sql +drop_database_scoped_credential + : DROP DATABASE SCOPED CREDENTIAL credential_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-default-transact-sql +drop_default + : DROP DEFAULT ( IF EXISTS )? (COMMA? (schema_name=id_ DOT)? default_name=id_) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-endpoint-transact-sql +drop_endpoint + : DROP ENDPOINT endPointName=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-external-data-source-transact-sql +drop_external_data_source + : DROP EXTERNAL DATA SOURCE external_data_source_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-external-file-format-transact-sql +drop_external_file_format + : DROP EXTERNAL FILE FORMAT external_file_format_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-external-library-transact-sql +drop_external_library + : DROP EXTERNAL LIBRARY library_name=id_ +( AUTHORIZATION owner_name=id_ )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-external-resource-pool-transact-sql +drop_external_resource_pool + : DROP EXTERNAL RESOURCE POOL pool_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-external-table-transact-sql +drop_external_table + : DROP EXTERNAL TABLE (database_name=id_ DOT)? (schema_name=id_ DOT)? table=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-event-notification-transact-sql +drop_event_notifications + : DROP EVENT NOTIFICATION (COMMA? notification_name=id_)+ + ON (SERVER|DATABASE|QUEUE queue_name=id_) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-event-session-transact-sql +drop_event_session + : DROP EVENT SESSION event_session_name=id_ + ON SERVER + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-fulltext-catalog-transact-sql +drop_fulltext_catalog + : DROP FULLTEXT CATALOG catalog_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-fulltext-index-transact-sql +drop_fulltext_index + : DROP FULLTEXT INDEX ON (schema=id_ DOT)? table=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-fulltext-stoplist-transact-sql +drop_fulltext_stoplist + : DROP FULLTEXT STOPLIST stoplist_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-login-transact-sql +drop_login + : DROP LOGIN login_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-master-key-transact-sql +drop_master_key + : DROP MASTER KEY + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-message-type-transact-sql +drop_message_type + : DROP MESSAGE TYPE message_type_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-partition-function-transact-sql +drop_partition_function + : DROP PARTITION FUNCTION partition_function_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-partition-scheme-transact-sql +drop_partition_scheme + : DROP PARTITION SCHEME partition_scheme_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-queue-transact-sql +drop_queue + : DROP QUEUE (database_name=id_ DOT)? (schema_name=id_ DOT)? queue_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-remote-service-binding-transact-sql +drop_remote_service_binding + : DROP REMOTE SERVICE BINDING binding_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-resource-pool-transact-sql +drop_resource_pool + : DROP RESOURCE POOL pool_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-role-transact-sql +drop_db_role + : DROP ROLE ( IF EXISTS )? role_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-route-transact-sql +drop_route + : DROP ROUTE route_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-rule-transact-sql +drop_rule + : DROP RULE ( IF EXISTS )? (COMMA? (schema_name=id_ DOT)? rule_name=id_)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-schema-transact-sql +drop_schema + : DROP SCHEMA ( IF EXISTS )? schema_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-search-property-list-transact-sql +drop_search_property_list + : DROP SEARCH PROPERTY LIST property_list_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-security-policy-transact-sql +drop_security_policy + : DROP SECURITY POLICY ( IF EXISTS )? (schema_name=id_ DOT )? security_policy_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-sequence-transact-sql +drop_sequence + : DROP SEQUENCE ( IF EXISTS )? ( COMMA? (database_name=id_ DOT)? (schema_name=id_ DOT)? sequence_name=id_ )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-server-audit-transact-sql +drop_server_audit + : DROP SERVER AUDIT audit_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-server-audit-specification-transact-sql +drop_server_audit_specification + : DROP SERVER AUDIT SPECIFICATION audit_specification_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-server-role-transact-sql +drop_server_role + : DROP SERVER ROLE role_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-service-transact-sql +drop_service + : DROP SERVICE dropped_service_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-signature-transact-sql +drop_signature + : DROP ( COUNTER )? SIGNATURE FROM (schema_name=id_ DOT)? module_name=id_ + BY (COMMA? CERTIFICATE cert_name=id_ + | COMMA? ASYMMETRIC KEY Asym_key_name=id_ + )+ + ; + + +drop_statistics_name_azure_dw_and_pdw + : DROP STATISTICS (schema_name=id_ DOT)? object_name=id_ DOT statistics_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-symmetric-key-transact-sql +drop_symmetric_key + : DROP SYMMETRIC KEY symmetric_key_name=id_ (REMOVE PROVIDER KEY)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-synonym-transact-sql +drop_synonym + : DROP SYNONYM ( IF EXISTS )? ( schema=id_ DOT )? synonym_name=id_ + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-user-transact-sql +drop_user + : DROP USER ( IF EXISTS )? user_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-workload-group-transact-sql +drop_workload_group + : DROP WORKLOAD GROUP group_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-xml-schema-collection-transact-sql +drop_xml_schema_collection + : DROP XML SCHEMA COLLECTION ( relational_schema=id_ DOT )? sql_identifier=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/disable-trigger-transact-sql +disable_trigger + : DISABLE TRIGGER ( ( COMMA? (schema_name=id_ DOT)? trigger_name=id_ )+ | ALL) ON ((schema_id=id_ DOT)? object_name=id_|DATABASE|ALL SERVER) + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/enable-trigger-transact-sql +enable_trigger + : ENABLE TRIGGER ( ( COMMA? (schema_name=id_ DOT)? trigger_name=id_ )+ | ALL) ON ( (schema_id=id_ DOT)? object_name=id_|DATABASE|ALL SERVER) + ; + +lock_table + : LOCK TABLE table_name IN (SHARE | EXCLUSIVE) MODE (WAIT seconds=DECIMAL | NOWAIT)? ';'? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/truncate-table-transact-sql +truncate_table + : TRUNCATE TABLE table_name + ( WITH LR_BRACKET + PARTITIONS LR_BRACKET + (COMMA? (DECIMAL|DECIMAL TO DECIMAL) )+ + RR_BRACKET + + RR_BRACKET + )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-column-master-key-transact-sql +create_column_master_key + : CREATE COLUMN MASTER KEY key_name=id_ + WITH LR_BRACKET + KEY_STORE_PROVIDER_NAME EQUAL key_store_provider_name=STRING COMMA + KEY_PATH EQUAL key_path=STRING + RR_BRACKET + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-credential-transact-sql +alter_credential + : ALTER CREDENTIAL credential_name=id_ + WITH IDENTITY EQUAL identity_name=STRING + ( COMMA SECRET EQUAL secret=STRING )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-credential-transact-sql +create_credential + : CREATE CREDENTIAL credential_name=id_ + WITH IDENTITY EQUAL identity_name=STRING + ( COMMA SECRET EQUAL secret=STRING )? + ( FOR CRYPTOGRAPHIC PROVIDER cryptographic_provider_name=id_ )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-cryptographic-provider-transact-sql +alter_cryptographic_provider + : ALTER CRYPTOGRAPHIC PROVIDER provider_name=id_ (FROM FILE EQUAL crypto_provider_ddl_file=STRING)? (ENABLE | DISABLE)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-cryptographic-provider-transact-sql +create_cryptographic_provider + : CREATE CRYPTOGRAPHIC PROVIDER provider_name=id_ + FROM FILE EQUAL path_of_DLL=STRING + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/statements/create-endpoint-transact-sql?view=sql-server-ver16 +create_endpoint + : CREATE ENDPOINT endpointname=id_ (AUTHORIZATION login=id_)? + (STATE EQUAL state=(STARTED | STOPPED | DISABLED))? + AS TCP LR_BRACKET endpoint_listener_clause RR_BRACKET + ( FOR TSQL LR_BRACKET RR_BRACKET + | FOR SERVICE_BROKER LR_BRACKET + endpoint_authentication_clause + (COMMA? endpoint_encryption_alogorithm_clause)? + (COMMA? MESSAGE_FORWARDING EQUAL (ENABLED | DISABLED))? + (COMMA? MESSAGE_FORWARD_SIZE EQUAL DECIMAL)? + RR_BRACKET + | FOR DATABASE_MIRRORING LR_BRACKET + endpoint_authentication_clause + (COMMA? endpoint_encryption_alogorithm_clause)? + COMMA? ROLE EQUAL (WITNESS | PARTNER | ALL) + RR_BRACKET + ) + ; + +endpoint_encryption_alogorithm_clause + : ENCRYPTION EQUAL (DISABLED | SUPPORTED | REQUIRED) (ALGORITHM (AES RC4? | RC4 AES?))? + ; + +endpoint_authentication_clause + : AUTHENTICATION EQUAL + ( WINDOWS (NTLM | KERBEROS | NEGOTIATE)? (CERTIFICATE cert_name=id_)? + | CERTIFICATE cert_name=id_ WINDOWS? (NTLM | KERBEROS | NEGOTIATE)? + ) + ; + +endpoint_listener_clause + : LISTENER_PORT EQUAL port=DECIMAL + (COMMA LISTENER_IP EQUAL (ALL | '(' (ipv4=IPV4_ADDR | ipv6=STRING) ')'))? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-event-notification-transact-sql +create_event_notification + : CREATE EVENT NOTIFICATION event_notification_name=id_ + ON (SERVER|DATABASE|QUEUE queue_name=id_) + (WITH FAN_IN)? + FOR (COMMA? event_type_or_group=id_)+ + TO SERVICE broker_service=STRING COMMA + broker_service_specifier_or_current_database=STRING + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-event-session-transact-sql +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-event-session-transact-sql +// todo: not implemented +create_or_alter_event_session + : (CREATE | ALTER) EVENT SESSION event_session_name=id_ ON SERVER + (COMMA? ADD EVENT ( (event_module_guid=id_ DOT)? event_package_name=id_ DOT event_name=id_) + (LR_BRACKET + (SET ( COMMA? event_customizable_attributue=id_ EQUAL (DECIMAL|STRING) )* )? + ( ACTION LR_BRACKET (COMMA? (event_module_guid=id_ DOT)? event_package_name=id_ DOT action_name=id_)+ RR_BRACKET)+ + (WHERE event_session_predicate_expression)? + RR_BRACKET )* + )* + (COMMA? DROP EVENT (event_module_guid=id_ DOT)? event_package_name=id_ DOT event_name=id_ )* + + ( (ADD TARGET (event_module_guid=id_ DOT)? event_package_name=id_ DOT target_name=id_ ) ( LR_BRACKET SET (COMMA? target_parameter_name=id_ EQUAL (LR_BRACKET? DECIMAL RR_BRACKET? |STRING) )+ RR_BRACKET )* )* + (DROP TARGET (event_module_guid=id_ DOT)? event_package_name=id_ DOT target_name=id_ )* + + + (WITH + LR_BRACKET + (COMMA? MAX_MEMORY EQUAL max_memory=DECIMAL (KB|MB) )? + (COMMA? EVENT_RETENTION_MODE EQUAL (ALLOW_SINGLE_EVENT_LOSS | ALLOW_MULTIPLE_EVENT_LOSS | NO_EVENT_LOSS ) )? + (COMMA? MAX_DISPATCH_LATENCY EQUAL (max_dispatch_latency_seconds=DECIMAL SECONDS | INFINITE) )? + (COMMA? MAX_EVENT_SIZE EQUAL max_event_size=DECIMAL (KB|MB) )? + (COMMA? MEMORY_PARTITION_MODE EQUAL (NONE | PER_NODE | PER_CPU) )? + (COMMA? TRACK_CAUSALITY EQUAL (ON|OFF) )? + (COMMA? STARTUP_STATE EQUAL (ON|OFF) )? + RR_BRACKET + )? + (STATE EQUAL (START|STOP) )? + + ; + +event_session_predicate_expression + : ( COMMA? (AND|OR)? NOT? ( event_session_predicate_factor | LR_BRACKET event_session_predicate_expression RR_BRACKET) )+ + ; + +event_session_predicate_factor + : event_session_predicate_leaf + | LR_BRACKET event_session_predicate_expression RR_BRACKET + ; + +event_session_predicate_leaf + : (event_field_name=id_ | (event_field_name=id_ |( (event_module_guid=id_ DOT)? event_package_name=id_ DOT predicate_source_name=id_ ) ) (EQUAL |(LESS GREATER) | (EXCLAMATION EQUAL) | GREATER | (GREATER EQUAL)| LESS | LESS EQUAL) (DECIMAL | STRING) ) + | (event_module_guid=id_ DOT)? event_package_name=id_ DOT predicate_compare_name=id_ LR_BRACKET (event_field_name=id_ |( (event_module_guid=id_ DOT)? event_package_name=id_ DOT predicate_source_name=id_ ) COMMA (DECIMAL | STRING) ) RR_BRACKET + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-external-data-source-transact-sql +alter_external_data_source + : ALTER EXTERNAL DATA SOURCE data_source_name=id_ SET + ( LOCATION EQUAL location=STRING COMMA? | RESOURCE_MANAGER_LOCATION EQUAL resource_manager_location=STRING COMMA? | CREDENTIAL EQUAL credential_name=id_ )+ + | ALTER EXTERNAL DATA SOURCE data_source_name=id_ WITH LR_BRACKET TYPE EQUAL BLOB_STORAGE COMMA LOCATION EQUAL location=STRING (COMMA CREDENTIAL EQUAL credential_name=id_ )? RR_BRACKET + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-external-library-transact-sql +alter_external_library + : ALTER EXTERNAL LIBRARY library_name=id_ (AUTHORIZATION owner_name=id_)? + (SET|ADD) ( LR_BRACKET CONTENT EQUAL (client_library=STRING | BINARY | NONE) (COMMA PLATFORM EQUAL (WINDOWS|LINUX)? RR_BRACKET) WITH (COMMA? LANGUAGE EQUAL (R|PYTHON) | DATA_SOURCE EQUAL external_data_source_name=id_ )+ RR_BRACKET ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-external-library-transact-sql +create_external_library + : CREATE EXTERNAL LIBRARY library_name=id_ (AUTHORIZATION owner_name=id_)? + FROM (COMMA? LR_BRACKET? (CONTENT EQUAL)? (client_library=STRING | BINARY | NONE) (COMMA PLATFORM EQUAL (WINDOWS|LINUX)? RR_BRACKET)? ) ( WITH (COMMA? LANGUAGE EQUAL (R|PYTHON) | DATA_SOURCE EQUAL external_data_source_name=id_ )+ RR_BRACKET )? + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-external-resource-pool-transact-sql +alter_external_resource_pool + : ALTER EXTERNAL RESOURCE POOL (pool_name=id_ | DEFAULT_DOUBLE_QUOTE) WITH LR_BRACKET MAX_CPU_PERCENT EQUAL max_cpu_percent=DECIMAL ( COMMA? AFFINITY CPU EQUAL (AUTO|(COMMA? DECIMAL TO DECIMAL |COMMA DECIMAL )+ ) | NUMANODE EQUAL (COMMA? DECIMAL TO DECIMAL| COMMA? DECIMAL )+ ) (COMMA? MAX_MEMORY_PERCENT EQUAL max_memory_percent=DECIMAL)? (COMMA? MAX_PROCESSES EQUAL max_processes=DECIMAL)? RR_BRACKET + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-external-resource-pool-transact-sql +create_external_resource_pool + : CREATE EXTERNAL RESOURCE POOL pool_name=id_ WITH LR_BRACKET MAX_CPU_PERCENT EQUAL max_cpu_percent=DECIMAL ( COMMA? AFFINITY CPU EQUAL (AUTO|(COMMA? DECIMAL TO DECIMAL |COMMA DECIMAL )+ ) | NUMANODE EQUAL (COMMA? DECIMAL TO DECIMAL| COMMA? DECIMAL )+ ) (COMMA? MAX_MEMORY_PERCENT EQUAL max_memory_percent=DECIMAL)? (COMMA? MAX_PROCESSES EQUAL max_processes=DECIMAL)? RR_BRACKET + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-fulltext-catalog-transact-sql +alter_fulltext_catalog + : ALTER FULLTEXT CATALOG catalog_name=id_ (REBUILD (WITH ACCENT_SENSITIVITY EQUAL (ON|OFF) )? | REORGANIZE | AS DEFAULT ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-fulltext-catalog-transact-sql +create_fulltext_catalog + : CREATE FULLTEXT CATALOG catalog_name=id_ + (ON FILEGROUP filegroup=id_)? + (IN PATH rootpath=STRING)? + (WITH ACCENT_SENSITIVITY EQUAL (ON|OFF) )? + (AS DEFAULT)? + (AUTHORIZATION owner_name=id_)? + ; + + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-fulltext-stoplist-transact-sql +alter_fulltext_stoplist + : ALTER FULLTEXT STOPLIST stoplist_name=id_ (ADD stopword=STRING LANGUAGE (STRING|DECIMAL|BINARY) | DROP ( stopword=STRING LANGUAGE (STRING|DECIMAL|BINARY) |ALL (STRING|DECIMAL|BINARY) | ALL ) ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-fulltext-stoplist-transact-sql +create_fulltext_stoplist + : CREATE FULLTEXT STOPLIST stoplist_name=id_ + (FROM ( (database_name=id_ DOT)? source_stoplist_name=id_ |SYSTEM STOPLIST ) )? + (AUTHORIZATION owner_name=id_)? + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-login-transact-sql +alter_login_sql_server + : ALTER LOGIN login_name=id_ + ( (ENABLE|DISABLE)? | WITH ( (PASSWORD EQUAL ( password=STRING | password_hash=BINARY HASHED ) ) (MUST_CHANGE|UNLOCK)* )? (OLD_PASSWORD EQUAL old_password=STRING (MUST_CHANGE|UNLOCK)* )? (DEFAULT_DATABASE EQUAL default_database=id_)? (DEFAULT_LANGUAGE EQUAL default_laguage=id_)? (NAME EQUAL login_name=id_)? (CHECK_POLICY EQUAL (ON|OFF) )? (CHECK_EXPIRATION EQUAL (ON|OFF) )? (CREDENTIAL EQUAL credential_name=id_)? (NO CREDENTIAL)? | (ADD|DROP) CREDENTIAL credential_name=id_ ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-login-transact-sql +create_login_sql_server + : CREATE LOGIN login_name=id_ + ( WITH ( (PASSWORD EQUAL ( password=STRING | password_hash=BINARY HASHED ) ) (MUST_CHANGE|UNLOCK)* )? + (COMMA? SID EQUAL sid=BINARY)? + (COMMA? DEFAULT_DATABASE EQUAL default_database=id_)? + (COMMA? DEFAULT_LANGUAGE EQUAL default_laguage=id_)? + (COMMA? CHECK_EXPIRATION EQUAL (ON|OFF) )? + (COMMA? CHECK_POLICY EQUAL (ON|OFF) )? + (COMMA? CREDENTIAL EQUAL credential_name=id_)? + |(FROM + (WINDOWS + (WITH (COMMA? DEFAULT_DATABASE EQUAL default_database=id_)? (COMMA? DEFAULT_LANGUAGE EQUAL default_language=STRING)? ) + | CERTIFICATE certname=id_ + | ASYMMETRIC KEY asym_key_name=id_ + ) + ) + ) + ; + +alter_login_azure_sql + : ALTER LOGIN login_name=id_ ( (ENABLE|DISABLE)? | WITH (PASSWORD EQUAL password=STRING (OLD_PASSWORD EQUAL old_password=STRING)? | NAME EQUAL login_name=id_ ) ) + ; + +create_login_azure_sql + : CREATE LOGIN login_name=id_ + WITH PASSWORD EQUAL STRING (SID EQUAL sid=BINARY)? + ; + +alter_login_azure_sql_dw_and_pdw + : ALTER LOGIN login_name=id_ ( (ENABLE|DISABLE)? | WITH (PASSWORD EQUAL password=STRING (OLD_PASSWORD EQUAL old_password=STRING (MUST_CHANGE|UNLOCK)* )? | NAME EQUAL login_name=id_ ) ) + ; + +create_login_pdw + : CREATE LOGIN loginName=id_ + (WITH + ( PASSWORD EQUAL password=STRING (MUST_CHANGE)? + (CHECK_POLICY EQUAL (ON|OFF)? )? + ) + | FROM WINDOWS + ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-master-key-transact-sql +alter_master_key_sql_server + : ALTER MASTER KEY ( (FORCE)? REGENERATE WITH ENCRYPTION BY PASSWORD EQUAL password=STRING |(ADD|DROP) ENCRYPTION BY (SERVICE MASTER KEY | PASSWORD EQUAL encryption_password=STRING) ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-master-key-transact-sql +create_master_key_sql_server + : CREATE MASTER KEY ENCRYPTION BY PASSWORD EQUAL password=STRING + ; + +alter_master_key_azure_sql + : ALTER MASTER KEY ( (FORCE)? REGENERATE WITH ENCRYPTION BY PASSWORD EQUAL password=STRING |ADD ENCRYPTION BY (SERVICE MASTER KEY | PASSWORD EQUAL encryption_password=STRING) | DROP ENCRYPTION BY PASSWORD EQUAL encryption_password=STRING ) + ; + +create_master_key_azure_sql + : CREATE MASTER KEY (ENCRYPTION BY PASSWORD EQUAL password=STRING)? + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-message-type-transact-sql +alter_message_type + : ALTER MESSAGE TYPE message_type_name=id_ VALIDATION EQUAL (NONE | EMPTY | WELL_FORMED_XML | VALID_XML WITH SCHEMA COLLECTION schema_collection_name=id_) + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-partition-function-transact-sql +alter_partition_function + : ALTER PARTITION FUNCTION partition_function_name=id_ LR_BRACKET RR_BRACKET (SPLIT|MERGE) RANGE LR_BRACKET DECIMAL RR_BRACKET + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-partition-scheme-transact-sql +alter_partition_scheme + : ALTER PARTITION SCHEME partition_scheme_name=id_ NEXT USED (file_group_name=id_)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-remote-service-binding-transact-sql +alter_remote_service_binding + : ALTER REMOTE SERVICE BINDING binding_name=id_ + WITH (USER EQUAL user_name=id_)? + (COMMA ANONYMOUS EQUAL (ON|OFF) )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-remote-service-binding-transact-sql +create_remote_service_binding + : CREATE REMOTE SERVICE BINDING binding_name=id_ + (AUTHORIZATION owner_name=id_)? + TO SERVICE remote_service_name=STRING + WITH (USER EQUAL user_name=id_)? + (COMMA ANONYMOUS EQUAL (ON|OFF) )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-resource-pool-transact-sql +create_resource_pool + : CREATE RESOURCE POOL pool_name=id_ + (WITH + LR_BRACKET + (COMMA? MIN_CPU_PERCENT EQUAL DECIMAL)? + (COMMA? MAX_CPU_PERCENT EQUAL DECIMAL)? + (COMMA? CAP_CPU_PERCENT EQUAL DECIMAL)? + (COMMA? AFFINITY SCHEDULER EQUAL + (AUTO + | LR_BRACKET (COMMA? (DECIMAL|DECIMAL TO DECIMAL) )+ RR_BRACKET + | NUMANODE EQUAL LR_BRACKET (COMMA? (DECIMAL|DECIMAL TO DECIMAL) )+ RR_BRACKET + ) + )? + (COMMA? MIN_MEMORY_PERCENT EQUAL DECIMAL)? + (COMMA? MAX_MEMORY_PERCENT EQUAL DECIMAL)? + (COMMA? MIN_IOPS_PER_VOLUME EQUAL DECIMAL)? + (COMMA? MAX_IOPS_PER_VOLUME EQUAL DECIMAL)? + RR_BRACKET + )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-resource-governor-transact-sql +alter_resource_governor + : ALTER RESOURCE GOVERNOR ( (DISABLE | RECONFIGURE) | WITH LR_BRACKET CLASSIFIER_FUNCTION EQUAL ( schema_name=id_ DOT function_name=id_ | NULL_ ) RR_BRACKET | RESET STATISTICS | WITH LR_BRACKET MAX_OUTSTANDING_IO_PER_VOLUME EQUAL max_outstanding_io_per_volume=DECIMAL RR_BRACKET ) + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/statements/alter-database-audit-specification-transact-sql?view=sql-server-ver16 +alter_database_audit_specification + : ALTER DATABASE AUDIT SPECIFICATION audit_specification_name=id_ + (FOR SERVER AUDIT audit_name=id_)? + (audit_action_spec_group (',' audit_action_spec_group)*)? + (WITH '(' STATE '=' (ON|OFF) ')')? + ; + +audit_action_spec_group + : (ADD|DROP) '(' (audit_action_specification | audit_action_group_name=id_) ')' + ; + +audit_action_specification + : action_specification (',' action_specification)* ON (audit_class_name '::')? audit_securable BY principal_id (',' principal_id)* + ; + +action_specification + : SELECT + | INSERT + | UPDATE + | DELETE + | EXECUTE + | RECEIVE + | REFERENCES + ; + +audit_class_name + : OBJECT + | SCHEMA + | TABLE + ; + +audit_securable + : ((id_ '.')? id_ '.')? id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-role-transact-sql +alter_db_role + : ALTER ROLE role_name=id_ + ( (ADD|DROP) MEMBER database_principal=id_ + | WITH NAME EQUAL new_role_name=id_ ) + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/statements/create-database-audit-specification-transact-sql?view=sql-server-ver16 +create_database_audit_specification + : CREATE DATABASE AUDIT SPECIFICATION audit_specification_name=id_ + (FOR SERVER AUDIT audit_name=id_)? + (audit_action_spec_group (',' audit_action_spec_group)*)? + (WITH '(' STATE '=' (ON|OFF) ')')? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-role-transact-sql +create_db_role + : CREATE ROLE role_name=id_ (AUTHORIZATION owner_name = id_)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-route-transact-sql +create_route + : CREATE ROUTE route_name=id_ + (AUTHORIZATION owner_name=id_)? + WITH + (COMMA? SERVICE_NAME EQUAL route_service_name=STRING)? + (COMMA? BROKER_INSTANCE EQUAL broker_instance_identifier=STRING)? + (COMMA? LIFETIME EQUAL DECIMAL)? + COMMA? ADDRESS EQUAL STRING + (COMMA MIRROR_ADDRESS EQUAL STRING )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-rule-transact-sql +create_rule + : CREATE RULE (schema_name=id_ DOT)? rule_name=id_ + AS search_condition + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-schema-transact-sql +alter_schema_sql + : ALTER SCHEMA schema_name=id_ TRANSFER ((OBJECT|TYPE|XML SCHEMA COLLECTION) DOUBLE_COLON )? id_ (DOT id_)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-schema-transact-sql +create_schema + : CREATE SCHEMA + (schema_name=id_ + |AUTHORIZATION owner_name=id_ + | schema_name=id_ AUTHORIZATION owner_name=id_ + ) + (create_table + |create_view + | (GRANT|DENY) (SELECT|INSERT|DELETE|UPDATE) ON (SCHEMA DOUBLE_COLON)? object_name=id_ TO owner_name=id_ + | REVOKE (SELECT|INSERT|DELETE|UPDATE) ON (SCHEMA DOUBLE_COLON)? object_name=id_ FROM owner_name=id_ + )* + ; + +create_schema_azure_sql_dw_and_pdw + : +CREATE SCHEMA schema_name=id_ (AUTHORIZATION owner_name=id_ )? + ; + +alter_schema_azure_sql_dw_and_pdw + : ALTER SCHEMA schema_name=id_ TRANSFER (OBJECT DOUBLE_COLON )? id_ (DOT ID)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-search-property-list-transact-sql +create_search_property_list + : CREATE SEARCH PROPERTY LIST new_list_name=id_ + (FROM (database_name=id_ DOT)? source_list_name=id_ )? + (AUTHORIZATION owner_name=id_)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-security-policy-transact-sql +create_security_policy + : CREATE SECURITY POLICY (schema_name=id_ DOT)? security_policy_name=id_ + (COMMA? ADD (FILTER|BLOCK)? PREDICATE tvf_schema_name=id_ DOT security_predicate_function_name=id_ + LR_BRACKET (COMMA? column_name_or_arguments=id_)+ RR_BRACKET + ON table_schema_name=id_ DOT name=id_ + (COMMA? AFTER (INSERT|UPDATE) + | COMMA? BEFORE (UPDATE|DELETE) + )* + )+ + (WITH LR_BRACKET + STATE EQUAL (ON|OFF) + (SCHEMABINDING (ON|OFF) )? + RR_BRACKET + )? + (NOT FOR REPLICATION)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-sequence-transact-sql +alter_sequence + : ALTER SEQUENCE (schema_name=id_ DOT)? sequence_name=id_ ( RESTART (WITH DECIMAL)? )? (INCREMENT BY sequnce_increment=DECIMAL )? ( MINVALUE DECIMAL| NO MINVALUE)? (MAXVALUE DECIMAL| NO MAXVALUE)? (CYCLE|NO CYCLE)? (CACHE DECIMAL | NO CACHE)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-sequence-transact-sql +create_sequence + : CREATE SEQUENCE (schema_name=id_ DOT)? sequence_name=id_ + (AS data_type )? + (START WITH DECIMAL)? + (INCREMENT BY MINUS? DECIMAL)? + (MINVALUE (MINUS? DECIMAL)? | NO MINVALUE)? + (MAXVALUE (MINUS? DECIMAL)? | NO MAXVALUE)? + (CYCLE|NO CYCLE)? + (CACHE DECIMAL? | NO CACHE)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-server-audit-transact-sql +alter_server_audit + : ALTER SERVER AUDIT audit_name=id_ + ( ( TO + (FILE + ( LR_BRACKET + ( COMMA? FILEPATH EQUAL filepath=STRING + | COMMA? MAXSIZE EQUAL ( DECIMAL (MB|GB|TB) + | UNLIMITED + ) + | COMMA? MAX_ROLLOVER_FILES EQUAL max_rollover_files=(DECIMAL|UNLIMITED) + | COMMA? MAX_FILES EQUAL max_files=DECIMAL + | COMMA? RESERVE_DISK_SPACE EQUAL (ON|OFF) )* + RR_BRACKET ) + | APPLICATION_LOG + | SECURITY_LOG + ) )? + ( WITH LR_BRACKET + (COMMA? QUEUE_DELAY EQUAL queue_delay=DECIMAL + | COMMA? ON_FAILURE EQUAL (CONTINUE | SHUTDOWN|FAIL_OPERATION) + |COMMA? STATE EQUAL (ON|OFF) )* + RR_BRACKET + )? + ( WHERE ( COMMA? (NOT?) event_field_name=id_ + (EQUAL + |(LESS GREATER) + | (EXCLAMATION EQUAL) + | GREATER + | (GREATER EQUAL) + | LESS + | LESS EQUAL + ) + (DECIMAL | STRING) + | COMMA? (AND|OR) NOT? (EQUAL + |(LESS GREATER) + | (EXCLAMATION EQUAL) + | GREATER + | (GREATER EQUAL) + | LESS + | LESS EQUAL) + (DECIMAL | STRING) ) )? + |REMOVE WHERE + | MODIFY NAME EQUAL new_audit_name=id_ + ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-server-audit-transact-sql +create_server_audit + : CREATE SERVER AUDIT audit_name=id_ + ( ( TO + (FILE + ( LR_BRACKET + ( COMMA? FILEPATH EQUAL filepath=STRING + | COMMA? MAXSIZE EQUAL ( DECIMAL (MB|GB|TB) + | UNLIMITED + ) + | COMMA? MAX_ROLLOVER_FILES EQUAL max_rollover_files=(DECIMAL|UNLIMITED) + | COMMA? MAX_FILES EQUAL max_files=DECIMAL + | COMMA? RESERVE_DISK_SPACE EQUAL (ON|OFF) )* + RR_BRACKET ) + | APPLICATION_LOG + | SECURITY_LOG + ) )? + ( WITH LR_BRACKET + (COMMA? QUEUE_DELAY EQUAL queue_delay=DECIMAL + | COMMA? ON_FAILURE EQUAL (CONTINUE | SHUTDOWN|FAIL_OPERATION) + |COMMA? STATE EQUAL (ON|OFF) + |COMMA? AUDIT_GUID EQUAL audit_guid=id_ + )* + + RR_BRACKET + )? + ( WHERE ( COMMA? (NOT?) event_field_name=id_ + (EQUAL + |(LESS GREATER) + | (EXCLAMATION EQUAL) + | GREATER + | (GREATER EQUAL) + | LESS + | LESS EQUAL + ) + (DECIMAL | STRING) + | COMMA? (AND|OR) NOT? (EQUAL + |(LESS GREATER) + | (EXCLAMATION EQUAL) + | GREATER + | (GREATER EQUAL) + | LESS + | LESS EQUAL) + (DECIMAL | STRING) ) )? + |REMOVE WHERE + | MODIFY NAME EQUAL new_audit_name=id_ + ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-server-audit-specification-transact-sql + +alter_server_audit_specification + : ALTER SERVER AUDIT SPECIFICATION audit_specification_name=id_ + (FOR SERVER AUDIT audit_name=id_)? + ( (ADD|DROP) LR_BRACKET audit_action_group_name=id_ RR_BRACKET )* + (WITH LR_BRACKET STATE EQUAL (ON|OFF) RR_BRACKET )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-server-audit-specification-transact-sql +create_server_audit_specification + : CREATE SERVER AUDIT SPECIFICATION audit_specification_name=id_ + (FOR SERVER AUDIT audit_name=id_)? + ( ADD LR_BRACKET audit_action_group_name=id_ RR_BRACKET )* + (WITH LR_BRACKET STATE EQUAL (ON|OFF) RR_BRACKET )? + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-server-configuration-transact-sql + +alter_server_configuration + : ALTER SERVER CONFIGURATION + SET ( (PROCESS AFFINITY (CPU EQUAL (AUTO | (COMMA? DECIMAL | COMMA? DECIMAL TO DECIMAL)+ ) | NUMANODE EQUAL ( COMMA? DECIMAL |COMMA? DECIMAL TO DECIMAL)+ ) | DIAGNOSTICS LOG (ON|OFF|PATH EQUAL (STRING | DEFAULT) |MAX_SIZE EQUAL (DECIMAL MB |DEFAULT)|MAX_FILES EQUAL (DECIMAL|DEFAULT) ) | FAILOVER CLUSTER PROPERTY (VERBOSELOGGING EQUAL (STRING|DEFAULT) |SQLDUMPERFLAGS EQUAL (STRING|DEFAULT) | SQLDUMPERPATH EQUAL (STRING|DEFAULT) | SQLDUMPERTIMEOUT (STRING|DEFAULT) | FAILURECONDITIONLEVEL EQUAL (STRING|DEFAULT) | HEALTHCHECKTIMEOUT EQUAL (DECIMAL|DEFAULT) ) | HADR CLUSTER CONTEXT EQUAL (STRING|LOCAL) | BUFFER POOL EXTENSION (ON LR_BRACKET FILENAME EQUAL STRING COMMA SIZE EQUAL DECIMAL (KB|MB|GB) RR_BRACKET | OFF ) | SET SOFTNUMA (ON|OFF) ) ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-server-role-transact-sql +alter_server_role + : ALTER SERVER ROLE server_role_name=id_ + ( (ADD|DROP) MEMBER server_principal=id_ + | WITH NAME EQUAL new_server_role_name=id_ + ) + ; +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-server-role-transact-sql +create_server_role + : CREATE SERVER ROLE server_role=id_ (AUTHORIZATION server_principal=id_)? + ; + +alter_server_role_pdw + : ALTER SERVER ROLE server_role_name=id_ (ADD|DROP) MEMBER login=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-service-transact-sql +alter_service + : ALTER SERVICE modified_service_name=id_ (ON QUEUE (schema_name=id_ DOT)? queue_name=id_)? ('(' opt_arg_clause (COMMA opt_arg_clause)* ')')? + ; + +opt_arg_clause + : (ADD|DROP) CONTRACT modified_contract_name=id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-service-transact-sql +create_service + : CREATE SERVICE create_service_name=id_ + (AUTHORIZATION owner_name=id_)? + ON QUEUE (schema_name=id_ DOT)? queue_name=id_ + ( LR_BRACKET (COMMA? (id_|DEFAULT) )+ RR_BRACKET )? + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-service-master-key-transact-sql + +alter_service_master_key + : ALTER SERVICE MASTER KEY ( FORCE? REGENERATE | (WITH (OLD_ACCOUNT EQUAL acold_account_name=STRING COMMA OLD_PASSWORD EQUAL old_password=STRING | NEW_ACCOUNT EQUAL new_account_name=STRING COMMA NEW_PASSWORD EQUAL new_password=STRING)? ) ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-symmetric-key-transact-sql + +alter_symmetric_key + : ALTER SYMMETRIC KEY key_name=id_ ( (ADD|DROP) ENCRYPTION BY (CERTIFICATE certificate_name=id_ | PASSWORD EQUAL password=STRING | SYMMETRIC KEY symmetric_key_name=id_ | ASYMMETRIC KEY Asym_key_name=id_ ) ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-synonym-transact-sql +create_synonym + : CREATE SYNONYM (schema_name_1=id_ DOT )? synonym_name=id_ + FOR ( (server_name=id_ DOT )? (database_name=id_ DOT)? (schema_name_2=id_ DOT)? object_name=id_ + | (database_or_schema2=id_ DOT)? (schema_id_2_or_object_name=id_ DOT)? + ) + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-user-transact-sql +alter_user + : ALTER USER username=id_ WITH (COMMA? NAME EQUAL newusername=id_ | COMMA? DEFAULT_SCHEMA EQUAL ( schema_name=id_ |NULL_ ) | COMMA? LOGIN EQUAL loginame=id_ | COMMA? PASSWORD EQUAL STRING (OLD_PASSWORD EQUAL STRING)+ | COMMA? DEFAULT_LANGUAGE EQUAL (NONE| lcid=DECIMAL| language_name_or_alias=id_) | COMMA? ALLOW_ENCRYPTED_VALUE_MODIFICATIONS EQUAL (ON|OFF) )+ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-user-transact-sql +create_user + : CREATE USER user_name=id_ + ( (FOR|FROM) LOGIN login_name=id_ )? + ( WITH (COMMA? DEFAULT_SCHEMA EQUAL schema_name=id_ + |COMMA? ALLOW_ENCRYPTED_VALUE_MODIFICATIONS EQUAL (ON|OFF) + )* + )? + | CREATE USER ( windows_principal=id_ + (WITH + (COMMA? DEFAULT_SCHEMA EQUAL schema_name=id_ + |COMMA? DEFAULT_LANGUAGE EQUAL (NONE + |DECIMAL + |language_name_or_alias=id_ ) + |COMMA? SID EQUAL BINARY + |COMMA? ALLOW_ENCRYPTED_VALUE_MODIFICATIONS EQUAL (ON|OFF) + )* + )? + | user_name=id_ WITH PASSWORD EQUAL password=STRING + (COMMA? DEFAULT_SCHEMA EQUAL schema_name=id_ + |COMMA? DEFAULT_LANGUAGE EQUAL (NONE + |DECIMAL + |language_name_or_alias=id_ ) + |COMMA? SID EQUAL BINARY + |COMMA? ALLOW_ENCRYPTED_VALUE_MODIFICATIONS EQUAL (ON|OFF) + )* + | Azure_Active_Directory_principal=id_ FROM EXTERNAL PROVIDER + ) + | CREATE USER user_name=id_ + ( WITHOUT LOGIN + (COMMA? DEFAULT_SCHEMA EQUAL schema_name=id_ + |COMMA? ALLOW_ENCRYPTED_VALUE_MODIFICATIONS EQUAL (ON|OFF) + )* + | (FOR|FROM) CERTIFICATE cert_name=id_ + | (FOR|FROM) ASYMMETRIC KEY asym_key_name=id_ + ) + | CREATE USER user_name=id_ + ; + +create_user_azure_sql_dw + : CREATE USER user_name=id_ + ( (FOR|FROM) LOGIN login_name=id_ + | WITHOUT LOGIN + )? + + ( WITH DEFAULT_SCHEMA EQUAL schema_name=id_)? + | CREATE USER Azure_Active_Directory_principal=id_ + FROM EXTERNAL PROVIDER + ( WITH DEFAULT_SCHEMA EQUAL schema_name=id_)? + ; + + +alter_user_azure_sql + : ALTER USER username=id_ WITH (COMMA? NAME EQUAL newusername=id_ | COMMA? DEFAULT_SCHEMA EQUAL schema_name=id_ | COMMA? LOGIN EQUAL loginame=id_ | COMMA? ALLOW_ENCRYPTED_VALUE_MODIFICATIONS EQUAL (ON|OFF) )+ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-workload-group-transact-sql + +alter_workload_group + : ALTER WORKLOAD GROUP + (workload_group_group_name=id_ + |DEFAULT_DOUBLE_QUOTE + ) + (WITH LR_BRACKET + (IMPORTANCE EQUAL (LOW|MEDIUM|HIGH) + | COMMA? REQUEST_MAX_MEMORY_GRANT_PERCENT EQUAL request_max_memory_grant=DECIMAL + | COMMA? REQUEST_MAX_CPU_TIME_SEC EQUAL request_max_cpu_time_sec=DECIMAL + | REQUEST_MEMORY_GRANT_TIMEOUT_SEC EQUAL request_memory_grant_timeout_sec=DECIMAL + | MAX_DOP EQUAL max_dop=DECIMAL + | GROUP_MAX_REQUESTS EQUAL group_max_requests=DECIMAL)+ + RR_BRACKET )? + (USING (workload_group_pool_name=id_ | DEFAULT_DOUBLE_QUOTE) )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-workload-group-transact-sql +create_workload_group + : CREATE WORKLOAD GROUP workload_group_group_name=id_ + (WITH LR_BRACKET + (IMPORTANCE EQUAL (LOW|MEDIUM|HIGH) + | COMMA? REQUEST_MAX_MEMORY_GRANT_PERCENT EQUAL request_max_memory_grant=DECIMAL + | COMMA? REQUEST_MAX_CPU_TIME_SEC EQUAL request_max_cpu_time_sec=DECIMAL + | REQUEST_MEMORY_GRANT_TIMEOUT_SEC EQUAL request_memory_grant_timeout_sec=DECIMAL + | MAX_DOP EQUAL max_dop=DECIMAL + | GROUP_MAX_REQUESTS EQUAL group_max_requests=DECIMAL)+ + RR_BRACKET )? + (USING (workload_group_pool_name=id_ | DEFAULT_DOUBLE_QUOTE)? + (COMMA? EXTERNAL external_pool_name=id_ | DEFAULT_DOUBLE_QUOTE)? + )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-xml-schema-collection-transact-sql +create_xml_schema_collection + : CREATE XML SCHEMA COLLECTION (relational_schema=id_ DOT)? sql_identifier=id_ AS (STRING|id_|LOCAL_ID) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-partition-function-transact-sql?view=sql-server-ver15 +create_partition_function + : CREATE PARTITION FUNCTION partition_function_name=id_ '(' input_parameter_type=data_type ')' + AS RANGE ( LEFT | RIGHT )? + FOR VALUES '(' boundary_values=expression_list_ ')' + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-partition-scheme-transact-sql?view=sql-server-ver15 +create_partition_scheme + : CREATE PARTITION SCHEME partition_scheme_name=id_ + AS PARTITION partition_function_name=id_ + ALL? TO '(' file_group_names+=id_ (',' file_group_names+=id_)* ')' + ; + +create_queue + : CREATE QUEUE (full_table_name | queue_name=id_) queue_settings? + (ON filegroup=id_ | DEFAULT)? + ; + + +queue_settings + : WITH + (STATUS EQUAL on_off COMMA?)? + (RETENTION EQUAL on_off COMMA?)? + (ACTIVATION + LR_BRACKET + ( + ( + (STATUS EQUAL on_off COMMA? )? + (PROCEDURE_NAME EQUAL func_proc_name_database_schema COMMA?)? + (MAX_QUEUE_READERS EQUAL max_readers=DECIMAL COMMA?)? + (EXECUTE AS (SELF | user_name=STRING | OWNER) COMMA?)? + ) + | DROP + ) + RR_BRACKET COMMA? + )? + (POISON_MESSAGE_HANDLING + LR_BRACKET + (STATUS EQUAL on_off) + RR_BRACKET + )? + ; + +alter_queue + : ALTER QUEUE (full_table_name | queue_name=id_) + (queue_settings | queue_action) + ; + +queue_action + : REBUILD ( WITH LR_BRACKET queue_rebuild_options RR_BRACKET)? + | REORGANIZE (WITH LOB_COMPACTION EQUAL on_off)? + | MOVE TO (id_ | DEFAULT) + ; +queue_rebuild_options + : MAXDOP EQUAL DECIMAL + ; + +create_contract + : CREATE CONTRACT contract_name + (AUTHORIZATION owner_name=id_)? + LR_BRACKET ((message_type_name=id_ | DEFAULT) + SENT BY (INITIATOR | TARGET | ANY ) COMMA?)+ + RR_BRACKET + ; + +conversation_statement + : begin_conversation_timer + | begin_conversation_dialog + | end_conversation + | get_conversation + | send_conversation + | waitfor_conversation + ; + +message_statement + : CREATE MESSAGE TYPE message_type_name=id_ + (AUTHORIZATION owner_name=id_)? + (VALIDATION EQUAL (NONE + | EMPTY + | WELL_FORMED_XML + | VALID_XML WITH SCHEMA COLLECTION schema_collection_name=id_)) + ; + +// DML + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/merge-transact-sql +// note that there's a limit on number of when_matches but it has to be done runtime due to different ordering of statements allowed +merge_statement + : with_expression? + MERGE (TOP '(' expression ')' PERCENT?)? + INTO? ddl_object with_table_hints? as_table_alias? + USING table_sources + ON search_condition + when_matches+ + output_clause? + option_clause? ';' + ; + +when_matches + : (WHEN MATCHED (AND search_condition)? + THEN merge_matched)+ + | (WHEN NOT MATCHED (BY TARGET)? (AND search_condition)? + THEN merge_not_matched) + | (WHEN NOT MATCHED BY SOURCE (AND search_condition)? + THEN merge_matched)+ + ; + +merge_matched + : UPDATE SET update_elem_merge (',' update_elem_merge)* + | DELETE + ; + +merge_not_matched + : INSERT ('(' column_name_list ')')? + (table_value_constructor | DEFAULT VALUES) + ; + +// https://msdn.microsoft.com/en-us/library/ms189835.aspx +delete_statement + : with_expression? + DELETE (TOP '(' expression ')' PERCENT? | TOP DECIMAL)? + FROM? delete_statement_from + with_table_hints? + output_clause? + from_table_sources? + (WHERE (search_condition | CURRENT OF (GLOBAL? cursor_name | cursor_var=LOCAL_ID)))? + for_clause? option_clause? ';'? + ; + +delete_statement_from + : ddl_object + | rowset_function_limited + | table_var=LOCAL_ID + ; + +// https://msdn.microsoft.com/en-us/library/ms174335.aspx +insert_statement + : with_expression? + INSERT (TOP '(' expression ')' PERCENT?)? + INTO? (ddl_object | rowset_function_limited) + with_table_hints? + ('(' insert_column_name_list ')')? + output_clause? + insert_statement_value + for_clause? option_clause? ';'? + ; + +insert_statement_value + : derived_table + | execute_statement + | DEFAULT VALUES + ; + + +receive_statement + : '('? RECEIVE (ALL | DISTINCT | top_clause | '*') + (LOCAL_ID '=' expression ','?)* FROM full_table_name + (INTO table_variable=id_ (WHERE where=search_condition))? ')'? + ; + +// https://msdn.microsoft.com/en-us/library/ms189499.aspx +select_statement_standalone + : with_expression? select_statement + ; + +select_statement + : query_expression select_order_by_clause? for_clause? option_clause? ';'? + ; + +time + : (LOCAL_ID | constant) + ; + +// https://msdn.microsoft.com/en-us/library/ms177523.aspx +update_statement + : with_expression? + UPDATE (TOP '(' expression ')' PERCENT?)? + (ddl_object | rowset_function_limited) + with_table_hints? + SET update_elem (',' update_elem)* + output_clause? + (FROM table_sources)? + (WHERE (search_condition | CURRENT OF (GLOBAL? cursor_name | cursor_var=LOCAL_ID)))? + for_clause? option_clause? ';'? + ; + +// https://msdn.microsoft.com/en-us/library/ms177564.aspx +output_clause + : OUTPUT output_dml_list_elem (',' output_dml_list_elem)* + (INTO (LOCAL_ID | table_name) ('(' column_name_list ')')? )? + ; + +output_dml_list_elem + : (expression | asterisk) as_column_alias? + ; + +// DDL + +// https://msdn.microsoft.com/en-ie/library/ms176061.aspx +create_database + : CREATE DATABASE (database=id_) + ( CONTAINMENT '=' ( NONE | PARTIAL ) )? + ( ON PRIMARY? database_file_spec ( ',' database_file_spec )* )? + ( LOG ON database_file_spec ( ',' database_file_spec )* )? + ( COLLATE collation_name = id_ )? + ( WITH create_database_option ( ',' create_database_option )* )? + ; + +// https://msdn.microsoft.com/en-us/library/ms188783.aspx +create_index + : CREATE UNIQUE? clustered? INDEX id_ ON table_name '(' column_name_list_with_order ')' + (INCLUDE '(' column_name_list ')' )? + (WHERE where=search_condition)? + (create_index_options)? + (ON id_)? + ';'? + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/statements/create-spatial-index-transact-sql +create_spatial_index + : CREATE SPATIAL INDEX id_ ON table_name '(' id_ ')' + (spatial_tessellation_scheme)? + (spatial_index_options)? + (ON id_)? + ';'? + ; + +spatial_tessellation_scheme + : USING (GEOMETRY_AUTO_GRID | GEOMETRY_GRID | GEOGRAPHY_AUTO_GRID | GEOGRAPHY_GRID) + ; + +spatial_index_options + : WITH '(' spatial_index_option (',' spatial_index_option)* ')' + ; + +spatial_index_option + : BOUNDING_BOX '=' '(' signed_decimal ',' signed_decimal ',' signed_decimal ',' signed_decimal ')' + | GRIDS '=' '(' spatial_grid_level (',' spatial_grid_level)* ')' + | CELLS_PER_OBJECT '=' DECIMAL + | rebuild_index_option + ; + +signed_decimal + : MINUS? (DECIMAL | REAL | FLOAT) + ; + +spatial_grid_level + : LEVEL_1 '=' spatial_grid_density + | LEVEL_2 '=' spatial_grid_density + | LEVEL_3 '=' spatial_grid_density + | LEVEL_4 '=' spatial_grid_density + ; + +spatial_grid_density + : LOW | MEDIUM | HIGH + ; + +create_index_options + : 'WITH' '(' relational_index_option (',' relational_index_option)* ')' + ; + +relational_index_option + : rebuild_index_option + | DROP_EXISTING '=' on_off + | OPTIMIZE_FOR_SEQUENTIAL_KEY '=' on_off + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-index-transact-sql +alter_index + : ALTER INDEX (id_ | ALL) ON table_name (DISABLE | PAUSE | ABORT | RESUME resumable_index_options? | reorganize_partition | set_index_options | rebuild_partition) + ; + +resumable_index_options + : WITH '(' (resumable_index_option (',' resumable_index_option)*) ')' + ; + +resumable_index_option + : MAXDOP '=' max_degree_of_parallelism=DECIMAL + | MAX_DURATION '=' max_duration=DECIMAL MINUTES? + | low_priority_lock_wait + ; + +reorganize_partition + : REORGANIZE (PARTITION '=' DECIMAL)? reorganize_options? + ; + +reorganize_options + : WITH '(' (reorganize_option (',' reorganize_option)*) ')' + ; + +reorganize_option + : LOB_COMPACTION '=' on_off + | COMPRESS_ALL_ROW_GROUPS '=' on_off + ; + +set_index_options + : SET '(' set_index_option (',' set_index_option)* ')' + ; + +set_index_option + : ALLOW_ROW_LOCKS '=' on_off + | ALLOW_PAGE_LOCKS '=' on_off + | OPTIMIZE_FOR_SEQUENTIAL_KEY '=' on_off + | IGNORE_DUP_KEY '=' on_off + | STATISTICS_NORECOMPUTE '=' on_off + | COMPRESSION_DELAY '=' delay=DECIMAL MINUTES? + ; + +rebuild_partition + : REBUILD (PARTITION '=' ALL)? rebuild_index_options? + | REBUILD PARTITION '=' DECIMAL single_partition_rebuild_index_options? + ; + +rebuild_index_options + : WITH '(' rebuild_index_option (',' rebuild_index_option)* ')' + ; + +rebuild_index_option + : PAD_INDEX '=' on_off + | FILLFACTOR '=' DECIMAL + | SORT_IN_TEMPDB '=' on_off + | IGNORE_DUP_KEY '=' on_off + | STATISTICS_NORECOMPUTE '=' on_off + | STATISTICS_INCREMENTAL '=' on_off + | ONLINE '=' (ON ('(' low_priority_lock_wait ')')? | OFF) + | RESUMABLE '=' on_off + | MAX_DURATION '=' times=DECIMAL MINUTES? + | ALLOW_ROW_LOCKS '=' on_off + | ALLOW_PAGE_LOCKS '=' on_off + | MAXDOP '=' max_degree_of_parallelism=DECIMAL + | DATA_COMPRESSION '=' (NONE | ROW | PAGE | COLUMNSTORE | COLUMNSTORE_ARCHIVE) + on_partitions? + | XML_COMPRESSION '=' on_off + on_partitions? + ; + +single_partition_rebuild_index_options + : WITH '(' single_partition_rebuild_index_option (',' single_partition_rebuild_index_option)* ')' + ; + +single_partition_rebuild_index_option + : SORT_IN_TEMPDB '=' on_off + | MAXDOP '=' max_degree_of_parallelism=DECIMAL + | RESUMABLE '=' on_off + | DATA_COMPRESSION '=' (NONE | ROW | PAGE | COLUMNSTORE | COLUMNSTORE_ARCHIVE) + on_partitions? + | XML_COMPRESSION '=' on_off + on_partitions? + | ONLINE '=' (ON ('(' low_priority_lock_wait ')')? | OFF) + ; + +on_partitions + : ON PARTITIONS '(' + partition_number=DECIMAL ( 'TO' to_partition_number=DECIMAL )? + ( ',' partition_number=DECIMAL ( 'TO' to_partition_number=DECIMAL )? )* + ')' + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-columnstore-index-transact-sql?view=sql-server-ver15 +create_columnstore_index + : CREATE CLUSTERED COLUMNSTORE INDEX id_ ON table_name + create_columnstore_index_options? + (ON id_)? + ';'? + ; + +create_columnstore_index_options + : 'WITH' '(' columnstore_index_option (',' columnstore_index_option)* ')' + ; + +columnstore_index_option + : + DROP_EXISTING '=' on_off + | MAXDOP '=' max_degree_of_parallelism=DECIMAL + | ONLINE '=' on_off + | COMPRESSION_DELAY '=' delay=DECIMAL MINUTES? + | DATA_COMPRESSION '=' (COLUMNSTORE | COLUMNSTORE_ARCHIVE) + on_partitions? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-columnstore-index-transact-sql?view=sql-server-ver15 +create_nonclustered_columnstore_index + : CREATE NONCLUSTERED? COLUMNSTORE INDEX id_ ON table_name '(' column_name_list_with_order ')' + (WHERE search_condition)? + create_columnstore_index_options? + (ON id_)? + ';'? + ; + +create_xml_index + : CREATE PRIMARY? XML INDEX id_ ON table_name '(' id_ ')' + (USING XML INDEX id_ (FOR (VALUE | PATH | PROPERTY)?)?)? + xml_index_options? + ';'? + ; + +xml_index_options + : 'WITH' '(' xml_index_option (',' xml_index_option)* ')' + ; + +xml_index_option + : PAD_INDEX '=' on_off + | FILLFACTOR '=' DECIMAL + | SORT_IN_TEMPDB '=' on_off + | IGNORE_DUP_KEY '=' on_off + | DROP_EXISTING '=' on_off + | ONLINE '=' (ON ('(' low_priority_lock_wait ')')? | OFF) + | ALLOW_ROW_LOCKS '=' on_off + | ALLOW_PAGE_LOCKS '=' on_off + | MAXDOP '=' max_degree_of_parallelism=DECIMAL + | XML_COMPRESSION '=' on_off + ; + + +// https://msdn.microsoft.com/en-us/library/ms187926(v=sql.120).aspx +create_or_alter_procedure + : ((CREATE (OR (ALTER | REPLACE))?) | ALTER) proc=(PROC | PROCEDURE) procName=func_proc_name_schema (';' DECIMAL)? + ('('? procedure_param (',' procedure_param)* ')'?)? + (WITH procedure_option (',' procedure_option)*)? + (FOR REPLICATION)? AS (as_external_name | sql_clauses*) + ; + +as_external_name + : EXTERNAL NAME assembly_name = id_ '.' class_name = id_ '.' method_name = id_ + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/create-trigger-transact-sql +create_or_alter_trigger + : create_or_alter_dml_trigger + | create_or_alter_ddl_trigger + ; + +create_or_alter_dml_trigger + : (CREATE (OR (ALTER | REPLACE))? | ALTER) TRIGGER simple_name + ON table_name + (WITH dml_trigger_option (',' dml_trigger_option)* )? + (FOR | AFTER | INSTEAD OF) + dml_trigger_operation (',' dml_trigger_operation)* + (WITH APPEND)? + (NOT FOR REPLICATION)? + AS sql_clauses+ + ; + +dml_trigger_option + : ENCRYPTION + | execute_clause + ; + +dml_trigger_operation + : (INSERT | UPDATE | DELETE) + ; + +create_or_alter_ddl_trigger + : (CREATE (OR (ALTER | REPLACE))? | ALTER) TRIGGER simple_name + ON (ALL SERVER | DATABASE) + (WITH dml_trigger_option (',' dml_trigger_option)* )? + (FOR | AFTER) ddl_trigger_operation (',' ddl_trigger_operation)* + AS sql_clauses+ + ; + +ddl_trigger_operation + : simple_id + ; + +// https://msdn.microsoft.com/en-us/library/ms186755.aspx +create_or_alter_function + : ((CREATE (OR ALTER)?) | ALTER) FUNCTION funcName=func_proc_name_schema + (('(' procedure_param (',' procedure_param)* ')') | '(' ')') //must have (), but can be empty + (func_body_returns_select | func_body_returns_table | func_body_returns_scalar) ';'? + ; + +func_body_returns_select + : RETURNS TABLE + (WITH function_option (',' function_option)*)? + AS? (as_external_name | RETURN ('(' select_statement_standalone ')' | select_statement_standalone)) + ; + +func_body_returns_table + : RETURNS LOCAL_ID table_type_definition + (WITH function_option (',' function_option)*)? + AS? (as_external_name | + BEGIN + sql_clauses* + RETURN ';'? + END ';'?) + ; + +func_body_returns_scalar + : RETURNS data_type + (WITH function_option (',' function_option)*)? + AS? (as_external_name | + BEGIN + sql_clauses* + RETURN ret=expression ';'? + END) + ; + +procedure_param_default_value + : NULL_ + | DEFAULT + | constant + | LOCAL_ID + ; + +procedure_param + : LOCAL_ID AS? (type_schema=id_ '.')? data_type VARYING? ('=' default_val=procedure_param_default_value)? (OUT | OUTPUT | READONLY)? + ; + +procedure_option + : ENCRYPTION + | RECOMPILE + | execute_clause + ; + +function_option + : ENCRYPTION + | SCHEMABINDING + | RETURNS NULL_ ON NULL_ INPUT + | CALLED ON NULL_ INPUT + | execute_clause + ; + +// https://msdn.microsoft.com/en-us/library/ms188038.aspx +create_statistics + : CREATE STATISTICS id_ ON table_name '(' column_name_list ')' + (WITH (FULLSCAN | SAMPLE DECIMAL (PERCENT | ROWS) | STATS_STREAM) + (',' NORECOMPUTE)? (',' INCREMENTAL EQUAL on_off)? )? ';'? + ; + +update_statistics + : UPDATE STATISTICS full_table_name + ( id_ | '(' id_ ( ',' id_ )* ')' )? + update_statistics_options? + ; + +update_statistics_options + : WITH update_statistics_option (',' update_statistics_option)* + ; + +update_statistics_option + : ( FULLSCAN (','? PERSIST_SAMPLE_PERCENT '=' on_off )? ) + | ( SAMPLE number=DECIMAL (PERCENT | ROWS) + (','? PERSIST_SAMPLE_PERCENT '=' on_off )? ) + | RESAMPLE on_partitions? + | STATS_STREAM '=' stats_stream_=expression + | ROWCOUNT '=' DECIMAL + | PAGECOUNT '=' DECIMAL + | ALL + | COLUMNS + | INDEX + | NORECOMPUTE + | INCREMENTAL '=' on_off + | MAXDOP '=' max_dregree_of_parallelism=DECIMAL + | AUTO_DROP '=' on_off + ; + +// https://msdn.microsoft.com/en-us/library/ms174979.aspx +create_table + : CREATE TABLE table_name '(' column_def_table_constraints (','? table_indices)* ','? ')' (LOCK simple_id)? table_options* (ON id_ | DEFAULT | on_partition_or_filegroup)? (TEXTIMAGE_ON id_ | DEFAULT)?';'? + ; + +table_indices + : INDEX id_ UNIQUE? clustered? '(' column_name_list_with_order ')' + | INDEX id_ CLUSTERED COLUMNSTORE + | INDEX id_ NONCLUSTERED? COLUMNSTORE '(' column_name_list ')' + create_table_index_options? + (ON id_)? + ; + +table_options + : WITH ('(' table_option (',' table_option)* ')' | table_option (',' table_option)*) + ; + +table_option + : (simple_id | keyword) '=' (simple_id | keyword | on_off | DECIMAL) + | CLUSTERED COLUMNSTORE INDEX | HEAP + | FILLFACTOR '=' DECIMAL + | DISTRIBUTION '=' HASH '(' id_ ')' | CLUSTERED INDEX '(' id_ (ASC | DESC)? (',' id_ (ASC | DESC)?)* ')' + | DATA_COMPRESSION '=' (NONE | ROW | PAGE) + on_partitions? + | XML_COMPRESSION '=' on_off + on_partitions? + ; + +create_table_index_options + : WITH '(' create_table_index_option ( ',' create_table_index_option)* ')' + ; + +create_table_index_option + : PAD_INDEX '=' on_off + | FILLFACTOR '=' DECIMAL + | IGNORE_DUP_KEY '=' on_off + | STATISTICS_NORECOMPUTE '=' on_off + | STATISTICS_INCREMENTAL '=' on_off + | ALLOW_ROW_LOCKS '=' on_off + | ALLOW_PAGE_LOCKS '=' on_off + | OPTIMIZE_FOR_SEQUENTIAL_KEY '=' on_off + | DATA_COMPRESSION '=' (NONE | ROW | PAGE | COLUMNSTORE | COLUMNSTORE_ARCHIVE) + on_partitions? + | XML_COMPRESSION '=' on_off + on_partitions? + ; + +// https://msdn.microsoft.com/en-us/library/ms187956.aspx +create_view + : (CREATE (OR (ALTER | REPLACE))? | ALTER) VIEW simple_name ('(' column_name_list ')')? + (WITH view_attribute (',' view_attribute)*)? + AS select_statement_standalone (WITH CHECK OPTION)? ';'? + ; + +view_attribute + : ENCRYPTION | SCHEMABINDING | VIEW_METADATA + ; + +// https://msdn.microsoft.com/en-us/library/ms190273.aspx +alter_table + : ALTER TABLE table_name (SET '(' LOCK_ESCALATION '=' (AUTO | TABLE | DISABLE) ')' + | ADD column_def_table_constraints + | ALTER COLUMN (column_definition | column_modifier) + | DROP COLUMN id_ (',' id_)* + | DROP CONSTRAINT constraint=id_ + | WITH (CHECK | NOCHECK) ADD (CONSTRAINT constraint=id_)? + ( FOREIGN KEY '(' fk=column_name_list ')' REFERENCES table_name ('(' pk=column_name_list')')? (on_delete | on_update)* + | CHECK '(' search_condition ')' ) + | (NOCHECK | CHECK) CONSTRAINT constraint=id_ + | (ENABLE | DISABLE) TRIGGER id_? + | REBUILD table_options + | SWITCH switch_partition) + ';'? + ; + +switch_partition + : (PARTITION? source_partition_number_expression=expression)? + TO target_table=table_name + (PARTITION target_partition_number_expression=expression)? + (WITH low_priority_lock_wait)? + ; + +low_priority_lock_wait + : WAIT_AT_LOW_PRIORITY '(' + MAX_DURATION '=' max_duration=time MINUTES? ',' + ABORT_AFTER_WAIT '=' abort_after_wait=(NONE | SELF | BLOCKERS) ')' + ; + +// https://msdn.microsoft.com/en-us/library/ms174269.aspx +alter_database + : ALTER DATABASE (database=id_ | CURRENT) + (MODIFY NAME '=' new_name=id_ + | COLLATE collation=id_ + | SET database_optionspec (WITH termination)? + | add_or_modify_files + | add_or_modify_filegroups + ) ';'? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-database-transact-sql-file-and-filegroup-options?view=sql-server-ver15 +add_or_modify_files + : ADD FILE filespec (',' filespec)* (TO FILEGROUP filegroup_name=id_)? + | ADD LOG FILE filespec (',' filespec)* + | REMOVE FILE logical_file_name=id_ + | MODIFY FILE filespec + ; + +filespec + : '(' NAME '=' name=id_or_string + (',' NEWNAME '=' new_name=id_or_string )? + (',' FILENAME '=' file_name=STRING )? + (',' SIZE '=' size=file_size )? + (',' MAXSIZE '=' (max_size=file_size) | UNLIMITED )? + (',' FILEGROWTH '=' growth_increment=file_size )? + (',' OFFLINE )? + ')' + ; + +add_or_modify_filegroups + : ADD FILEGROUP filegroup_name=id_ (CONTAINS FILESTREAM | CONTAINS MEMORY_OPTIMIZED_DATA)? + | REMOVE FILEGROUP filegrou_name=id_ + | MODIFY FILEGROUP filegrou_name=id_ ( + filegroup_updatability_option + | DEFAULT + | NAME '=' new_filegroup_name=id_ + | AUTOGROW_SINGLE_FILE + | AUTOGROW_ALL_FILES + ) + ; + +filegroup_updatability_option + : READONLY + | READWRITE + | READ_ONLY + | READ_WRITE + ; + +// https://msdn.microsoft.com/en-us/library/bb522682.aspx +// Runtime check. +database_optionspec + : auto_option + | change_tracking_option + | containment_option + | cursor_option + | database_mirroring_option + | date_correlation_optimization_option + | db_encryption_option + | db_state_option + | db_update_option + | db_user_access_option + | delayed_durability_option + | external_access_option + | FILESTREAM database_filestream_option + | hadr_options + | mixed_page_allocation_option + | parameterization_option +// | query_store_options + | recovery_option +// | remote_data_archive_option + | service_broker_option + | snapshot_option + | sql_option + | target_recovery_time_option + | termination + ; + +auto_option + : AUTO_CLOSE on_off + | AUTO_CREATE_STATISTICS OFF | ON ( INCREMENTAL EQUAL ON | OFF ) + | AUTO_SHRINK on_off + | AUTO_UPDATE_STATISTICS on_off + | AUTO_UPDATE_STATISTICS_ASYNC (ON | OFF ) + ; + +change_tracking_option + : CHANGE_TRACKING EQUAL ( OFF | ON '(' (change_tracking_option_list (',' change_tracking_option_list)*)* ')' ) + ; + +change_tracking_option_list + : AUTO_CLEANUP EQUAL on_off + | CHANGE_RETENTION EQUAL DECIMAL ( DAYS | HOURS | MINUTES ) + ; + +containment_option + : CONTAINMENT EQUAL ( NONE | PARTIAL ) + ; + +cursor_option + : CURSOR_CLOSE_ON_COMMIT on_off + | CURSOR_DEFAULT ( LOCAL | GLOBAL ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-endpoint-transact-sql +alter_endpoint + : ALTER ENDPOINT endpointname=id_ (AUTHORIZATION login=id_)? + (STATE EQUAL state=(STARTED | STOPPED | DISABLED))? + AS TCP LR_BRACKET endpoint_listener_clause RR_BRACKET + ( FOR TSQL LR_BRACKET RR_BRACKET + | FOR SERVICE_BROKER LR_BRACKET + endpoint_authentication_clause + (COMMA? endpoint_encryption_alogorithm_clause)? + (COMMA? MESSAGE_FORWARDING EQUAL (ENABLED | DISABLED))? + (COMMA? MESSAGE_FORWARD_SIZE EQUAL DECIMAL)? + RR_BRACKET + | FOR DATABASE_MIRRORING LR_BRACKET + endpoint_authentication_clause + (COMMA? endpoint_encryption_alogorithm_clause)? + COMMA? ROLE EQUAL (WITNESS | PARTNER | ALL) + RR_BRACKET + ) + ; + +/* Will visit later +*/ +database_mirroring_option + : mirroring_set_option + ; + +mirroring_set_option + : mirroring_partner partner_option + | mirroring_witness witness_option + ; +mirroring_partner + : PARTNER + ; + +mirroring_witness + : WITNESS + ; + +witness_partner_equal + : EQUAL + ; + + +partner_option + : witness_partner_equal partner_server + | FAILOVER + | FORCE_SERVICE_ALLOW_DATA_LOSS + | OFF + | RESUME + | SAFETY (FULL | OFF ) + | SUSPEND + | TIMEOUT DECIMAL + ; + +witness_option + : witness_partner_equal witness_server + | OFF + ; + +witness_server + : partner_server + ; + +partner_server + : partner_server_tcp_prefix host mirroring_host_port_seperator port_number + ; + +mirroring_host_port_seperator + : COLON + ; + +partner_server_tcp_prefix + : TCP COLON DOUBLE_FORWARD_SLASH + ; +port_number + : port=DECIMAL + ; + +host + : id_ DOT host + | (id_ DOT |id_) + ; + +date_correlation_optimization_option + : DATE_CORRELATION_OPTIMIZATION on_off + ; + +db_encryption_option + : ENCRYPTION on_off + ; +db_state_option + : ( ONLINE | OFFLINE | EMERGENCY ) + ; + +db_update_option + : READ_ONLY | READ_WRITE + ; + +db_user_access_option + : SINGLE_USER | RESTRICTED_USER | MULTI_USER + ; +delayed_durability_option + : DELAYED_DURABILITY EQUAL ( DISABLED | ALLOWED | FORCED ) + ; + +external_access_option + : DB_CHAINING on_off + | TRUSTWORTHY on_off + | DEFAULT_LANGUAGE EQUAL ( id_ | STRING ) + | DEFAULT_FULLTEXT_LANGUAGE EQUAL ( id_ | STRING ) + | NESTED_TRIGGERS EQUAL ( OFF | ON ) + | TRANSFORM_NOISE_WORDS EQUAL ( OFF | ON ) + | TWO_DIGIT_YEAR_CUTOFF EQUAL DECIMAL + ; + +hadr_options + : HADR + ( ( AVAILABILITY GROUP EQUAL availability_group_name=id_ | OFF ) |(SUSPEND|RESUME) ) + ; + +mixed_page_allocation_option + : MIXED_PAGE_ALLOCATION ( OFF | ON ) + ; + +parameterization_option + : PARAMETERIZATION ( SIMPLE | FORCED ) + ; + +recovery_option + : RECOVERY ( FULL | BULK_LOGGED | SIMPLE ) + | TORN_PAGE_DETECTION on_off + | ACCELERATED_DATABASE_RECOVERY '=' on_off + | PAGE_VERIFY ( CHECKSUM | TORN_PAGE_DETECTION | NONE ) + ; + +service_broker_option: + ENABLE_BROKER + | DISABLE_BROKER + | NEW_BROKER + | ERROR_BROKER_CONVERSATIONS + | HONOR_BROKER_PRIORITY on_off + ; +snapshot_option + : ALLOW_SNAPSHOT_ISOLATION on_off + | READ_COMMITTED_SNAPSHOT (ON | OFF ) + | MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT = (ON | OFF ) + ; + +sql_option + : ANSI_NULL_DEFAULT on_off + | ANSI_NULLS on_off + | ANSI_PADDING on_off + | ANSI_WARNINGS on_off + | ARITHABORT on_off + | COMPATIBILITY_LEVEL EQUAL DECIMAL + | CONCAT_NULL_YIELDS_NULL on_off + | NUMERIC_ROUNDABORT on_off + | QUOTED_IDENTIFIER on_off + | RECURSIVE_TRIGGERS on_off + ; + +target_recovery_time_option + : TARGET_RECOVERY_TIME EQUAL DECIMAL ( SECONDS | MINUTES ) + ; + +termination + : ROLLBACK AFTER seconds = DECIMAL + | ROLLBACK IMMEDIATE + | NO_WAIT + ; + +// https://msdn.microsoft.com/en-us/library/ms176118.aspx +drop_index + : DROP INDEX (IF EXISTS)? + ( drop_relational_or_xml_or_spatial_index (',' drop_relational_or_xml_or_spatial_index)* + | drop_backward_compatible_index (',' drop_backward_compatible_index)* + ) + ';'? + ; + +drop_relational_or_xml_or_spatial_index + : index_name=id_ ON full_table_name + ; + +drop_backward_compatible_index + : (owner_name=id_ '.')? table_or_view_name=id_ '.' index_name=id_ + ; + +// https://msdn.microsoft.com/en-us/library/ms174969.aspx +drop_procedure + : DROP proc=(PROC | PROCEDURE) (IF EXISTS)? func_proc_name_schema (',' func_proc_name_schema)* ';'? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-trigger-transact-sql +drop_trigger + : drop_dml_trigger + | drop_ddl_trigger + ; + +drop_dml_trigger + : DROP TRIGGER (IF EXISTS)? simple_name (',' simple_name)* ';'? + ; + +drop_ddl_trigger + : DROP TRIGGER (IF EXISTS)? simple_name (',' simple_name)* + ON (DATABASE | ALL SERVER) ';'? + ; + +// https://msdn.microsoft.com/en-us/library/ms190290.aspx +drop_function + : DROP FUNCTION (IF EXISTS)? func_proc_name_schema (',' func_proc_name_schema)* ';'? + ; + +// https://msdn.microsoft.com/en-us/library/ms175075.aspx +drop_statistics + : DROP STATISTICS (COMMA? (table_name '.')? name=id_)+ ';' + ; + +// https://msdn.microsoft.com/en-us/library/ms173790.aspx +drop_table + : DROP TABLE (IF EXISTS)? table_name (',' table_name)* ';'? + ; + +// https://msdn.microsoft.com/en-us/library/ms173492.aspx +drop_view + : DROP VIEW (IF EXISTS)? simple_name (',' simple_name)* ';'? + ; + +create_type + : CREATE TYPE name = simple_name + (FROM data_type null_notnull?)? + (AS TABLE LR_BRACKET column_def_table_constraints RR_BRACKET)? + ; + +drop_type: + DROP TYPE ( IF EXISTS )? name = simple_name + ; + +rowset_function_limited + : openquery + | opendatasource + ; + +// https://msdn.microsoft.com/en-us/library/ms188427(v=sql.120).aspx +openquery + : OPENQUERY '(' linked_server=id_ ',' query=STRING ')' + ; + +// https://msdn.microsoft.com/en-us/library/ms179856.aspx +opendatasource + : OPENDATASOURCE '(' provider=STRING ',' init=STRING ')' + '.' (database=id_)? '.' (scheme=id_)? '.' (table=id_) + ; + +// Other statements. + +// https://msdn.microsoft.com/en-us/library/ms188927.aspx +declare_statement + : DECLARE LOCAL_ID AS? (data_type | table_type_definition | table_name) + | DECLARE loc+=declare_local (',' loc+=declare_local)* + | DECLARE LOCAL_ID AS? xml_type_definition + | WITH XMLNAMESPACES '(' xml_dec+=xml_declaration (',' xml_dec+=xml_declaration)* ')' + ; + +xml_declaration + : xml_namespace_uri=STRING AS id_ + | DEFAULT STRING + ; + +// https://msdn.microsoft.com/en-us/library/ms181441(v=sql.120).aspx +cursor_statement + // https://msdn.microsoft.com/en-us/library/ms175035(v=sql.120).aspx + : CLOSE GLOBAL? cursor_name ';'? + // https://msdn.microsoft.com/en-us/library/ms188782(v=sql.120).aspx + | DEALLOCATE GLOBAL? CURSOR? cursor_name ';'? + // https://msdn.microsoft.com/en-us/library/ms180169(v=sql.120).aspx + | declare_cursor + // https://msdn.microsoft.com/en-us/library/ms180152(v=sql.120).aspx + | fetch_cursor + // https://msdn.microsoft.com/en-us/library/ms190500(v=sql.120).aspx + | OPEN GLOBAL? cursor_name ';'? + ; +// https://docs.microsoft.com/en-us/sql/t-sql/statements/backup-transact-sql +backup_database + : BACKUP DATABASE ( database_name=id_ ) + (READ_WRITE_FILEGROUPS (COMMA? (FILE|FILEGROUP) EQUAL file_or_filegroup=STRING)* )? + (COMMA? (FILE|FILEGROUP) EQUAL file_or_filegroup=STRING)* + ( TO ( COMMA? logical_device_name=id_)+ + | TO ( COMMA? (DISK|TAPE|URL) EQUAL (STRING|id_) )+ + ) + + ( (MIRROR TO ( COMMA? logical_device_name=id_)+ )+ + | ( MIRROR TO ( COMMA? (DISK|TAPE|URL) EQUAL (STRING|id_) )+ )+ + )? + + (WITH ( COMMA? DIFFERENTIAL + | COMMA? COPY_ONLY + | COMMA? (COMPRESSION|NO_COMPRESSION) + | COMMA? DESCRIPTION EQUAL (STRING|id_) + | COMMA? NAME EQUAL backup_set_name=id_ + | COMMA? CREDENTIAL + | COMMA? FILE_SNAPSHOT + | COMMA? (EXPIREDATE EQUAL (STRING|id_) | RETAINDAYS EQUAL (DECIMAL|id_) ) + | COMMA? (NOINIT|INIT) + | COMMA? (NOSKIP|SKIP_KEYWORD) + | COMMA? (NOFORMAT|FORMAT) + | COMMA? MEDIADESCRIPTION EQUAL (STRING|id_) + | COMMA? MEDIANAME EQUAL (medianame=STRING) + | COMMA? BLOCKSIZE EQUAL (DECIMAL|id_) + | COMMA? BUFFERCOUNT EQUAL (DECIMAL|id_) + | COMMA? MAXTRANSFER EQUAL (DECIMAL|id_) + | COMMA? (NO_CHECKSUM|CHECKSUM) + | COMMA? (STOP_ON_ERROR|CONTINUE_AFTER_ERROR) + | COMMA? RESTART + | COMMA? STATS (EQUAL stats_percent=DECIMAL)? + | COMMA? (REWIND|NOREWIND) + | COMMA? (LOAD|NOUNLOAD) + | COMMA? ENCRYPTION LR_BRACKET + ALGORITHM EQUAL + (AES_128 + | AES_192 + | AES_256 + | TRIPLE_DES_3KEY + ) + COMMA + SERVER CERTIFICATE EQUAL + (encryptor_name=id_ + | SERVER ASYMMETRIC KEY EQUAL encryptor_name=id_ + ) + )* + )? + + ; + +backup_log + : BACKUP LOG ( database_name=id_ ) + ( TO ( COMMA? logical_device_name=id_)+ + | TO ( COMMA? (DISK|TAPE|URL) EQUAL (STRING|id_) )+ + ) + + ( (MIRROR TO ( COMMA? logical_device_name=id_)+ )+ + | ( MIRROR TO ( COMMA? (DISK|TAPE|URL) EQUAL (STRING|id_) )+ )+ + )? + + (WITH ( COMMA? DIFFERENTIAL + | COMMA? COPY_ONLY + | COMMA? (COMPRESSION|NO_COMPRESSION) + | COMMA? DESCRIPTION EQUAL (STRING|id_) + | COMMA? NAME EQUAL backup_set_name=id_ + | COMMA? CREDENTIAL + | COMMA? FILE_SNAPSHOT + | COMMA? (EXPIREDATE EQUAL (STRING|id_) | RETAINDAYS EQUAL (DECIMAL|id_) ) + | COMMA? (NOINIT|INIT) + | COMMA? (NOSKIP|SKIP_KEYWORD) + | COMMA? (NOFORMAT|FORMAT) + | COMMA? MEDIADESCRIPTION EQUAL (STRING|id_) + | COMMA? MEDIANAME EQUAL (medianame=STRING) + | COMMA? BLOCKSIZE EQUAL (DECIMAL|id_) + | COMMA? BUFFERCOUNT EQUAL (DECIMAL|id_) + | COMMA? MAXTRANSFER EQUAL (DECIMAL|id_) + | COMMA? (NO_CHECKSUM|CHECKSUM) + | COMMA? (STOP_ON_ERROR|CONTINUE_AFTER_ERROR) + | COMMA? RESTART + | COMMA? STATS (EQUAL stats_percent=DECIMAL)? + | COMMA? (REWIND|NOREWIND) + | COMMA? (LOAD|NOUNLOAD) + | COMMA? (NORECOVERY| STANDBY EQUAL undo_file_name=STRING) + | COMMA? NO_TRUNCATE + | COMMA? ENCRYPTION LR_BRACKET + ALGORITHM EQUAL + (AES_128 + | AES_192 + | AES_256 + | TRIPLE_DES_3KEY + ) + COMMA + SERVER CERTIFICATE EQUAL + (encryptor_name=id_ + | SERVER ASYMMETRIC KEY EQUAL encryptor_name=id_ + ) + )* + )? + + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/backup-certificate-transact-sql +backup_certificate + : BACKUP CERTIFICATE certname=id_ TO FILE EQUAL cert_file=STRING + ( WITH PRIVATE KEY + LR_BRACKET + (COMMA? FILE EQUAL private_key_file=STRING + |COMMA? ENCRYPTION BY PASSWORD EQUAL encryption_password=STRING + |COMMA? DECRYPTION BY PASSWORD EQUAL decryption_pasword=STRING + )+ + RR_BRACKET + )? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/backup-master-key-transact-sql +backup_master_key + : BACKUP MASTER KEY TO FILE EQUAL master_key_backup_file=STRING + ENCRYPTION BY PASSWORD EQUAL encryption_password=STRING + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/statements/backup-service-master-key-transact-sql +backup_service_master_key + : BACKUP SERVICE MASTER KEY TO FILE EQUAL service_master_key_backup_file=STRING + ENCRYPTION BY PASSWORD EQUAL encryption_password=STRING + ; + +kill_statement + : KILL (kill_process | kill_query_notification | kill_stats_job) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/kill-transact-sql +kill_process + : (session_id=(DECIMAL|STRING) | UOW) (WITH STATUSONLY)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/kill-query-notification-subscription-transact-sql +kill_query_notification + : QUERY NOTIFICATION SUBSCRIPTION (ALL | subscription_id=DECIMAL) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/kill-stats-job-transact-sql +kill_stats_job + : STATS JOB job_id=DECIMAL + ; + +// https://msdn.microsoft.com/en-us/library/ms188332.aspx +execute_statement + : EXECUTE execute_body ';'? + ; + +execute_body_batch + : func_proc_name_server_database_schema (execute_statement_arg (',' execute_statement_arg)*)? ';'? + ; + +//https://docs.microsoft.com/it-it/sql/t-sql/language-elements/execute-transact-sql?view=sql-server-ver15 +execute_body + : (return_status=LOCAL_ID '=')? (func_proc_name_server_database_schema | execute_var_string) execute_statement_arg? + | '(' execute_var_string (',' execute_var_string)* ')' (AS (LOGIN | USER) '=' STRING)? (AT_KEYWORD linkedServer=id_)? + | AS ( + (LOGIN | USER) '=' STRING + | CALLER + ) + ; + +execute_statement_arg + : + execute_statement_arg_unnamed (',' execute_statement_arg) * //Unnamed params can continue unnamed + | + execute_statement_arg_named (',' execute_statement_arg_named)* //Named can only be continued by unnamed + ; + +execute_statement_arg_named + : name=LOCAL_ID '=' value=execute_parameter + ; + +execute_statement_arg_unnamed + : value=execute_parameter + ; + +execute_parameter + : (constant | LOCAL_ID (OUTPUT | OUT)? | id_ | DEFAULT | NULL_) + ; + +execute_var_string + : LOCAL_ID (OUTPUT | OUT)? ('+' LOCAL_ID ('+' execute_var_string)?)? + | STRING ('+' LOCAL_ID ('+' execute_var_string)?)? + ; + +// https://msdn.microsoft.com/en-us/library/ff848791.aspx +security_statement + // https://msdn.microsoft.com/en-us/library/ms188354.aspx + : execute_clause ';'? + // https://msdn.microsoft.com/en-us/library/ms187965.aspx + | GRANT (ALL PRIVILEGES? | grant_permission ('(' column_name_list ')')?) (ON (class_type_for_grant '::')? on_id=table_name)? TO to_principal+=principal_id (',' to_principal+=principal_id)* (WITH GRANT OPTION)? (AS as_principal=principal_id)? ';'? + // https://msdn.microsoft.com/en-us/library/ms178632.aspx + | REVERT (WITH COOKIE '=' LOCAL_ID)? ';'? + | open_key + | close_key + | create_key + | create_certificate + ; + +principal_id + : id_ + | PUBLIC + ; + +create_certificate + : CREATE CERTIFICATE certificate_name=id_ (AUTHORIZATION user_name=id_)? + (FROM existing_keys | generate_new_keys) + (ACTIVE FOR BEGIN DIALOG '=' on_off)? + ; + +existing_keys + : ASSEMBLY assembly_name=id_ + | EXECUTABLE? FILE EQUAL path_to_file=STRING (WITH PRIVATE KEY '(' private_key_options ')')? + ; + +private_key_options + : (FILE | BINARY) '=' path=STRING (',' (DECRYPTION | ENCRYPTION) BY PASSWORD '=' password=STRING)? + ; + +generate_new_keys + : (ENCRYPTION BY PASSWORD '=' password=STRING)? + WITH SUBJECT EQUAL certificate_subject_name=STRING (',' date_options)* + ; + +date_options + : (START_DATE | EXPIRY_DATE) EQUAL STRING + ; + +open_key + : OPEN SYMMETRIC KEY key_name=id_ DECRYPTION BY decryption_mechanism + | OPEN MASTER KEY DECRYPTION BY PASSWORD '=' password=STRING + ; + +close_key + : CLOSE SYMMETRIC KEY key_name=id_ + | CLOSE ALL SYMMETRIC KEYS + | CLOSE MASTER KEY + ; + +create_key + : CREATE MASTER KEY ENCRYPTION BY PASSWORD '=' password=STRING + | CREATE SYMMETRIC KEY key_name=id_ + (AUTHORIZATION user_name=id_)? + (FROM PROVIDER provider_name=id_)? + WITH ((key_options | ENCRYPTION BY encryption_mechanism)','?)+ + ; + +key_options + : KEY_SOURCE EQUAL pass_phrase=STRING + | ALGORITHM EQUAL algorithm + | IDENTITY_VALUE EQUAL identity_phrase=STRING + | PROVIDER_KEY_NAME EQUAL key_name_in_provider=STRING + | CREATION_DISPOSITION EQUAL (CREATE_NEW | OPEN_EXISTING) + ; + +algorithm + : DES + | TRIPLE_DES + | TRIPLE_DES_3KEY + | RC2 + | RC4 + | RC4_128 + | DESX + | AES_128 + | AES_192 + | AES_256 + ; + +encryption_mechanism + : CERTIFICATE certificate_name=id_ + | ASYMMETRIC KEY asym_key_name=id_ + | SYMMETRIC KEY decrypting_Key_name=id_ + | PASSWORD '=' STRING + ; + +decryption_mechanism + : CERTIFICATE certificate_name=id_ (WITH PASSWORD EQUAL STRING)? + | ASYMMETRIC KEY asym_key_name=id_ (WITH PASSWORD EQUAL STRING)? + | SYMMETRIC KEY decrypting_Key_name=id_ + | PASSWORD EQUAL STRING + ; + +// https://docs.microsoft.com/en-us/sql/relational-databases/system-functions/sys-fn-builtin-permissions-transact-sql?view=sql-server-ver15 +// SELECT DISTINCT '| ' + permission_name +// FROM sys.fn_builtin_permissions (DEFAULT) +// ORDER BY 1 +grant_permission + : ADMINISTER ( BULK OPERATIONS | DATABASE BULK OPERATIONS) + | ALTER ( ANY ( APPLICATION ROLE + | ASSEMBLY + | ASYMMETRIC KEY + | AVAILABILITY GROUP + | CERTIFICATE + | COLUMN ( ENCRYPTION KEY | MASTER KEY ) + | CONNECTION + | CONTRACT + | CREDENTIAL + | DATABASE ( AUDIT + | DDL TRIGGER + | EVENT ( NOTIFICATION | SESSION ) + | SCOPED CONFIGURATION + )? + | DATASPACE + | ENDPOINT + | EVENT ( NOTIFICATION | SESSION ) + | EXTERNAL ( DATA SOURCE | FILE FORMAT | LIBRARY) + | FULLTEXT CATALOG + | LINKED SERVER + | LOGIN + | MASK + | MESSAGE TYPE + | REMOTE SERVICE BINDING + | ROLE + | ROUTE + | SCHEMA + | SECURITY POLICY + | SERVER ( AUDIT | ROLE ) + | SERVICE + | SYMMETRIC KEY + | USER + ) + | RESOURCES + | SERVER STATE + | SETTINGS + | TRACE + )? + | AUTHENTICATE SERVER? + | BACKUP ( DATABASE | LOG ) + | CHECKPOINT + | CONNECT ( ANY DATABASE | REPLICATION | SQL )? + | CONTROL SERVER? + | CREATE ( AGGREGATE + | ANY DATABASE + | ASSEMBLY + | ASYMMETRIC KEY + | AVAILABILITY GROUP + | CERTIFICATE + | CONTRACT + | DATABASE (DDL EVENT NOTIFICATION)? + | DDL EVENT NOTIFICATION + | DEFAULT + | ENDPOINT + | EXTERNAL LIBRARY + | FULLTEXT CATALOG + | FUNCTION + | MESSAGE TYPE + | PROCEDURE + | QUEUE + | REMOTE SERVICE BINDING + | ROLE + | ROUTE + | RULE + | SCHEMA + | SEQUENCE + | SERVER ROLE + | SERVICE + | SYMMETRIC KEY + | SYNONYM + | TABLE + | TRACE EVENT NOTIFICATION + | TYPE + | VIEW + | XML SCHEMA COLLECTION + ) + | DELETE + | EXECUTE ( ANY EXTERNAL SCRIPT )? + | EXTERNAL ACCESS ASSEMBLY + | IMPERSONATE ( ANY LOGIN )? + | INSERT + | KILL DATABASE CONNECTION + | RECEIVE + | REFERENCES + | SELECT ( ALL USER SECURABLES )? + | SEND + | SHOWPLAN + | SHUTDOWN + | SUBSCRIBE QUERY NOTIFICATIONS + | TAKE OWNERSHIP + | UNMASK + | UNSAFE ASSEMBLY + | UPDATE + | VIEW ( ANY ( DATABASE | DEFINITION | COLUMN ( ENCRYPTION | MASTER ) KEY DEFINITION ) + | CHANGE TRACKING + | DATABASE STATE + | DEFINITION + | SERVER STATE + ) + ; + +// https://msdn.microsoft.com/en-us/library/ms190356.aspx +// https://msdn.microsoft.com/en-us/library/ms189484.aspx +set_statement + : SET LOCAL_ID ('.' member_name=id_)? '=' expression + | SET LOCAL_ID assignment_operator expression + | SET LOCAL_ID '=' + CURSOR declare_set_cursor_common (FOR (READ ONLY | UPDATE (OF column_name_list)?))? + // https://msdn.microsoft.com/en-us/library/ms189837.aspx + | set_special + ; + +// https://msdn.microsoft.com/en-us/library/ms174377.aspx +transaction_statement + // https://msdn.microsoft.com/en-us/library/ms188386.aspx + : BEGIN DISTRIBUTED (TRAN | TRANSACTION) (id_ | LOCAL_ID)? + // https://msdn.microsoft.com/en-us/library/ms188929.aspx + | BEGIN (TRAN | TRANSACTION) ((id_ | LOCAL_ID) (WITH MARK STRING)?)? + // https://msdn.microsoft.com/en-us/library/ms190295.aspx + | COMMIT (TRAN | TRANSACTION) ((id_ | LOCAL_ID) (WITH '(' DELAYED_DURABILITY EQUAL (OFF | ON) ')')?)? + // https://msdn.microsoft.com/en-us/library/ms178628.aspx + | COMMIT WORK? + | COMMIT id_ + | ROLLBACK id_ + // https://msdn.microsoft.com/en-us/library/ms181299.aspx + | ROLLBACK (TRAN | TRANSACTION) (id_ | LOCAL_ID)? + // https://msdn.microsoft.com/en-us/library/ms174973.aspx + | ROLLBACK WORK? + // https://msdn.microsoft.com/en-us/library/ms188378.aspx + | SAVE (TRAN | TRANSACTION) (id_ | LOCAL_ID)? + ; + +// https://msdn.microsoft.com/en-us/library/ms188037.aspx +go_statement + : GO (count=DECIMAL)? + ; + +// https://msdn.microsoft.com/en-us/library/ms188366.aspx +use_statement + : USE database=id_ + ; + +setuser_statement + : SETUSER user=STRING? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/reconfigure-transact-sql +reconfigure_statement + : RECONFIGURE (WITH OVERRIDE)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/shutdown-transact-sql +shutdown_statement + : SHUTDOWN (WITH NOWAIT)? + ; + +checkpoint_statement + : CHECKPOINT (checkPointDuration=DECIMAL)? + ; + +dbcc_checkalloc_option + : ALL_ERRORMSGS + | NO_INFOMSGS + | TABLOCK + | ESTIMATEONLY + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-checkalloc-transact-sql?view=sql-server-ver16 +dbcc_checkalloc + : name=CHECKALLOC + ( + '(' + ( database=id_ | databaseid=STRING | DECIMAL ) + ( ',' NOINDEX | ',' ( REPAIR_ALLOW_DATA_LOSS | REPAIR_FAST | REPAIR_REBUILD ) )? + ')' + ( + WITH dbcc_option=dbcc_checkalloc_option ( ',' dbcc_option=dbcc_checkalloc_option )* + )? + )? + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-checkcatalog-transact-sql?view=sql-server-ver16 +dbcc_checkcatalog + : name=CHECKCATALOG + ( + '(' + ( database=id_ | databasename=STRING | DECIMAL ) + ')' + )? + ( + WITH dbcc_option=NO_INFOMSGS + )? + ; + +dbcc_checkconstraints_option + : ALL_CONSTRAINTS + | ALL_ERRORMSGS + | NO_INFOMSGS + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-checkconstraints-transact-sql?view=sql-server-ver16 +dbcc_checkconstraints + : name=CHECKCONSTRAINTS + ( + '(' + ( table_or_constraint=id_ | table_or_constraint_name=STRING ) + ')' + )? + ( + WITH dbcc_option=dbcc_checkconstraints_option (',' dbcc_option=dbcc_checkconstraints_option)* + )? + ; + +dbcc_checkdb_table_option + : ALL_ERRORMSGS + | EXTENDED_LOGICAL_CHECKS + | NO_INFOMSGS + | TABLOCK + | ESTIMATEONLY + | PHYSICAL_ONLY + | DATA_PURITY + | MAXDOP '=' max_dregree_of_parallelism=DECIMAL + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-checkdb-transact-sql?view=sql-server-ver16 +dbcc_checkdb + : name=CHECKDB + ( + '(' + ( database=id_ | databasename=STRING | DECIMAL ) + ( + ',' ( + NOINDEX + | REPAIR_ALLOW_DATA_LOSS + | REPAIR_FAST + | REPAIR_REBUILD + ) + )? + ')' + )? + ( + WITH dbcc_option=dbcc_checkdb_table_option (',' dbcc_option=dbcc_checkdb_table_option)* + )? + ; + +dbcc_checkfilegroup_option + : ALL_ERRORMSGS + | NO_INFOMSGS + | TABLOCK + | ESTIMATEONLY + | PHYSICAL_ONLY + | MAXDOP '=' max_dregree_of_parallelism=DECIMAL + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-checkfilegroup-transact-sql?view=sql-server-ver16 +// Additional parameters: https://dbtut.com/index.php/2019/01/01/dbcc-checkfilegroup-command-on-sql-server/ +dbcc_checkfilegroup + : name=CHECKFILEGROUP + ( + '(' + ( filegroup_id=DECIMAL | filegroup_name=STRING ) + ( + ',' ( + NOINDEX + | REPAIR_ALLOW_DATA_LOSS + | REPAIR_FAST + | REPAIR_REBUILD + ) + )? + ')' + )? + ( + WITH dbcc_option=dbcc_checkfilegroup_option (',' dbcc_option=dbcc_checkfilegroup_option)* + )? + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-checktable-transact-sql?view=sql-server-ver16 +dbcc_checktable + : name=CHECKTABLE + '(' + table_or_view_name=STRING + ( ',' ( + NOINDEX + | index_id=expression + | REPAIR_ALLOW_DATA_LOSS + | REPAIR_FAST + | REPAIR_REBUILD + ) + )? + ')' + ( + WITH dbcc_option=dbcc_checkdb_table_option (',' dbcc_option=dbcc_checkdb_table_option)* + )? + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-cleantable-transact-sql?view=sql-server-ver16 +dbcc_cleantable + : name=CLEANTABLE + '(' + ( database=id_ | databasename=STRING | DECIMAL ) + ',' ( table_or_view=id_ | table_or_view_name=STRING ) + ( ',' batch_size=DECIMAL )? + ')' + ( WITH dbcc_option=NO_INFOMSGS )? + ; + +dbcc_clonedatabase_option + : NO_STATISTICS + | NO_QUERYSTORE + | SERVICEBROKER + | VERIFY_CLONEDB + | BACKUP_CLONEDB + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-clonedatabase-transact-sql?view=sql-server-ver16 +dbcc_clonedatabase + : name=CLONEDATABASE + '(' + source_database=id_ + ',' target_database=id_ + ')' + ( WITH dbcc_option=dbcc_clonedatabase_option (',' dbcc_option=dbcc_clonedatabase_option)* )? + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-pdw-showspaceused-transact-sql?view=aps-pdw-2016-au7 +dbcc_pdw_showspaceused + : name=PDW_SHOWSPACEUSED ( '(' tablename=id_ ')' ) ? ( WITH dbcc_option=IGNORE_REPLICATED_TABLE_CACHE )? ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-proccache-transact-sql?view=sql-server-ver16 +dbcc_proccache + : name=PROCCACHE ( WITH dbcc_option=NO_INFOMSGS )? ; + +dbcc_showcontig_option + : ALL_INDEXES + | TABLERESULTS + | FAST + | ALL_LEVELS + | NO_INFOMSGS + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-showcontig-transact-sql?view=sql-server-ver16 +dbcc_showcontig + : name=SHOWCONTIG + ( + '(' + table_or_view=expression + ( + ',' index=expression + )? + ')' + )? + ( WITH dbcc_option=dbcc_showcontig_option (',' dbcc_showcontig_option)* )? + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-shrinklog-azure-sql-data-warehouse?view=aps-pdw-2016-au7 +dbcc_shrinklog + : name=SHRINKLOG + ('(' SIZE '=' ( (DECIMAL ( MB | GB | TB ) ) | DEFAULT ) ')')? + ( WITH dbcc_option=NO_INFOMSGS )? + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-dbreindex-transact-sql?view=sql-server-ver16 +dbcc_dbreindex + : name=DBREINDEX + '(' + table=id_or_string + ( ',' index_name=id_or_string ( ',' fillfactor=expression)? )? + ')' + ( + WITH dbcc_option=NO_INFOMSGS + )? + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-dllname-free-transact-sql?view=sql-server-ver16 +dbcc_dll_free + : dllname=id_ + '(' name=FREE ')' + ( + WITH dbcc_option=NO_INFOMSGS + )? + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-dropcleanbuffers-transact-sql?view=sql-server-ver16 +dbcc_dropcleanbuffers + : name=DROPCLEANBUFFERS + ( + '(' + COMPUTE | ALL + ')' + )? + ( + WITH dbcc_option=NO_INFOMSGS + )? + ; + +dbcc_clause + : DBCC ( + dbcc_checkalloc + | dbcc_checkcatalog + | dbcc_checkconstraints + | dbcc_checkdb + | dbcc_checkfilegroup + | dbcc_checktable + | dbcc_cleantable + | dbcc_clonedatabase + | dbcc_dbreindex + | dbcc_dll_free + | dbcc_dropcleanbuffers + | dbcc_pdw_showspaceused + | dbcc_proccache + | dbcc_showcontig + | dbcc_shrinklog + ) + ; + +execute_clause + : EXECUTE AS clause=(CALLER | SELF | OWNER | STRING) + ; + +declare_local + : LOCAL_ID AS? data_type ('=' expression)? + ; + +table_type_definition + : TABLE '(' column_def_table_constraints (','? table_type_indices)* ')' + ; + +table_type_indices + : (((PRIMARY KEY | INDEX id_) (CLUSTERED | NONCLUSTERED)?) | UNIQUE) '(' column_name_list_with_order ')' + | CHECK '(' search_condition ')' + ; + +xml_type_definition + : XML '(' ( CONTENT | DOCUMENT )? xml_schema_collection ')' + ; + +xml_schema_collection + : ID '.' ID + ; + +column_def_table_constraints + : column_def_table_constraint (','? column_def_table_constraint)* + ; + +column_def_table_constraint + : column_definition + | materialized_column_definition + | table_constraint + ; + +// https://msdn.microsoft.com/en-us/library/ms187742.aspx +// There is a documentation error: column definition elements can be given in +// any order +column_definition + : id_ (data_type | AS expression PERSISTED? ) + column_definition_element* + column_index? + ; + +column_definition_element + : FILESTREAM + | COLLATE collation_name=id_ + | SPARSE + | MASKED WITH '(' FUNCTION '=' mask_function=STRING ')' + | (CONSTRAINT constraint=id_)? DEFAULT constant_expr=expression + | IDENTITY ('(' seed=DECIMAL ',' increment=DECIMAL ')')? + | NOT FOR REPLICATION + | GENERATED ALWAYS AS ( ROW | TRANSACTION_ID | SEQUENCE_NUMBER ) ( START | END ) HIDDEN_KEYWORD? + // NULL / NOT NULL is a constraint + | ROWGUIDCOL + | ENCRYPTED WITH + '(' COLUMN_ENCRYPTION_KEY '=' key_name=STRING ',' + ENCRYPTION_TYPE '=' ( DETERMINISTIC | RANDOMIZED ) ',' + ALGORITHM '=' algo=STRING + ')' + | column_constraint + ; + +column_modifier + : id_ (ADD | DROP) ( + ROWGUIDCOL + | PERSISTED + | NOT FOR REPLICATION + | SPARSE + | HIDDEN_KEYWORD + | MASKED (WITH (FUNCTION EQUAL STRING | LR_BRACKET FUNCTION EQUAL STRING RR_BRACKET))?) + ; + +materialized_column_definition + : id_ (COMPUTE | AS) expression (MATERIALIZED | NOT MATERIALIZED)? + ; + +// https://msdn.microsoft.com/en-us/library/ms186712.aspx +// There is a documentation error: NOT NULL is a constraint +// and therefore can be given a name. +column_constraint + : (CONSTRAINT constraint=id_)? + ( + null_notnull + | ( + (PRIMARY KEY | UNIQUE) + clustered? + primary_key_options + ) + | ( + (FOREIGN KEY)? + foreign_key_options + ) + | check_constraint + ) + ; + +column_index + : + INDEX index_name=id_ clustered? + create_table_index_options? + on_partition_or_filegroup? + ( FILESTREAM_ON ( filestream_filegroup_or_partition_schema_name=id_ | NULL_DOUBLE_QUOTE ) )? + ; + +on_partition_or_filegroup + : + ON ( + (partition_scheme_name=id_ '(' partition_column_name=id_ ')') + | filegroup=id_ + | DEFAULT_DOUBLE_QUOTE + ) + ; + +// https://msdn.microsoft.com/en-us/library/ms188066.aspx +table_constraint + : (CONSTRAINT constraint=id_)? + ( + ( + (PRIMARY KEY | UNIQUE) + clustered? + '(' column_name_list_with_order ')' + primary_key_options + ) + | + ( + FOREIGN KEY + '(' fk = column_name_list ')' + foreign_key_options + ) + | + ( + CONNECTION + '(' connection_node ( ',' connection_node )* ')' + ) + | + ( + DEFAULT constant_expr=expression FOR column=id_ (WITH VALUES)? + ) + | check_constraint + ) + ; + +connection_node + : + from_node_table=id_ TO to_node_table=id_ + ; + +primary_key_options + : + (WITH FILLFACTOR '=' DECIMAL)? + alter_table_index_options? + on_partition_or_filegroup? + ; + +foreign_key_options + : + REFERENCES table_name '(' pk = column_name_list')' + (on_delete | on_update)* + (NOT FOR REPLICATION)? + ; + +check_constraint + : + CHECK (NOT FOR REPLICATION)? '(' search_condition ')' + ; + +on_delete + : ON DELETE (NO ACTION | CASCADE | SET NULL_ | SET DEFAULT) + ; + +on_update + : ON UPDATE (NO ACTION | CASCADE | SET NULL_ | SET DEFAULT) + ; + +alter_table_index_options + : WITH '(' alter_table_index_option (',' alter_table_index_option)* ')' + ; + +// https://msdn.microsoft.com/en-us/library/ms186869.aspx +alter_table_index_option + : PAD_INDEX '=' on_off + | FILLFACTOR '=' DECIMAL + | IGNORE_DUP_KEY '=' on_off + | STATISTICS_NORECOMPUTE '=' on_off + | ALLOW_ROW_LOCKS '=' on_off + | ALLOW_PAGE_LOCKS '=' on_off + | OPTIMIZE_FOR_SEQUENTIAL_KEY '=' on_off + | SORT_IN_TEMPDB '=' on_off + | MAXDOP '=' max_degree_of_parallelism=DECIMAL + | DATA_COMPRESSION '=' (NONE | ROW | PAGE | COLUMNSTORE | COLUMNSTORE_ARCHIVE) + on_partitions? + | XML_COMPRESSION '=' on_off + on_partitions? + | DISTRIBUTION '=' HASH '(' id_ ')' | CLUSTERED INDEX '(' id_ (ASC | DESC)? (',' id_ (ASC | DESC)?)* ')' + | ONLINE '=' (ON ('(' low_priority_lock_wait ')')? | OFF) + | RESUMABLE '=' on_off + | MAX_DURATION '=' times=DECIMAL MINUTES? + ; + +// https://msdn.microsoft.com/en-us/library/ms180169.aspx +declare_cursor + : DECLARE cursor_name + (CURSOR (declare_set_cursor_common (FOR UPDATE (OF column_name_list)?)?)? + | (SEMI_SENSITIVE | INSENSITIVE)? SCROLL? CURSOR FOR select_statement_standalone (FOR (READ ONLY | UPDATE | (OF column_name_list)))? + ) ';'? + ; + +declare_set_cursor_common + : declare_set_cursor_common_partial* + FOR select_statement_standalone + ; + +declare_set_cursor_common_partial + : (LOCAL | GLOBAL) + | (FORWARD_ONLY | SCROLL) + | (STATIC | KEYSET | DYNAMIC | FAST_FORWARD) + | (READ_ONLY | SCROLL_LOCKS | OPTIMISTIC) + | TYPE_WARNING + ; + +fetch_cursor + : FETCH ((NEXT | PRIOR | FIRST | LAST | (ABSOLUTE | RELATIVE) expression)? FROM)? + GLOBAL? cursor_name (INTO LOCAL_ID (',' LOCAL_ID)*)? ';'? + ; + +// https://msdn.microsoft.com/en-us/library/ms190356.aspx +// Runtime check. +set_special + : SET id_ (id_ | constant_LOCAL_ID | on_off) ';'? + | SET STATISTICS (IO | TIME | XML | PROFILE) on_off ';'? + | SET ROWCOUNT (LOCAL_ID | DECIMAL) ';'? + | SET TEXTSIZE DECIMAL ';'? + // https://msdn.microsoft.com/en-us/library/ms173763.aspx + | SET TRANSACTION ISOLATION LEVEL + (READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SNAPSHOT | SERIALIZABLE | DECIMAL) ';'? + // https://msdn.microsoft.com/en-us/library/ms188059.aspx + | SET IDENTITY_INSERT table_name on_off ';'? + | SET special_list (',' special_list)* on_off + | SET modify_method + ; + +special_list + : ANSI_NULLS + | QUOTED_IDENTIFIER + | ANSI_PADDING + | ANSI_WARNINGS + | ANSI_DEFAULTS + | ANSI_NULL_DFLT_OFF + | ANSI_NULL_DFLT_ON + | ARITHABORT + | ARITHIGNORE + | CONCAT_NULL_YIELDS_NULL + | CURSOR_CLOSE_ON_COMMIT + | FMTONLY + | FORCEPLAN + | IMPLICIT_TRANSACTIONS + | NOCOUNT + | NOEXEC + | NUMERIC_ROUNDABORT + | PARSEONLY + | REMOTE_PROC_TRANSACTIONS + | SHOWPLAN_ALL + | SHOWPLAN_TEXT + | SHOWPLAN_XML + | XACT_ABORT + ; + +constant_LOCAL_ID + : constant + | LOCAL_ID + ; + +// Expression. + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/expressions-transact-sql +// Operator precendence: https://docs.microsoft.com/en-us/sql/t-sql/language-elements/operator-precedence-transact-sql +expression + : primitive_expression + | full_column_name + | function_call + | expression '.' (value_call | query_call | exist_call | modify_call) + | expression '.' hierarchyid_call + | expression COLLATE id_ + | case_expression + | bracket_expression + | unary_operator_expression + | expression op=('*' | '/' | '%') expression + | expression op=('+' | '-' | '&' | '^' | '|' | '||') expression + | expression time_zone + | over_clause + | DOLLAR_ACTION + ; + +parameter + : PLACEHOLDER; + +time_zone + : AT_KEYWORD TIME ZONE expression + ; + +primitive_expression + : DEFAULT | NULL_ | LOCAL_ID | primitive_constant + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/case-transact-sql +case_expression + : CASE caseExpr=expression switch_section+ (ELSE elseExpr=expression)? END + | CASE switch_search_condition_section+ (ELSE elseExpr=expression)? END + ; + +unary_operator_expression + : '~' expression + | op=('+' | '-') expression + ; + +bracket_expression + : '(' expression ')' | '(' subquery ')' + ; + +subquery + : select_statement + ; + +// https://msdn.microsoft.com/en-us/library/ms175972.aspx +with_expression + : WITH ctes+=common_table_expression (',' ctes+=common_table_expression)* + ; + +common_table_expression + : expression_name=id_ ('(' columns=column_name_list ')')? AS '(' cte_query=select_statement ')' + ; + +update_elem + : LOCAL_ID '=' full_column_name ('=' | assignment_operator) expression //Combined variable and column update + | (full_column_name | LOCAL_ID) ('=' | assignment_operator) expression + | udt_column_name=id_ '.' method_name=id_ '(' expression_list_ ')' + //| full_column_name '.' WRITE (expression, ) + ; + +update_elem_merge + : (full_column_name | LOCAL_ID) ('=' | assignment_operator) expression + | udt_column_name=id_ '.' method_name=id_ '(' expression_list_ ')' + //| full_column_name '.' WRITE (expression, ) + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/queries/search-condition-transact-sql +search_condition + : NOT* (predicate | '(' search_condition ')') + | search_condition AND search_condition // AND takes precedence over OR + | search_condition OR search_condition + ; + +predicate + : EXISTS '(' subquery ')' + | freetext_predicate + | expression comparison_operator expression + | expression MULT_ASSIGN expression ////SQL-82 syntax for left outer joins; '*='. See https://stackoverflow.com/questions/40665/in-sybase-sql + | expression comparison_operator (ALL | SOME | ANY) '(' subquery ')' + | expression NOT* BETWEEN expression AND expression + | expression NOT* IN '(' (subquery | expression_list_) ')' + | expression NOT* LIKE expression (ESCAPE expression)? + | expression IS null_notnull + ; + +// Changed union rule to sql_union to avoid union construct with C++ target. Issue reported by person who generates into C++. This individual reports change causes generated code to work + +query_expression + : query_specification select_order_by_clause? unions+=sql_union* //if using top, order by can be on the "top" side of union :/ + | '(' query_expression ')' (UNION ALL? query_expression)? + ; + +sql_union + : (UNION ALL? | EXCEPT | INTERSECT) (spec=query_specification | ('(' op=query_expression ')')) + ; + +// https://msdn.microsoft.com/en-us/library/ms176104.aspx +query_specification + : SELECT allOrDistinct=(ALL | DISTINCT)? top=top_clause? + columns=select_list + // https://msdn.microsoft.com/en-us/library/ms188029.aspx + (INTO into=table_name)? + from_table_sources? + (WHERE where=search_condition)? + // https://msdn.microsoft.com/en-us/library/ms177673.aspx + group_by_clause? + having_clause? + ; + +group_by_clause + : GROUP BY ((groupByAll=ALL? groupBys+=group_by_item (',' groupBys+=group_by_item)*) | GROUPING SETS '(' groupSets+=grouping_sets_item (',' groupSets+=grouping_sets_item)* ')') + ; + +having_clause + : HAVING having=search_condition + ; + +from_table_sources + : FROM from=table_sources + ; + +// https://msdn.microsoft.com/en-us/library/ms189463.aspx +top_clause + : TOP (top_percent | top_count) (WITH TIES)? + ; + +top_percent + : percent_constant=(REAL | FLOAT | DECIMAL) PERCENT + | '(' topper_expression=expression ')' PERCENT + ; + +top_count + : count_constant=DECIMAL + | '(' topcount_expression=expression ')' + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/queries/select-over-clause-transact-sql?view=sql-server-ver16 +order_by_clause + : ORDER BY order_bys+=order_by_expression (',' order_bys+=order_by_expression)* + ; + +// https://msdn.microsoft.com/en-us/library/ms188385.aspx +select_order_by_clause + : order_by_clause + (OFFSET offset_exp=expression offset_rows=(ROW | ROWS) (FETCH fetch_offset=(FIRST | NEXT) fetch_exp=expression fetch_rows=(ROW | ROWS) ONLY)?)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/queries/select-for-clause-transact-sql +for_clause + : FOR BROWSE + | FOR XML (RAW ('(' STRING ')')? | AUTO) xml_common_directives* + (COMMA (XMLDATA | XMLSCHEMA ('(' STRING ')')?))? + (COMMA ELEMENTS (XSINIL | ABSENT)?)? + | FOR XML EXPLICIT xml_common_directives* + (COMMA XMLDATA)? + | FOR XML PATH ('(' STRING ')')? xml_common_directives* + (COMMA ELEMENTS (XSINIL | ABSENT)?)? + | FOR JSON (AUTO | PATH) + ( COMMA + ( ROOT ('(' STRING ')') + | INCLUDE_NULL_VALUES + | WITHOUT_ARRAY_WRAPPER + ) + )* + ; + +xml_common_directives + : ',' (BINARY_KEYWORD BASE64 | TYPE | ROOT ('(' STRING ')')?) + ; + +order_by_expression + : order_by=expression (ascending=ASC | descending=DESC)? + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/queries/select-group-by-transact-sql?view=sql-server-ver15 +grouping_sets_item + : '('? groupSetItems+=group_by_item (',' groupSetItems+=group_by_item)* ')'? + | '(' ')' + ; + +group_by_item + : expression + /*| rollup_spec + | cube_spec + | grouping_sets_spec + | grand_total*/ + ; + +option_clause + // https://msdn.microsoft.com/en-us/library/ms181714.aspx + : OPTION '(' options+=option (',' options+=option)* ')' + ; + +option + : FAST number_rows=DECIMAL + | (HASH | ORDER) GROUP + | (MERGE | HASH | CONCAT) UNION + | (LOOP | MERGE | HASH) JOIN + | EXPAND VIEWS + | FORCE ORDER + | IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX + | KEEP PLAN + | KEEPFIXED PLAN + | MAXDOP number_of_processors=DECIMAL + | MAXRECURSION number_recursion=DECIMAL + | OPTIMIZE FOR '(' optimize_for_arg (',' optimize_for_arg)* ')' + | OPTIMIZE FOR UNKNOWN + | PARAMETERIZATION (SIMPLE | FORCED) + | RECOMPILE + | ROBUST PLAN + | USE PLAN STRING + ; + +optimize_for_arg + : LOCAL_ID (UNKNOWN | '=' (constant | NULL_)) + ; + +// https://msdn.microsoft.com/en-us/library/ms176104.aspx +select_list + : selectElement+=select_list_elem (',' selectElement+=select_list_elem)* + ; + +udt_method_arguments + : '(' argument+=execute_var_string (',' argument+=execute_var_string)* ')' + ; + +// https://docs.microsoft.com/ru-ru/sql/t-sql/queries/select-clause-transact-sql +asterisk + : (table_name '.')? '*' + | (INSERTED | DELETED) '.' '*' + ; + +udt_elem + : udt_column_name=id_ '.' non_static_attr=id_ udt_method_arguments as_column_alias? + | udt_column_name=id_ DOUBLE_COLON static_attr=id_ udt_method_arguments? as_column_alias? + ; + +expression_elem + : leftAlias=column_alias eq='=' leftAssignment=expression + | expressionAs=expression as_column_alias? + ; + +select_list_elem + : asterisk + | udt_elem + | LOCAL_ID (assignment_operator | '=') expression + | expression_elem + ; + +table_sources + : source+=table_source (',' source+=table_source)* + ; + + +// https://docs.microsoft.com/en-us/sql/t-sql/queries/from-transact-sql +table_source + : table_source_item joins+=join_part* + ; + +table_source_item + : full_table_name deprecated_table_hint as_table_alias // this is currently allowed + | full_table_name as_table_alias? (with_table_hints | deprecated_table_hint | sybase_legacy_hints)? + | rowset_function as_table_alias? + | '(' derived_table ')' (as_table_alias column_alias_list?)? + | change_table as_table_alias? + | nodes_method (as_table_alias column_alias_list?)? + | function_call (as_table_alias column_alias_list?)? + | loc_id=LOCAL_ID as_table_alias? + | loc_id_call=LOCAL_ID '.' loc_fcall=function_call (as_table_alias column_alias_list?)? + | open_xml + | open_json + | DOUBLE_COLON oldstyle_fcall=function_call as_table_alias? // Build-in function (old syntax) + | '(' table_source ')' + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/functions/openxml-transact-sql +open_xml + : OPENXML '(' expression ',' expression (',' expression)? ')' + (WITH '(' schema_declaration ')' )? as_table_alias? + ; + +open_json + : OPENJSON '(' expression (',' expression)? ')' + (WITH '(' json_declaration ')' )? as_table_alias? + ; + +json_declaration + : json_col+=json_column_declaration (',' json_col+=json_column_declaration)* + ; + +json_column_declaration + : column_declaration (AS JSON)? + ; + +schema_declaration + : xml_col+=column_declaration (',' xml_col+=column_declaration)* + ; + +column_declaration + : id_ data_type STRING? + ; + +change_table + : change_table_changes + | change_table_version + ; + +change_table_changes + : CHANGETABLE '(' CHANGES changetable=table_name ',' changesid=(NULL_ | DECIMAL | LOCAL_ID) ')' + ; +change_table_version + : CHANGETABLE '(' VERSION versiontable=table_name ',' pk_columns=full_column_name_list ',' pk_values=select_list ')' + ; + +// https://msdn.microsoft.com/en-us/library/ms191472.aspx +join_part + // https://msdn.microsoft.com/en-us/library/ms173815(v=sql.120).aspx + : join_on + | cross_join + | apply_ + | pivot + | unpivot + ; +join_on + : (inner=INNER? | join_type=(LEFT | RIGHT | FULL) outer=OUTER?) (join_hint=(LOOP | HASH | MERGE | REMOTE))? + JOIN source=table_source ON cond=search_condition + ; + +cross_join + : CROSS JOIN table_source_item + ; + +apply_ + : apply_style=(CROSS | OUTER) APPLY source=table_source_item + ; + +pivot + : PIVOT pivot_clause as_table_alias + ; + +unpivot + : UNPIVOT unpivot_clause as_table_alias + ; + +pivot_clause + : '(' aggregate_windowed_function FOR full_column_name IN column_alias_list ')' + ; + +unpivot_clause + : '(' unpivot_exp=expression FOR full_column_name IN '(' full_column_name_list ')' ')' + ; + +full_column_name_list + : column+=full_column_name (',' column+=full_column_name)* + ; + +// https://msdn.microsoft.com/en-us/library/ms190312.aspx +rowset_function + : ( + OPENROWSET LR_BRACKET provider_name = STRING COMMA connectionString = STRING COMMA sql = STRING RR_BRACKET + ) + | ( OPENROWSET '(' BULK data_file=STRING ',' (bulk_option (',' bulk_option)* | id_)')' ) + ; + +// runtime check. +bulk_option + : id_ '=' bulk_option_value=(DECIMAL | STRING) + ; + +derived_table + : subquery + | '(' subquery (UNION ALL subquery)* ')' + | table_value_constructor + | '(' table_value_constructor ')' + ; + +function_call + : ranking_windowed_function #RANKING_WINDOWED_FUNC + | aggregate_windowed_function #AGGREGATE_WINDOWED_FUNC + | analytic_windowed_function #ANALYTIC_WINDOWED_FUNC + | built_in_functions #BUILT_IN_FUNC + | scalar_function_name '(' expression_list_? ')' #SCALAR_FUNCTION + | freetext_function #FREE_TEXT + | partition_function #PARTITION_FUNC + | hierarchyid_static_method #HIERARCHYID_METHOD + ; + +partition_function + : (database=id_ '.')? DOLLAR_PARTITION '.' func_name=id_ '(' expression ')' + ; + +freetext_function + : (CONTAINSTABLE | FREETEXTTABLE) '(' table_name ',' (full_column_name | '(' full_column_name (',' full_column_name)* ')' | '*' ) ',' expression (',' LANGUAGE expression)? (',' expression)? ')' + | (SEMANTICSIMILARITYTABLE | SEMANTICKEYPHRASETABLE) '(' table_name ',' (full_column_name | '(' full_column_name (',' full_column_name)* ')' | '*' ) ',' expression ')' + | SEMANTICSIMILARITYDETAILSTABLE '(' table_name ',' full_column_name ',' expression ',' full_column_name ',' expression ')' + ; + +freetext_predicate + : CONTAINS '(' (full_column_name | '(' full_column_name (',' full_column_name)* ')' | '*' | PROPERTY '(' full_column_name ',' expression ')') ',' expression ')' + | FREETEXT '(' (table_name ',')? (full_column_name | '(' full_column_name (',' full_column_name)* ')' | '*' ) ',' expression (',' LANGUAGE expression)? ')' + ; + +json_key_value + : json_key_name=expression ':' value_expression=expression + ; + +json_null_clause + : (ABSENT | NULL_) ON NULL_ + ; + +built_in_functions + // Metadata functions + // https://docs.microsoft.com/en-us/sql/t-sql/functions/app-name-transact-sql?view=sql-server-ver16 + : APP_NAME '(' ')' #APP_NAME + // https://docs.microsoft.com/en-us/sql/t-sql/functions/applock-mode-transact-sql?view=sql-server-ver16 + | APPLOCK_MODE '(' database_principal=expression ',' resource_name=expression ',' lock_owner=expression ')' #APPLOCK_MODE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/applock-test-transact-sql?view=sql-server-ver16 + | APPLOCK_TEST '(' database_principal=expression ',' resource_name=expression ',' lock_mode=expression ',' lock_owner=expression ')' #APPLOCK_TEST + // https://docs.microsoft.com/en-us/sql/t-sql/functions/assemblyproperty-transact-sql?view=sql-server-ver16 + | ASSEMBLYPROPERTY '(' assembly_name=expression ',' property_name=expression ')' #ASSEMBLYPROPERTY + // https://docs.microsoft.com/en-us/sql/t-sql/functions/col-length-transact-sql?view=sql-server-ver16 + | COL_LENGTH '(' table=expression ',' column=expression ')' #COL_LENGTH + // https://docs.microsoft.com/en-us/sql/t-sql/functions/col-name-transact-sql?view=sql-server-ver16 + | COL_NAME '(' table_id=expression ',' column_id=expression ')' #COL_NAME + // https://docs.microsoft.com/en-us/sql/t-sql/functions/columnproperty-transact-sql?view=sql-server-ver16 + | COLUMNPROPERTY '(' id=expression ',' column=expression ',' property=expression ')' #COLUMNPROPERTY + // https://docs.microsoft.com/en-us/sql/t-sql/functions/databasepropertyex-transact-sql?view=sql-server-ver16 + | DATABASEPROPERTYEX '(' database=expression ',' property=expression ')' #DATABASEPROPERTYEX + // https://docs.microsoft.com/en-us/sql/t-sql/functions/db-id-transact-sql?view=sql-server-ver16 + | DB_ID '(' database_name=expression? ')' #DB_ID + // https://docs.microsoft.com/en-us/sql/t-sql/functions/db-name-transact-sql?view=sql-server-ver16 + | DB_NAME '(' database_id=expression? ')' #DB_NAME + // https://docs.microsoft.com/en-us/sql/t-sql/functions/file-id-transact-sql?view=sql-server-ver16 + | FILE_ID '(' file_name=expression ')' #FILE_ID + // https://docs.microsoft.com/en-us/sql/t-sql/functions/file-idex-transact-sql?view=sql-server-ver16 + | FILE_IDEX '(' file_name=expression ')' #FILE_IDEX + // https://docs.microsoft.com/en-us/sql/t-sql/functions/file-name-transact-sql?view=sql-server-ver16 + | FILE_NAME '(' file_id=expression ')' #FILE_NAME + // https://docs.microsoft.com/en-us/sql/t-sql/functions/filegroup-id-transact-sql?view=sql-server-ver16 + | FILEGROUP_ID '(' filegroup_name=expression ')' #FILEGROUP_ID + // https://docs.microsoft.com/en-us/sql/t-sql/functions/filegroup-name-transact-sql?view=sql-server-ver16 + | FILEGROUP_NAME '(' filegroup_id=expression ')' #FILEGROUP_NAME + // https://docs.microsoft.com/en-us/sql/t-sql/functions/filegroupproperty-transact-sql?view=sql-server-ver16 + | FILEGROUPPROPERTY '(' filegroup_name=expression ',' property=expression ')' #FILEGROUPPROPERTY + // https://docs.microsoft.com/en-us/sql/t-sql/functions/fileproperty-transact-sql?view=sql-server-ver16 + | FILEPROPERTY '(' file_name=expression ',' property=expression ')' #FILEPROPERTY + // https://docs.microsoft.com/en-us/sql/t-sql/functions/filepropertyex-transact-sql?view=sql-server-ver16 + | FILEPROPERTYEX '(' name=expression ',' property=expression ')' #FILEPROPERTYEX + // https://docs.microsoft.com/en-us/sql/t-sql/functions/fulltextcatalogproperty-transact-sql?view=sql-server-ver16 + | FULLTEXTCATALOGPROPERTY '(' catalog_name=expression ',' property=expression ')' #FULLTEXTCATALOGPROPERTY + // https://docs.microsoft.com/en-us/sql/t-sql/functions/fulltextserviceproperty-transact-sql?view=sql-server-ver16 + | FULLTEXTSERVICEPROPERTY '(' property=expression ')' #FULLTEXTSERVICEPROPERTY + // https://docs.microsoft.com/en-us/sql/t-sql/functions/index-col-transact-sql?view=sql-server-ver16 + | INDEX_COL '(' table_or_view_name=expression ',' index_id=expression ',' key_id=expression ')' #INDEX_COL + // https://docs.microsoft.com/en-us/sql/t-sql/functions/indexkey-property-transact-sql?view=sql-server-ver16 + | INDEXKEY_PROPERTY '(' object_id=expression ',' index_id=expression ',' key_id=expression ',' property=expression ')' #INDEXKEY_PROPERTY + // https://docs.microsoft.com/en-us/sql/t-sql/functions/indexproperty-transact-sql?view=sql-server-ver16 + | INDEXPROPERTY '(' object_id=expression ',' index_or_statistics_name=expression ',' property=expression ')' #INDEXPROPERTY + // https://docs.microsoft.com/en-us/sql/t-sql/functions/next-value-for-transact-sql?view=sql-server-ver16 + | NEXT VALUE FOR sequence_name=table_name ( OVER '(' order_by_clause ')' )? #NEXT_VALUE_FOR + // https://docs.microsoft.com/en-us/sql/t-sql/functions/object-definition-transact-sql?view=sql-server-ver16 + | OBJECT_DEFINITION '(' object_id=expression ')' #OBJECT_DEFINITION + // https://docs.microsoft.com/en-us/sql/t-sql/functions/object-id-transact-sql?view=sql-server-ver16 + | OBJECT_ID '(' object_name=expression ( ',' object_type=expression )? ')' #OBJECT_ID + // https://docs.microsoft.com/en-us/sql/t-sql/functions/object-name-transact-sql?view=sql-server-ver16 + | OBJECT_NAME '(' object_id=expression ( ',' database_id=expression )? ')' #OBJECT_NAME + // https://docs.microsoft.com/en-us/sql/t-sql/functions/object-schema-name-transact-sql?view=sql-server-ver16 + | OBJECT_SCHEMA_NAME '(' object_id=expression ( ',' database_id=expression )? ')' #OBJECT_SCHEMA_NAME + // https://docs.microsoft.com/en-us/sql/t-sql/functions/objectproperty-transact-sql?view=sql-server-ver16 + | OBJECTPROPERTY '(' id=expression ',' property=expression ')' #OBJECTPROPERTY + // https://docs.microsoft.com/en-us/sql/t-sql/functions/objectpropertyex-transact-sql?view=sql-server-ver16 + | OBJECTPROPERTYEX '(' id=expression ',' property=expression ')' #OBJECTPROPERTYEX + // https://docs.microsoft.com/en-us/sql/t-sql/functions/original-db-name-transact-sql?view=sql-server-ver16 + | ORIGINAL_DB_NAME '(' ')' #ORIGINAL_DB_NAME + // https://docs.microsoft.com/en-us/sql/t-sql/functions/parsename-transact-sql?view=sql-server-ver16 + | PARSENAME '(' object_name=expression ',' object_piece=expression ')' #PARSENAME + // https://docs.microsoft.com/en-us/sql/t-sql/functions/schema-id-transact-sql?view=sql-server-ver16 + | SCHEMA_ID '(' schema_name=expression? ')' #SCHEMA_ID + // https://docs.microsoft.com/en-us/sql/t-sql/functions/schema-name-transact-sql?view=sql-server-ver16 + | SCHEMA_NAME '(' schema_id=expression? ')' #SCHEMA_NAME + // https://docs.microsoft.com/en-us/sql/t-sql/functions/scope-identity-transact-sql?view=sql-server-ver16 + | SCOPE_IDENTITY '(' ')' #SCOPE_IDENTITY + // https://docs.microsoft.com/en-us/sql/t-sql/functions/serverproperty-transact-sql?view=sql-server-ver16 + | SERVERPROPERTY '(' property=expression ')' #SERVERPROPERTY + // https://docs.microsoft.com/en-us/sql/t-sql/functions/stats-date-transact-sql?view=sql-server-ver16 + | STATS_DATE '(' object_id=expression ',' stats_id=expression ')' #STATS_DATE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/type-id-transact-sql?view=sql-server-ver16 + | TYPE_ID '(' type_name=expression ')' #TYPE_ID + // https://docs.microsoft.com/en-us/sql/t-sql/functions/type-name-transact-sql?view=sql-server-ver16 + | TYPE_NAME '(' type_id=expression ')' #TYPE_NAME + // https://docs.microsoft.com/en-us/sql/t-sql/functions/typeproperty-transact-sql?view=sql-server-ver16 + | TYPEPROPERTY '(' type=expression ',' property=expression ')' #TYPEPROPERTY + // String functions + // https://docs.microsoft.com/en-us/sql/t-sql/functions/ascii-transact-sql?view=sql-server-ver16 + | ASCII '(' character_expression=expression ')' #ASCII + // https://docs.microsoft.com/en-us/sql/t-sql/functions/char-transact-sql?view=sql-server-ver16 + | CHAR '(' integer_expression=expression ')' #CHAR + // https://docs.microsoft.com/en-us/sql/t-sql/functions/charindex-transact-sql?view=sql-server-ver16 + | CHARINDEX '(' expressionToFind=expression ',' expressionToSearch=expression ( ',' start_location=expression )? ')' #CHARINDEX + // https://docs.microsoft.com/en-us/sql/t-sql/functions/concat-transact-sql?view=sql-server-ver16 + | CONCAT '(' string_value_1=expression ',' string_value_2=expression ( ',' string_value_n+=expression )* ')' #CONCAT + // https://docs.microsoft.com/en-us/sql/t-sql/functions/concat-ws-transact-sql?view=sql-server-ver16 + | CONCAT_WS '(' separator=expression ',' argument_1=expression ',' argument_2=expression ( ',' argument_n+=expression )* ')' #CONCAT_WS + // https://docs.microsoft.com/en-us/sql/t-sql/functions/difference-transact-sql?view=sql-server-ver16 + | DIFFERENCE '(' character_expression_1=expression ',' character_expression_2=expression ')' #DIFFERENCE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/format-transact-sql?view=sql-server-ver16 + | FORMAT '(' value=expression ',' format=expression ( ',' culture=expression )? ')' #FORMAT + // https://docs.microsoft.com/en-us/sql/t-sql/functions/left-transact-sql?view=sql-server-ver16 + | LEFT '(' character_expression=expression ',' integer_expression=expression ')' #LEFT + // https://docs.microsoft.com/en-us/sql/t-sql/functions/len-transact-sql?view=sql-server-ver16 + | LEN '(' string_expression=expression ')' #LEN + // https://docs.microsoft.com/en-us/sql/t-sql/functions/lower-transact-sql?view=sql-server-ver16 + | LOWER '(' character_expression=expression ')' #LOWER + // https://docs.microsoft.com/en-us/sql/t-sql/functions/ltrim-transact-sql?view=sql-server-ver16 + | LTRIM '(' character_expression=expression ')' #LTRIM + // https://docs.microsoft.com/en-us/sql/t-sql/functions/nchar-transact-sql?view=sql-server-ver16 + | NCHAR '(' integer_expression=expression ')' #NCHAR + // https://docs.microsoft.com/en-us/sql/t-sql/functions/patindex-transact-sql?view=sql-server-ver16 + | PATINDEX '(' pattern=expression ',' string_expression=expression ')' #PATINDEX + // https://docs.microsoft.com/en-us/sql/t-sql/functions/quotename-transact-sql?view=sql-server-ver16 + | QUOTENAME '(' character_string=expression ( ',' quote_character=expression )? ')' #QUOTENAME + // https://docs.microsoft.com/en-us/sql/t-sql/functions/replace-transact-sql?view=sql-server-ver16 + | REPLACE '(' input=expression ',' replacing=expression ',' with=expression ')' #REPLACE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/replicate-transact-sql?view=sql-server-ver16 + | REPLICATE '(' string_expression=expression ',' integer_expression=expression ')' #REPLICATE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/reverse-transact-sql?view=sql-server-ver16 + | REVERSE '(' string_expression=expression ')' #REVERSE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/right-transact-sql?view=sql-server-ver16 + | RIGHT '(' character_expression=expression ',' integer_expression=expression ')' #RIGHT + // https://docs.microsoft.com/en-us/sql/t-sql/functions/rtrim-transact-sql?view=sql-server-ver16 + | RTRIM '(' character_expression=expression ')' #RTRIM + // https://docs.microsoft.com/en-us/sql/t-sql/functions/soundex-transact-sql?view=sql-server-ver16 + | SOUNDEX '(' character_expression=expression ')' #SOUNDEX + // https://docs.microsoft.com/en-us/sql/t-sql/functions/space-transact-sql?view=sql-server-ver16 + | SPACE_KEYWORD '(' integer_expression=expression ')' #SPACE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/str-transact-sql?view=sql-server-ver16 + | STR '(' float_expression=expression ( ',' length_expression=expression ( ',' decimal=expression )? )? ')' #STR + // https://docs.microsoft.com/en-us/sql/t-sql/functions/string-agg-transact-sql?view=sql-server-ver16 + | STRING_AGG '(' expr=expression ',' separator=expression ')' (WITHIN GROUP '(' order_by_clause ')')? #STRINGAGG + // https://docs.microsoft.com/en-us/sql/t-sql/functions/string-escape-transact-sql?view=sql-server-ver16 + | STRING_ESCAPE '(' text_=expression ',' type_=expression ')' #STRING_ESCAPE + // https://msdn.microsoft.com/fr-fr/library/ms188043.aspx + | STUFF '(' str=expression ',' from=expression ',' to=expression ',' str_with=expression ')' #STUFF + // https://docs.microsoft.com/en-us/sql/t-sql/functions/substring-transact-sql?view=sql-server-ver16 + | SUBSTRING '(' string_expression=expression ',' start_=expression ',' length=expression ')' #SUBSTRING + // https://docs.microsoft.com/en-us/sql/t-sql/functions/translate-transact-sql?view=sql-server-ver16 + | TRANSLATE '(' inputString=expression ',' characters=expression ',' translations=expression ')' #TRANSLATE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/trim-transact-sql?view=sql-server-ver16 + | TRIM '(' ( characters=expression FROM )? string_=expression ')' #TRIM + // https://docs.microsoft.com/en-us/sql/t-sql/functions/unicode-transact-sql?view=sql-server-ver16 + | UNICODE '(' ncharacter_expression=expression ')' #UNICODE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/upper-transact-sql?view=sql-server-ver16 + | UPPER '(' character_expression=expression ')' #UPPER + // System functions + // https://msdn.microsoft.com/en-us/library/ms173784.aspx + | BINARY_CHECKSUM '(' ( star='*' | expression (',' expression)* ) ')' #BINARY_CHECKSUM + // https://msdn.microsoft.com/en-us/library/ms189788.aspx + | CHECKSUM '(' ( star='*' | expression (',' expression)* ) ')' #CHECKSUM + // https://docs.microsoft.com/en-us/sql/t-sql/functions/compress-transact-sql?view=sql-server-ver16 + | COMPRESS '(' expr=expression ')' #COMPRESS + // https://docs.microsoft.com/en-us/sql/t-sql/functions/connectionproperty-transact-sql?view=sql-server-ver16 + | CONNECTIONPROPERTY '(' property=STRING ')' #CONNECTIONPROPERTY + // https://docs.microsoft.com/en-us/sql/t-sql/functions/context-info-transact-sql?view=sql-server-ver16 + | CONTEXT_INFO '(' ')' #CONTEXT_INFO + // https://docs.microsoft.com/en-us/sql/t-sql/functions/current-request-id-transact-sql?view=sql-server-ver16 + | CURRENT_REQUEST_ID '(' ')' #CURRENT_REQUEST_ID + // https://docs.microsoft.com/en-us/sql/t-sql/functions/current-transaction-id-transact-sql?view=sql-server-ver16 + | CURRENT_TRANSACTION_ID '(' ')' #CURRENT_TRANSACTION_ID + // https://docs.microsoft.com/en-us/sql/t-sql/functions/decompress-transact-sql?view=sql-server-ver16 + | DECOMPRESS '(' expr=expression ')' #DECOMPRESS + // https://docs.microsoft.com/en-us/sql/t-sql/functions/error-line-transact-sql?view=sql-server-ver16 + | ERROR_LINE '(' ')' #ERROR_LINE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/error-message-transact-sql?view=sql-server-ver16 + | ERROR_MESSAGE '(' ')' #ERROR_MESSAGE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/error-number-transact-sql?view=sql-server-ver16 + | ERROR_NUMBER '(' ')' #ERROR_NUMBER + // https://docs.microsoft.com/en-us/sql/t-sql/functions/error-procedure-transact-sql?view=sql-server-ver16 + | ERROR_PROCEDURE '(' ')' #ERROR_PROCEDURE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/error-severity-transact-sql?view=sql-server-ver16 + | ERROR_SEVERITY '(' ')' #ERROR_SEVERITY + // https://docs.microsoft.com/en-us/sql/t-sql/functions/error-state-transact-sql?view=sql-server-ver16 + | ERROR_STATE '(' ')' #ERROR_STATE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/formatmessage-transact-sql?view=sql-server-ver16 + | FORMATMESSAGE '(' (msg_number=DECIMAL | msg_string=STRING | msg_variable=LOCAL_ID) ',' expression (',' expression)* ')' #FORMATMESSAGE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/get-filestream-transaction-context-transact-sql?view=sql-server-ver16 + | GET_FILESTREAM_TRANSACTION_CONTEXT '(' ')' #GET_FILESTREAM_TRANSACTION_CONTEXT + // https://docs.microsoft.com/en-us/sql/t-sql/functions/getansinull-transact-sql?view=sql-server-ver16 + | GETANSINULL '(' (database=STRING)? ')' #GETANSINULL + // https://docs.microsoft.com/en-us/sql/t-sql/functions/host-id-transact-sql?view=sql-server-ver16 + | HOST_ID '(' ')' #HOST_ID + // https://docs.microsoft.com/en-us/sql/t-sql/functions/host-name-transact-sql?view=sql-server-ver16 + | HOST_NAME '(' ')' #HOST_NAME + // https://msdn.microsoft.com/en-us/library/ms184325.aspx + | ISNULL '(' left=expression ',' right=expression ')' #ISNULL + // https://docs.microsoft.com/en-us/sql/t-sql/functions/isnumeric-transact-sql?view=sql-server-ver16 + | ISNUMERIC '(' expression ')' #ISNUMERIC + // https://docs.microsoft.com/en-us/sql/t-sql/functions/min-active-rowversion-transact-sql?view=sql-server-ver16 + | MIN_ACTIVE_ROWVERSION '(' ')' #MIN_ACTIVE_ROWVERSION + // https://docs.microsoft.com/en-us/sql/t-sql/functions/newid-transact-sql?view=sql-server-ver16 + | NEWID '(' ')' #NEWID + // https://docs.microsoft.com/en-us/sql/t-sql/functions/newsequentialid-transact-sql?view=sql-server-ver16 + | NEWSEQUENTIALID '(' ')' #NEWSEQUENTIALID + // https://docs.microsoft.com/en-us/sql/t-sql/functions/rowcount-big-transact-sql?view=sql-server-ver16 + | ROWCOUNT_BIG '(' ')' #ROWCOUNT_BIG + // https://docs.microsoft.com/en-us/sql/t-sql/functions/session-context-transact-sql?view=sql-server-ver16 + | SESSION_CONTEXT '(' key=STRING ')' #SESSION_CONTEXT + // https://docs.microsoft.com/en-us/sql/t-sql/functions/xact-state-transact-sql?view=sql-server-ver16 + | XACT_STATE '(' ')' #XACT_STATE + // https://msdn.microsoft.com/en-us/library/hh231076.aspx + // https://msdn.microsoft.com/en-us/library/ms187928.aspx + | CAST '(' expression AS data_type ')' #CAST + | TRY_CAST '(' expression AS data_type ')' #TRY_CAST + | CONVERT '(' convert_data_type=data_type ','convert_expression=expression (',' style=expression)? ')' #CONVERT + // https://msdn.microsoft.com/en-us/library/ms190349.aspx + | COALESCE '(' expression_list_ ')' #COALESCE + // Cursor functions + // https://learn.microsoft.com/en-us/sql/t-sql/functions/cursor-rows-transact-sql?view=sql-server-ver16 + | CURSOR_ROWS #CURSOR_ROWS + // https://learn.microsoft.com/en-us/sql/t-sql/functions/cursor-rows-transact-sql?view=sql-server-ver16 + | FETCH_STATUS #FETCH_STATUS + // https://learn.microsoft.com/en-us/sql/t-sql/functions/cursor-status-transact-sql?view=sql-server-ver16 + | CURSOR_STATUS '(' scope=STRING ',' cursor=expression ')' #CURSOR_STATUS + // Cryptographic functions + // https://learn.microsoft.com/en-us/sql/t-sql/functions/cert-id-transact-sql?view=sql-server-ver16 + | CERT_ID '(' cert_name=expression ')' #CERT_ID + // Data type functions + // https://learn.microsoft.com/en-us/sql/t-sql/functions/datalength-transact-sql?view=sql-server-ver16 + | DATALENGTH '(' expression ')' #DATALENGTH + // https://learn.microsoft.com/en-us/sql/t-sql/functions/ident-current-transact-sql?view=sql-server-ver16 + | IDENT_CURRENT '(' table_or_view=expression ')' # IDENT_CURRENT + // https://learn.microsoft.com/en-us/sql/t-sql/functions/ident-incr-transact-sql?view=sql-server-ver16 + | IDENT_INCR '(' table_or_view=expression ')' # IDENT_INCR + // https://learn.microsoft.com/en-us/sql/t-sql/functions/ident-seed-transact-sql?view=sql-server-ver16 + | IDENT_SEED '(' table_or_view=expression ')' # IDENT_SEED + // https://learn.microsoft.com/en-us/sql/t-sql/functions/ident-seed-transact-sql?view=sql-server-ver16 + | IDENTITY '(' datatype=data_type (',' seed=DECIMAL ',' increment=DECIMAL)? ')' #IDENTITY + // https://learn.microsoft.com/en-us/sql/t-sql/functions/ident-seed-transact-sql?view=sql-server-ver16 + | SQL_VARIANT_PROPERTY '(' expr=expression ',' property=STRING ')' #SQL_VARIANT_PROPERTY + // Date functions + //https://infocenter.sybase.com/help/index.jsp?topic=/com.sybase.infocenter.dc36271.1572/html/blocks/CJADIDHD.htm + | CURRENT_DATE '(' ')' #CURRENT_DATE + // https://msdn.microsoft.com/en-us/library/ms188751.aspx + | CURRENT_TIMESTAMP #CURRENT_TIMESTAMP + // https://learn.microsoft.com/en-us/sql/t-sql/functions/current-timezone-transact-sql?view=sql-server-ver16 + | CURRENT_TIMEZONE '(' ')' #CURRENT_TIMEZONE + // https://learn.microsoft.com/en-us/sql/t-sql/functions/current-timezone-id-transact-sql?view=sql-server-ver16 + | CURRENT_TIMEZONE_ID '(' ')' #CURRENT_TIMEZONE_ID + // https://learn.microsoft.com/en-us/sql/t-sql/functions/date-bucket-transact-sql?view=sql-server-ver16 + | DATE_BUCKET '(' datepart=dateparts_9 ',' number=expression ',' date=expression (',' origin=expression)? ')' #DATE_BUCKET + // https://msdn.microsoft.com/en-us/library/ms186819.aspx + | DATEADD '(' datepart=dateparts_12 ',' number=expression ',' date=expression ')' #DATEADD + // https://msdn.microsoft.com/en-us/library/ms189794.aspx + | DATEDIFF '(' datepart=dateparts_12 ',' date_first=expression ',' date_second=expression ')' #DATEDIFF + // https://learn.microsoft.com/en-us/sql/t-sql/functions/datediff-big-transact-sql?view=sql-server-ver16 + | DATEDIFF_BIG '(' datepart=dateparts_12 ',' startdate=expression ',' enddate=expression ')' #DATEDIFF_BIG + // https://learn.microsoft.com/en-us/sql/t-sql/functions/datefromparts-transact-sql?view=sql-server-ver16 + | DATEFROMPARTS '(' year=expression ',' month=expression ',' day=expression ')'#DATEFROMPARTS + // https://msdn.microsoft.com/en-us/library/ms174395.aspx + | DATENAME '(' datepart=dateparts_15 ',' date=expression ')' #DATENAME + // https://msdn.microsoft.com/en-us/library/ms174420.aspx + | DATEPART '(' datepart=dateparts_15 ',' date=expression ')' #DATEPART + // https://learn.microsoft.com/en-us/sql/t-sql/functions/datetime2fromparts-transact-sql?view=sql-server-ver16 + | DATETIME2FROMPARTS '(' year=expression ',' month=expression ',' day=expression ',' hour=expression ',' minute=expression ',' seconds=expression ',' fractions=expression ',' precision=expression ')' #DATETIME2FROMPARTS + // https://learn.microsoft.com/en-us/sql/t-sql/functions/datetimefromparts-transact-sql?view=sql-server-ver16 + | DATETIMEFROMPARTS '(' year=expression ',' month=expression ',' day=expression ',' hour=expression ',' minute=expression ',' seconds=expression ',' milliseconds=expression ')' #DATETIMEFROMPARTS + // https://learn.microsoft.com/en-us/sql/t-sql/functions/datetimeoffsetfromparts-transact-sql?view=sql-server-ver16 + | DATETIMEOFFSETFROMPARTS '(' year=expression ',' month=expression ',' day=expression ',' hour=expression ',' minute=expression ',' seconds=expression ',' fractions=expression ',' hour_offset=expression ',' minute_offset=expression ',' precision=DECIMAL ')' #DATETIMEOFFSETFROMPARTS + // https://learn.microsoft.com/en-us/sql/t-sql/functions/datetrunc-transact-sql?view=sql-server-ver16 + | DATETRUNC '(' datepart=dateparts_datetrunc ',' date=expression ')' #DATETRUNC + // https://learn.microsoft.com/en-us/sql/t-sql/functions/day-transact-sql?view=sql-server-ver16 + | DAY '(' date=expression ')' #DAY + // https://learn.microsoft.com/en-us/sql/t-sql/functions/eomonth-transact-sql?view=sql-server-ver16 + | EOMONTH '(' start_date=expression (',' month_to_add=expression)? ')'#EOMONTH + // https://docs.microsoft.com/en-us/sql/t-sql/functions/getdate-transact-sql + | GETDATE '(' ')' #GETDATE + // https://docs.microsoft.com/en-us/sql/t-sql/functions/getdate-transact-sql + | GETUTCDATE '(' ')' #GETUTCDATE + // https://learn.microsoft.com/en-us/sql/t-sql/functions/isdate-transact-sql?view=sql-server-ver16 + | ISDATE '(' expression ')' #ISDATE + // https://learn.microsoft.com/en-us/sql/t-sql/functions/month-transact-sql?view=sql-server-ver16 + | MONTH '(' date=expression ')' #MONTH + // https://learn.microsoft.com/en-us/sql/t-sql/functions/smalldatetimefromparts-transact-sql?view=sql-server-ver16 + | SMALLDATETIMEFROMPARTS '(' year=expression ',' month=expression ',' day=expression ',' hour=expression ',' minute=expression ')' #SMALLDATETIMEFROMPARTS + // https://learn.microsoft.com/en-us/sql/t-sql/functions/switchoffset-transact-sql?view=sql-server-ver16 + | SWITCHOFFSET '(' datetimeoffset_expression=expression ',' timezoneoffset_expression=expression ')' #SWITCHOFFSET + // https://learn.microsoft.com/en-us/sql/t-sql/functions/sysdatetime-transact-sql?view=sql-server-ver16 + | SYSDATETIME '(' ')' #SYSDATETIME + // https://learn.microsoft.com/en-us/sql/t-sql/functions/sysdatetimeoffset-transact-sql?view=sql-server-ver16 + | SYSDATETIMEOFFSET '(' ')' #SYSDATETIMEOFFSET + // https://learn.microsoft.com/en-us/sql/t-sql/functions/sysutcdatetime-transact-sql?view=sql-server-ver16 + | SYSUTCDATETIME '(' ')' #SYSUTCDATETIME + //https://learn.microsoft.com/en-us/sql/t-sql/functions/timefromparts-transact-sql?view=sql-server-ver16 + | TIMEFROMPARTS '(' hour=expression ',' minute=expression ',' seconds=expression ',' fractions=expression ',' precision=DECIMAL ')' #TIMEFROMPARTS + // https://learn.microsoft.com/en-us/sql/t-sql/functions/todatetimeoffset-transact-sql?view=sql-server-ver16 + | TODATETIMEOFFSET '(' datetime_expression=expression ',' timezoneoffset_expression=expression ')' #TODATETIMEOFFSET + // https://learn.microsoft.com/en-us/sql/t-sql/functions/year-transact-sql?view=sql-server-ver16 + | YEAR '(' date=expression ')' #YEAR + // https://msdn.microsoft.com/en-us/library/ms189838.aspx + | IDENTITY '(' data_type (',' seed=DECIMAL)? (',' increment=DECIMAL)? ')' #IDENTITY + // https://msdn.microsoft.com/en-us/library/bb839514.aspx + | MIN_ACTIVE_ROWVERSION '(' ')' #MIN_ACTIVE_ROWVERSION + // https://msdn.microsoft.com/en-us/library/ms177562.aspx + | NULLIF '(' left=expression ',' right=expression ')' #NULLIF + // https://docs.microsoft.com/en-us/sql/t-sql/functions/parse-transact-sql + // https://docs.microsoft.com/en-us/sql/t-sql/functions/try-parse-transact-sql + | PARSE '(' str=expression AS data_type ( USING culture=expression )? ')' #PARSE + // https://docs.microsoft.com/en-us/sql/t-sql/xml/xml-data-type-methods + | xml_data_type_methods #XML_DATA_TYPE_FUNC + // https://docs.microsoft.com/en-us/sql/t-sql/functions/logical-functions-iif-transact-sql + | IIF '(' cond=search_condition ',' left=expression ',' right=expression ')' #IIF + // JSON functions + // https://learn.microsoft.com/en-us/sql/t-sql/functions/isjson-transact-sql?view=azure-sqldw-latest + | ISJSON '(' json_expr=expression (',' json_type_constraint=expression)? ')' #ISJSON + // https://learn.microsoft.com/en-us/sql/t-sql/functions/json-object-transact-sql?view=azure-sqldw-latest + | JSON_OBJECT '(' (key_value=json_key_value (',' key_value=json_key_value)*)? json_null_clause? ')' #JSON_OBJECT + // https://learn.microsoft.com/en-us/sql/t-sql/functions/json-array-transact-sql?view=azure-sqldw-latest + | JSON_ARRAY '(' expression_list_? json_null_clause? ')' #JSON_ARRAY + // https://learn.microsoft.com/en-us/sql/t-sql/functions/json-value-transact-sql?view=azure-sqldw-latest + | JSON_VALUE '(' expr=expression ',' path=expression ')' #JSON_VALUE + // https://learn.microsoft.com/en-us/sql/t-sql/functions/json-query-transact-sql?view=azure-sqldw-latest + | JSON_QUERY '(' expr=expression (',' path=expression)? ')' #JSON_QUERY + // https://learn.microsoft.com/en-us/sql/t-sql/functions/json-modify-transact-sql?view=azure-sqldw-latest + | JSON_MODIFY '(' expr=expression ',' path=expression ',' new_value=expression ')' #JSON_MODIFY + // https://learn.microsoft.com/en-us/sql/t-sql/functions/json-path-exists-transact-sql?view=azure-sqldw-latest + | JSON_PATH_EXISTS '(' value_expression=expression ',' sql_json_path=expression ')' #JSON_PATH_EXISTS + // Math functions + // https://learn.microsoft.com/en-us/sql/t-sql/functions/abs-transact-sql?view=sql-server-ver16 + | ABS '(' numeric_expression=expression ')' #ABS + // https://learn.microsoft.com/en-us/sql/t-sql/functions/acos-transact-sql?view=sql-server-ver16 + | ACOS '(' float_expression=expression ')' #ACOS + // https://learn.microsoft.com/en-us/sql/t-sql/functions/asin-transact-sql?view=sql-server-ver16 + | ASIN '(' float_expression=expression ')' #ASIN + // https://learn.microsoft.com/en-us/sql/t-sql/functions/atan-transact-sql?view=sql-server-ver16 + | ATAN '(' float_expression=expression ')' #ATAN + // https://learn.microsoft.com/en-us/sql/t-sql/functions/atn2-transact-sql?view=sql-server-ver16 + | ATN2 '(' float_expression=expression ',' float_expression=expression ')' #ATN2 + // https://learn.microsoft.com/en-us/sql/t-sql/functions/ceiling-transact-sql?view=sql-server-ver16 + | CEILING '(' numeric_expression=expression ')' #CEILING + // https://learn.microsoft.com/en-us/sql/t-sql/functions/cos-transact-sql?view=sql-server-ver16 + | COS '(' float_expression=expression ')' #COS + // https://learn.microsoft.com/en-us/sql/t-sql/functions/cot-transact-sql?view=sql-server-ver16 + | COT '(' float_expression=expression ')' #COT + // https://learn.microsoft.com/en-us/sql/t-sql/functions/degrees-transact-sql?view=sql-server-ver16 + | DEGREES '(' numeric_expression=expression ')' #DEGREES + // https://learn.microsoft.com/en-us/sql/t-sql/functions/exp-transact-sql?view=sql-server-ver16 + | EXP '(' float_expression=expression ')' #EXP + // https://learn.microsoft.com/en-us/sql/t-sql/functions/floor-transact-sql?view=sql-server-ver16 + | FLOOR '(' numeric_expression=expression ')' #FLOOR + // https://learn.microsoft.com/en-us/sql/t-sql/functions/log-transact-sql?view=sql-server-ver16 + | LOG '(' float_expression=expression (',' base=expression)? ')' #LOG + // https://learn.microsoft.com/en-us/sql/t-sql/functions/log10-transact-sql?view=sql-server-ver16 + | LOG10 '(' float_expression=expression ')' #LOG10 + // https://learn.microsoft.com/en-us/sql/t-sql/functions/pi-transact-sql?view=sql-server-ver16 + | PI '(' ')' #PI + // https://learn.microsoft.com/en-us/sql/t-sql/functions/power-transact-sql?view=sql-server-ver16 + | POWER '(' float_expression=expression ',' y=expression ')' #POWER + // https://learn.microsoft.com/en-us/sql/t-sql/functions/radians-transact-sql?view=sql-server-ver16 + | RADIANS '(' numeric_expression=expression ')' #RADIANS + // https://learn.microsoft.com/en-us/sql/t-sql/functions/rand-transact-sql?view=sql-server-ver16 + | RAND '(' (seed=expression)? ')' #RAND + // https://learn.microsoft.com/en-us/sql/t-sql/functions/round-transact-sql?view=sql-server-ver16 + | ROUND '(' numeric_expression=expression ',' length=expression (',' function=expression)? ')' #ROUND + // https://learn.microsoft.com/en-us/sql/t-sql/functions/sign-transact-sql?view=sql-server-ver16 + | SIGN '(' numeric_expression=expression ')' #MATH_SIGN + // https://learn.microsoft.com/en-us/sql/t-sql/functions/sin-transact-sql?view=sql-server-ver16 + | SIN '(' float_expression=expression ')' #SIN + // https://learn.microsoft.com/en-us/sql/t-sql/functions/sqrt-transact-sql?view=sql-server-ver16 + | SQRT '(' float_expression=expression ')' #SQRT + // https://learn.microsoft.com/en-us/sql/t-sql/functions/square-transact-sql?view=sql-server-ver16 + | SQUARE '(' float_expression=expression ')' #SQUARE + // https://learn.microsoft.com/en-us/sql/t-sql/functions/tan-transact-sql?view=sql-server-ver16 + | TAN '(' float_expression=expression ')' #TAN + // Logical functions + // https://learn.microsoft.com/en-us/sql/t-sql/functions/logical-functions-greatest-transact-sql?view=azure-sqldw-latest + | GREATEST '(' expression_list_ ')' #GREATEST + // https://learn.microsoft.com/en-us/sql/t-sql/functions/logical-functions-least-transact-sql?view=azure-sqldw-latest + | LEAST '(' expression_list_ ')' #LEAST + // Security functions + // https://learn.microsoft.com/en-us/sql/t-sql/functions/certencoded-transact-sql?view=sql-server-ver16 + | CERTENCODED '(' certid=expression ')' #CERTENCODED + // https://learn.microsoft.com/en-us/sql/t-sql/functions/certprivatekey-transact-sql?view=sql-server-ver16 + | CERTPRIVATEKEY '(' certid=expression ',' encryption_password=expression (',' decryption_pasword=expression)? ')' #CERTPRIVATEKEY + // https://msdn.microsoft.com/en-us/library/ms176050.aspx + | CURRENT_USER #CURRENT_USER + // https://learn.microsoft.com/en-us/sql/t-sql/functions/database-principal-id-transact-sql?view=sql-server-ver16 + | DATABASE_PRINCIPAL_ID '(' (principal_name=expression)? ')' #DATABASE_PRINCIPAL_ID + // https://learn.microsoft.com/en-us/sql/t-sql/functions/has-dbaccess-transact-sql?view=sql-server-ver16 + | HAS_DBACCESS '(' database_name=expression ')' #HAS_DBACCESS + // https://learn.microsoft.com/en-us/sql/t-sql/functions/has-perms-by-name-transact-sql?view=sql-server-ver16 + | HAS_PERMS_BY_NAME '(' securable=expression ',' securable_class=expression ',' permission=expression ( ',' sub_securable=expression (',' sub_securable_class=expression )? )? ')' #HAS_PERMS_BY_NAME + // https://learn.microsoft.com/en-us/sql/t-sql/functions/is-member-transact-sql?view=sql-server-ver16 + | IS_MEMBER '(' group_or_role=expression ')' #IS_MEMBER + // https://learn.microsoft.com/en-us/sql/t-sql/functions/is-rolemember-transact-sql?view=sql-server-ver16 + | IS_ROLEMEMBER '(' role=expression ( ',' database_principal=expression )? ')' #IS_ROLEMEMBER + // https://learn.microsoft.com/en-us/sql/t-sql/functions/is-srvrolemember-transact-sql?view=sql-server-ver16 + | IS_SRVROLEMEMBER '(' role=expression ( ',' login=expression )? ')' #IS_SRVROLEMEMBER + // https://learn.microsoft.com/en-us/sql/t-sql/functions/loginproperty-transact-sql?view=sql-server-ver16 + | LOGINPROPERTY '(' login_name=expression ',' property_name=expression ')' #LOGINPROPERTY + // https://learn.microsoft.com/en-us/sql/t-sql/functions/original-login-transact-sql?view=sql-server-ver16 + | ORIGINAL_LOGIN '(' ')' #ORIGINAL_LOGIN + // https://learn.microsoft.com/en-us/sql/t-sql/functions/permissions-transact-sql?view=sql-server-ver16 + | PERMISSIONS '(' ( object_id=expression (',' column=expression)? )? ')' #PERMISSIONS + // https://learn.microsoft.com/en-us/sql/t-sql/functions/pwdencrypt-transact-sql?view=sql-server-ver16 + | PWDENCRYPT '(' password=expression ')' #PWDENCRYPT + // https://learn.microsoft.com/en-us/sql/t-sql/functions/pwdcompare-transact-sql?view=sql-server-ver16 + | PWDCOMPARE '(' clear_text_password=expression ',' password_hash=expression (',' version=expression )?')' #PWDCOMPARE + // https://msdn.microsoft.com/en-us/library/ms177587.aspx + | SESSION_USER #SESSION_USER + // https://learn.microsoft.com/en-us/sql/t-sql/functions/sessionproperty-transact-sql?view=sql-server-ver16 + | SESSIONPROPERTY '(' option_name=expression ')' #SESSIONPROPERTY + // https://learn.microsoft.com/en-us/sql/t-sql/functions/suser-id-transact-sql?view=sql-server-ver16 + | SUSER_ID '(' (login=expression)? ')' #SUSER_ID + // https://learn.microsoft.com/en-us/sql/t-sql/functions/suser-name-transact-sql?view=sql-server-ver16 + | SUSER_NAME '(' (server_user_sid=expression)? ')' #SUSER_SNAME + // https://learn.microsoft.com/en-us/sql/t-sql/functions/suser-sid-transact-sql?view=sql-server-ver16 + | SUSER_SID '(' (login=expression (',' param2=expression)?)? ')' #SUSER_SID + // https://learn.microsoft.com/en-us/sql/t-sql/functions/suser-sname-transact-sql?view=sql-server-ver16 + | SUSER_SNAME '(' (server_user_sid=expression)? ')' #SUSER_SNAME + // https://msdn.microsoft.com/en-us/library/ms179930.aspx + | SYSTEM_USER #SYSTEM_USER + // https://learn.microsoft.com/en-us/sql/t-sql/functions/user-transact-sql?view=sql-server-ver16 + | USER #USER + // https://learn.microsoft.com/en-us/sql/t-sql/functions/user-id-transact-sql?view=sql-server-ver16 + | USER_ID '(' (user=expression)? ')' #USER_ID + // https://learn.microsoft.com/en-us/sql/t-sql/functions/user-name-transact-sql?view=sql-server-ver16 + | USER_NAME '(' (id=expression)? ')' #USER_NAME + ; + +xml_data_type_methods + : value_method + | query_method + | exist_method + | modify_method + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/functions/date-bucket-transact-sql?view=sql-server-ver16 +dateparts_9 + : YEAR | YEAR_ABBR + | QUARTER | QUARTER_ABBR + | MONTH | MONTH_ABBR + | DAY | DAY_ABBR + | WEEK | WEEK_ABBR + | HOUR | HOUR_ABBR + | MINUTE | MINUTE_ABBR + | SECOND | SECOND_ABBR + | MILLISECOND | MILLISECOND_ABBR + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/functions/dateadd-transact-sql?view=sql-server-ver16 +dateparts_12 + : dateparts_9 + | DAYOFYEAR | DAYOFYEAR_ABBR + | MICROSECOND | MICROSECOND_ABBR + | NANOSECOND | NANOSECOND_ABBR + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/functions/datename-transact-sql?view=sql-server-ver16 +dateparts_15 + : dateparts_12 + | WEEKDAY | WEEKDAY_ABBR + | TZOFFSET | TZOFFSET_ABBR + | ISO_WEEK | ISO_WEEK_ABBR + ; + +// https://learn.microsoft.com/en-us/sql/t-sql/functions/datetrunc-transact-sql?view=sql-server-ver16 +dateparts_datetrunc + : dateparts_9 + | DAYOFYEAR | DAYOFYEAR_ABBR + | MICROSECOND | MICROSECOND_ABBR + | ISO_WEEK | ISO_WEEK_ABBR + ; + +value_method + : (loc_id=LOCAL_ID | value_id=full_column_name | eventdata=EVENTDATA '(' ')' | query=query_method | '(' subquery ')') '.' call=value_call + ; + +value_call + : (VALUE | VALUE_SQUARE_BRACKET) '(' xquery=STRING ',' sqltype=STRING ')' + ; + +query_method + : (loc_id=LOCAL_ID | value_id=full_column_name | '(' subquery ')' ) '.' call=query_call + ; + +query_call + : (QUERY | QUERY_SQUARE_BRACKET) '(' xquery=STRING ')' + ; + +exist_method + : (loc_id=LOCAL_ID | value_id=full_column_name | '(' subquery ')') '.' call=exist_call + ; + +exist_call + : (EXIST | EXIST_SQUARE_BRACKET) '(' xquery=STRING ')' + ; + +modify_method + : (loc_id=LOCAL_ID | value_id=full_column_name | '(' subquery ')') '.' call=modify_call + ; + +modify_call + : (MODIFY | MODIFY_SQUARE_BRACKET) '(' xml_dml=STRING ')' + ; + +hierarchyid_call + : GETANCESTOR '(' n=expression ')' + | GETDESCENDANT '(' child1=expression ',' child2=expression ')' + | GETLEVEL '(' ')' + | ISDESCENDANTOF '(' parent_=expression ')' + | GETREPARENTEDVALUE '(' oldroot=expression ',' newroot=expression ')' + | TOSTRING '(' ')' + ; + +hierarchyid_static_method + : HIERARCHYID DOUBLE_COLON (GETROOT '(' ')' | PARSE '(' input=expression ')') + ; + +nodes_method + : (loc_id=LOCAL_ID | value_id=full_column_name | '(' subquery ')') '.' NODES '(' xquery=STRING ')' + ; + + +switch_section + : WHEN expression THEN expression + ; + +switch_search_condition_section + : WHEN search_condition THEN expression + ; + +as_column_alias + : AS? column_alias + ; + +as_table_alias + : AS? table_alias + ; + +table_alias + : id_ + ; + +// https://msdn.microsoft.com/en-us/library/ms187373.aspx +with_table_hints + : WITH '(' hint+=table_hint (','? hint+=table_hint)* ')' + ; + +deprecated_table_hint + : '(' table_hint ')' + ; + +// https://infocenter-archive.sybase.com/help/index.jsp?topic=/com.sybase.infocenter.dc00938.1502/html/locking/locking103.htm +// https://infocenter-archive.sybase.com/help/index.jsp?topic=/com.sybase.dc32300_1250/html/sqlug/sqlug792.htm +// https://infocenter-archive.sybase.com/help/index.jsp?topic=/com.sybase.dc36271_36272_36273_36274_1250/html/refman/X35229.htm +// Legacy hint with no parenthesis and no WITH keyword. Actually conflicts with table alias name except for holdlock which is +// a reserved keyword in this grammar. We might want a separate sybase grammar variant. +sybase_legacy_hints + : sybase_legacy_hint+ + ; + +sybase_legacy_hint + : HOLDLOCK + | NOHOLDLOCK + | READPAST + | SHARED + ; + +// For simplicity, we don't build subsets for INSERT/UPDATE/DELETE/SELECT/MERGE +// which means the grammar accept slightly more than the what the specification (documentation) says. +table_hint + : NOEXPAND + | INDEX ( + '(' index_value (',' index_value)* ')' + | '=' '(' index_value ')' + | '=' index_value // examples in the doc include this syntax + ) + | FORCESEEK ( '(' index_value '(' column_name_list ')' ')' )? + | FORCESCAN + | HOLDLOCK + | NOLOCK + | NOWAIT + | PAGLOCK + | READCOMMITTED + | READCOMMITTEDLOCK + | READPAST + | READUNCOMMITTED + | REPEATABLEREAD + | ROWLOCK + | SERIALIZABLE + | SNAPSHOT + | SPATIAL_WINDOW_MAX_CELLS '=' DECIMAL + | TABLOCK + | TABLOCKX + | UPDLOCK + | XLOCK + | KEEPIDENTITY + | KEEPDEFAULTS + | IGNORE_CONSTRAINTS + | IGNORE_TRIGGERS + ; + +index_value + : id_ | DECIMAL + ; + +column_alias_list + : '(' alias+=column_alias (',' alias+=column_alias)* ')' + ; + +column_alias + : id_ + | STRING + ; + +table_value_constructor + : VALUES '(' exps+=expression_list_ ')' (',' '(' exps+=expression_list_ ')')* + ; + +expression_list_ + : exp+=expression (',' exp+=expression)* + ; + +// https://msdn.microsoft.com/en-us/library/ms189798.aspx +ranking_windowed_function + : (RANK | DENSE_RANK | ROW_NUMBER) '(' ')' over_clause + | NTILE '(' expression ')' over_clause + ; + +// https://msdn.microsoft.com/en-us/library/ms173454.aspx +aggregate_windowed_function + : agg_func=(AVG | MAX | MIN | SUM | STDEV | STDEVP | VAR | VARP) + '(' all_distinct_expression ')' over_clause? + | cnt=(COUNT | COUNT_BIG) + '(' ('*' | all_distinct_expression) ')' over_clause? + | CHECKSUM_AGG '(' all_distinct_expression ')' + | GROUPING '(' expression ')' + | GROUPING_ID '(' expression_list_ ')' + ; + +// https://docs.microsoft.com/en-us/sql/t-sql/functions/analytic-functions-transact-sql +analytic_windowed_function + : (FIRST_VALUE | LAST_VALUE) '(' expression ')' over_clause + | (LAG | LEAD) '(' expression (',' expression (',' expression)? )? ')' over_clause + | (CUME_DIST | PERCENT_RANK) '(' ')' OVER '(' (PARTITION BY expression_list_)? order_by_clause ')' + | (PERCENTILE_CONT | PERCENTILE_DISC) '(' expression ')' WITHIN GROUP '(' order_by_clause ')' OVER '(' (PARTITION BY expression_list_)? ')' + ; + +all_distinct_expression + : (ALL | DISTINCT)? expression + ; + +// https://msdn.microsoft.com/en-us/library/ms189461.aspx +over_clause + : OVER '(' (PARTITION BY expression_list_)? order_by_clause? row_or_range_clause? ')' + ; + +row_or_range_clause + : (ROWS | RANGE) window_frame_extent + ; + +window_frame_extent + : window_frame_preceding + | BETWEEN window_frame_bound AND window_frame_bound + ; + +window_frame_bound + : window_frame_preceding + | window_frame_following + ; + +window_frame_preceding + : UNBOUNDED PRECEDING + | DECIMAL PRECEDING + | CURRENT ROW + ; + +window_frame_following + : UNBOUNDED FOLLOWING + | DECIMAL FOLLOWING + ; + +create_database_option + : FILESTREAM ( database_filestream_option (',' database_filestream_option)* ) + | DEFAULT_LANGUAGE EQUAL ( id_ | STRING ) + | DEFAULT_FULLTEXT_LANGUAGE EQUAL ( id_ | STRING ) + | NESTED_TRIGGERS EQUAL ( OFF | ON ) + | TRANSFORM_NOISE_WORDS EQUAL ( OFF | ON ) + | TWO_DIGIT_YEAR_CUTOFF EQUAL DECIMAL + | DB_CHAINING ( OFF | ON ) + | TRUSTWORTHY ( OFF | ON ) + ; + +database_filestream_option + : LR_BRACKET + ( + ( NON_TRANSACTED_ACCESS EQUAL ( OFF | READ_ONLY | FULL ) ) + | + ( DIRECTORY_NAME EQUAL STRING ) + ) + RR_BRACKET + ; + +database_file_spec + : file_group | file_spec + ; + +file_group + : FILEGROUP id_ + ( CONTAINS FILESTREAM )? + ( DEFAULT )? + ( CONTAINS MEMORY_OPTIMIZED_DATA )? + file_spec ( ',' file_spec )* + ; +file_spec + : LR_BRACKET + NAME EQUAL ( id_ | STRING ) ','? + FILENAME EQUAL file = STRING ','? + ( SIZE EQUAL file_size ','? )? + ( MAXSIZE EQUAL (file_size | UNLIMITED )','? )? + ( FILEGROWTH EQUAL file_size ','? )? + RR_BRACKET + ; + + +// Primitive. +entity_name + : (server=id_ '.' database=id_ '.' schema=id_ '.' + | database=id_ '.' (schema=id_)? '.' + | schema=id_ '.')? table=id_ + ; + + +entity_name_for_azure_dw + : schema=id_ + | schema=id_ '.' object_name=id_ + ; + +entity_name_for_parallel_dw + : schema_database=id_ + | schema=id_ '.' object_name=id_ + ; + +//full_table_name +// : (linkedServer=id_ '.' '.' schema=id_ '.' +// | server=id_ '.' database=id_ '.' schema=id_ '.' +// | database=id_ '.' schema=id_? '.' +// | schema=id_ '.')? table=id_ +// ; +// Rewrite full_table_name to avoid leading optional values. +full_table_name + : id_ ( + dotID+ + | doubleDotID dotID? + )? + ; + +dotID + : '.' id_; + +doubleDotID + : '.' '.' id_; + +table_name + : (database=id_ '.' schema=id_? '.' | schema=id_ '.')? (table=id_ | blocking_hierarchy=BLOCKING_HIERARCHY) + ; + +simple_name + : (schema=id_ '.')? name=id_ + ; + +func_proc_name_schema + : ((schema=id_) '.')? procedure=id_ + ; + +func_proc_name_database_schema + : database=id_? '.' schema=id_? '.' procedure=id_ + | func_proc_name_schema + ; + +func_proc_name_server_database_schema + : server=id_? '.' database=id_? '.' schema=id_? '.' procedure=id_ + | func_proc_name_database_schema + ; + +ddl_object + : full_table_name + | LOCAL_ID + ; + +full_column_name + : (DELETED | INSERTED) (column_name=id_ | ('$' (IDENTITY | ROWGUID))) + | full_table_name '.' (column_name=id_ | ('$' (IDENTITY | ROWGUID))) + | (column_name=id_ | ('$' (IDENTITY | ROWGUID))) + ; + +column_name_list_with_order + : column_name_with_order (',' column_name_with_order)* + ; + +column_name_with_order + : id_ (ASC | DESC)? + ; + +//For some reason, sql server allows any number of prefixes: Here, h is the column: a.b.c.d.e.f.g.h +insert_column_name_list + : col+=insert_column_id (',' col+=insert_column_id)* + ; + +insert_column_id + : (ignore+=id_? '.' )* id_ + ; + +column_name_list + : col+=id_ (',' col+=id_)* + ; + +cursor_name + : id_ + | LOCAL_ID + ; + +on_off + : ON + | OFF + ; + +clustered + : CLUSTERED + | NONCLUSTERED + ; + +null_notnull + : NOT? NULL_ + ; + +scalar_function_name + : func_proc_name_server_database_schema + | RIGHT + | LEFT + | BINARY_CHECKSUM + | CHECKSUM + ; + +begin_conversation_timer + : BEGIN CONVERSATION TIMER '(' LOCAL_ID ')' TIMEOUT '=' time ';'? + ; + +begin_conversation_dialog + : BEGIN DIALOG (CONVERSATION)? dialog_handle=LOCAL_ID + FROM SERVICE initiator_service_name=service_name + TO SERVICE target_service_name=service_name (',' service_broker_guid=STRING)? + ON CONTRACT contract_name + (WITH + ((RELATED_CONVERSATION | RELATED_CONVERSATION_GROUP) '=' LOCAL_ID ','?)? + (LIFETIME '=' (DECIMAL | LOCAL_ID) ','?)? + (ENCRYPTION '=' on_off)? )? + ';'? + ; + +contract_name + : (id_ | expression) + ; + +service_name + : (id_ | expression) + ; + +end_conversation + : END CONVERSATION conversation_handle=LOCAL_ID ';'? + (WITH (ERROR '=' faliure_code=(LOCAL_ID | STRING) DESCRIPTION '=' failure_text=(LOCAL_ID | STRING))? CLEANUP? )? + ; + +waitfor_conversation + : WAITFOR? '(' get_conversation ')' (','? TIMEOUT timeout=time)? ';'? + ; + +get_conversation + :GET CONVERSATION GROUP conversation_group_id=(STRING | LOCAL_ID) FROM queue=queue_id ';'? + ; + +queue_id + : (database_name=id_ '.' schema_name=id_ '.' name=id_) + | id_ + ; + +send_conversation + : SEND ON CONVERSATION conversation_handle=(STRING | LOCAL_ID) + MESSAGE TYPE message_type_name=expression + ('(' message_body_expression=(STRING | LOCAL_ID) ')' )? + ';'? + ; + +// https://msdn.microsoft.com/en-us/library/ms187752.aspx +// TODO: implement runtime check or add new tokens. + +data_type + : scaled=(VARCHAR | NVARCHAR | BINARY_KEYWORD | VARBINARY_KEYWORD | SQUARE_BRACKET_ID) '(' MAX ')' + | ext_type=id_ '(' scale=DECIMAL ',' prec=DECIMAL ')' + | ext_type=id_ '(' scale=DECIMAL ')' + | ext_type=id_ IDENTITY ('(' seed=DECIMAL ',' inc=DECIMAL ')')? + | double_prec=DOUBLE PRECISION? + | spatial_type=(GEOMETRY | GEOGRAPHY) + | unscaled_type=id_ + ; + +// https://msdn.microsoft.com/en-us/library/ms179899.aspx +constant + : STRING // string, datetime or uniqueidentifier + | BINARY + | '-'? (DECIMAL | REAL | FLOAT) // float or decimal + | '-'? dollar='$' ('-'|'+')? (DECIMAL | FLOAT) // money + | parameter + ; + +// To reduce ambiguity, -X is considered as an application of unary operator +primitive_constant + : STRING // string, datetime or uniqueidentifier + | BINARY + | (DECIMAL | REAL | FLOAT) // float or decimal + | dollar='$' ('-'|'+')? (DECIMAL | FLOAT) // money + | parameter + ; + +keyword + : ABORT + | ABSOLUTE + | ACCENT_SENSITIVITY + | ACCESS + | ACTION + | ACTIVATION + | ACTIVE + | ADD // ? + | ADDRESS + | AES_128 + | AES_192 + | AES_256 + | AFFINITY + | AFTER + | AGGREGATE + | ALGORITHM + | ALL_CONSTRAINTS + | ALL_ERRORMSGS + | ALL_INDEXES + | ALL_LEVELS + | ALLOW_ENCRYPTED_VALUE_MODIFICATIONS + | ALLOW_PAGE_LOCKS + | ALLOW_ROW_LOCKS + | ALLOW_SNAPSHOT_ISOLATION + | ALLOWED + | ALWAYS + | ANSI_DEFAULTS + | ANSI_NULL_DEFAULT + | ANSI_NULL_DFLT_OFF + | ANSI_NULL_DFLT_ON + | ANSI_NULLS + | ANSI_PADDING + | ANSI_WARNINGS + | APP_NAME + | APPLICATION_LOG + | APPLOCK_MODE + | APPLOCK_TEST + | APPLY + | ARITHABORT + | ARITHIGNORE + | ASCII + | ASSEMBLY + | ASSEMBLYPROPERTY + | AT_KEYWORD + | AUDIT + | AUDIT_GUID + | AUTO + | AUTO_CLEANUP + | AUTO_CLOSE + | AUTO_CREATE_STATISTICS + | AUTO_DROP + | AUTO_SHRINK + | AUTO_UPDATE_STATISTICS + | AUTO_UPDATE_STATISTICS_ASYNC + | AUTOGROW_ALL_FILES + | AUTOGROW_SINGLE_FILE + | AVAILABILITY + | AVG + | BACKUP_CLONEDB + | BACKUP_PRIORITY + | BASE64 + | BEGIN_DIALOG + | BIGINT + | BINARY_KEYWORD + | BINARY_CHECKSUM + | BINDING + | BLOB_STORAGE + | BROKER + | BROKER_INSTANCE + | BULK_LOGGED + | CALLER + | CAP_CPU_PERCENT + | CAST + | TRY_CAST + | CATALOG + | CATCH + | CERT_ID + | CERTENCODED + | CERTPRIVATEKEY + | CHANGE + | CHANGE_RETENTION + | CHANGE_TRACKING + | CHAR + | CHARINDEX + | CHECKALLOC + | CHECKCATALOG + | CHECKCONSTRAINTS + | CHECKDB + | CHECKFILEGROUP + | CHECKSUM + | CHECKSUM_AGG + | CHECKTABLE + | CLEANTABLE + | CLEANUP + | CLONEDATABASE + | COL_LENGTH + | COL_NAME + | COLLECTION + | COLUMN_ENCRYPTION_KEY + | COLUMN_MASTER_KEY + | COLUMNPROPERTY + | COLUMNS + | COLUMNSTORE + | COLUMNSTORE_ARCHIVE + | COMMITTED + | COMPATIBILITY_LEVEL + | COMPRESS_ALL_ROW_GROUPS + | COMPRESSION_DELAY + | CONCAT + | CONCAT_WS + | CONCAT_NULL_YIELDS_NULL + | CONTENT + | CONTROL + | COOKIE + | COUNT + | COUNT_BIG + | COUNTER + | CPU + | CREATE_NEW + | CREATION_DISPOSITION + | CREDENTIAL + | CRYPTOGRAPHIC + | CUME_DIST + | CURSOR_CLOSE_ON_COMMIT + | CURSOR_DEFAULT + | CURSOR_STATUS + | DATA + | DATA_PURITY + | DATABASE_PRINCIPAL_ID + | DATABASEPROPERTYEX + | DATALENGTH + | DATE_CORRELATION_OPTIMIZATION + | DATEADD + | DATEDIFF + | DATENAME + | DATEPART + | DAYS + | DB_CHAINING + | DB_FAILOVER + | DB_ID + | DB_NAME + | DBCC + | DBREINDEX + | DECRYPTION + | DEFAULT_DOUBLE_QUOTE + | DEFAULT_FULLTEXT_LANGUAGE + | DEFAULT_LANGUAGE + | DEFINITION + | DELAY + | DELAYED_DURABILITY + | DELETED + | DENSE_RANK + | DEPENDENTS + | DES + | DESCRIPTION + | DESX + | DETERMINISTIC + | DHCP + | DIALOG + | DIFFERENCE + | DIRECTORY_NAME + | DISABLE + | DISABLE_BROKER + | DISABLED + | DOCUMENT + | DROP_EXISTING + | DROPCLEANBUFFERS + | DYNAMIC + | ELEMENTS + | EMERGENCY + | EMPTY + | ENABLE + | ENABLE_BROKER + | ENCRYPTED + | ENCRYPTED_VALUE + | ENCRYPTION + | ENCRYPTION_TYPE + | ENDPOINT_URL + | ERROR_BROKER_CONVERSATIONS + | ESTIMATEONLY + | EXCLUSIVE + | EXECUTABLE + | EXIST + | EXIST_SQUARE_BRACKET + | EXPAND + | EXPIRY_DATE + | EXPLICIT + | EXTENDED_LOGICAL_CHECKS + | FAIL_OPERATION + | FAILOVER_MODE + | FAILURE + | FAILURE_CONDITION_LEVEL + | FAST + | FAST_FORWARD + | FILE_ID + | FILE_IDEX + | FILE_NAME + | FILEGROUP + | FILEGROUP_ID + | FILEGROUP_NAME + | FILEGROUPPROPERTY + | FILEGROWTH + | FILENAME + | FILEPATH + | FILEPROPERTY + | FILEPROPERTYEX + | FILESTREAM + | FILTER + | FIRST + | FIRST_VALUE + | FMTONLY + | FOLLOWING + | FORCE + | FORCE_FAILOVER_ALLOW_DATA_LOSS + | FORCED + | FORCEPLAN + | FORCESCAN + | FORMAT + | FORWARD_ONLY + | FREE + | FULLSCAN + | FULLTEXT + | FULLTEXTCATALOGPROPERTY + | FULLTEXTSERVICEPROPERTY + | GB + | GENERATED + | GETDATE + | GETUTCDATE + | GLOBAL + | GO + | GREATEST + | GROUP_MAX_REQUESTS + | GROUPING + | GROUPING_ID + | HADR + | HAS_DBACCESS + | HAS_PERMS_BY_NAME + | HASH + | HEALTH_CHECK_TIMEOUT + | HIDDEN_KEYWORD + | HIGH + | HONOR_BROKER_PRIORITY + | HOURS + | IDENT_CURRENT + | IDENT_INCR + | IDENT_SEED + | IDENTITY_VALUE + | IGNORE_CONSTRAINTS + | IGNORE_DUP_KEY + | IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX + | IGNORE_REPLICATED_TABLE_CACHE + | IGNORE_TRIGGERS + | IMMEDIATE + | IMPERSONATE + | IMPLICIT_TRANSACTIONS + | IMPORTANCE + | INCLUDE_NULL_VALUES + | INCREMENTAL + | INDEX_COL + | INDEXKEY_PROPERTY + | INDEXPROPERTY + | INITIATOR + | INPUT + | INSENSITIVE + | INSERTED + | INT + | IP + | IS_MEMBER + | IS_ROLEMEMBER + | IS_SRVROLEMEMBER + | ISJSON + | ISOLATION + | JOB + | JSON + | JSON_OBJECT + | JSON_ARRAY + | JSON_VALUE + | JSON_QUERY + | JSON_MODIFY + | JSON_PATH_EXISTS + | KB + | KEEP + | KEEPDEFAULTS + | KEEPFIXED + | KEEPIDENTITY + | KEY_SOURCE + | KEYS + | KEYSET + | LAG + | LAST + | LAST_VALUE + | LEAD + | LEAST + | LEN + | LEVEL + | LIST + | LISTENER + | LISTENER_URL + | LOB_COMPACTION + | LOCAL + | LOCATION + | LOCK + | LOCK_ESCALATION + | LOGIN + | LOGINPROPERTY + | LOOP + | LOW + | LOWER + | LTRIM + | MANUAL + | MARK + | MASKED + | MATERIALIZED + | MAX + | MAX_CPU_PERCENT + | MAX_DOP + | MAX_FILES + | MAX_IOPS_PER_VOLUME + | MAX_MEMORY_PERCENT + | MAX_PROCESSES + | MAX_QUEUE_READERS + | MAX_ROLLOVER_FILES + | MAXDOP + | MAXRECURSION + | MAXSIZE + | MB + | MEDIUM + | MEMORY_OPTIMIZED_DATA + | MESSAGE + | MIN + | MIN_ACTIVE_ROWVERSION + | MIN_CPU_PERCENT + | MIN_IOPS_PER_VOLUME + | MIN_MEMORY_PERCENT + | MINUTES + | MIRROR_ADDRESS + | MIXED_PAGE_ALLOCATION + | MODE + | MODIFY + | MODIFY_SQUARE_BRACKET + | MOVE + | MULTI_USER + | NAME + | NCHAR + | NESTED_TRIGGERS + | NEW_ACCOUNT + | NEW_BROKER + | NEW_PASSWORD + | NEWNAME + | NEXT + | NO + | NO_INFOMSGS + | NO_QUERYSTORE + | NO_STATISTICS + | NO_TRUNCATE + | NO_WAIT + | NOCOUNT + | NODES + | NOEXEC + | NOEXPAND + | NOINDEX + | NOLOCK + | NON_TRANSACTED_ACCESS + | NORECOMPUTE + | NORECOVERY + | NOTIFICATIONS + | NOWAIT + | NTILE + | NULL_DOUBLE_QUOTE + | NUMANODE + | NUMBER + | NUMERIC_ROUNDABORT + | OBJECT + | OBJECT_DEFINITION + | OBJECT_ID + | OBJECT_NAME + | OBJECT_SCHEMA_NAME + | OBJECTPROPERTY + | OBJECTPROPERTYEX + | OFFLINE + | OFFSET + | OLD_ACCOUNT + | ONLINE + | ONLY + | OPEN_EXISTING + | OPENJSON + | OPTIMISTIC + | OPTIMIZE + | OPTIMIZE_FOR_SEQUENTIAL_KEY + | ORIGINAL_DB_NAME + | ORIGINAL_LOGIN + | OUT + | OUTPUT + | OVERRIDE + | OWNER + | OWNERSHIP + | PAD_INDEX + | PAGE_VERIFY + | PAGECOUNT + | PAGLOCK + | PARAMETERIZATION + | PARSENAME + | PARSEONLY + | PARTITION + | PARTITIONS + | PARTNER + | PATH + | PATINDEX + | PAUSE + | PDW_SHOWSPACEUSED + | PERCENT_RANK + | PERCENTILE_CONT + | PERCENTILE_DISC + | PERMISSIONS + | PERSIST_SAMPLE_PERCENT + | PHYSICAL_ONLY + | POISON_MESSAGE_HANDLING + | POOL + | PORT + | PRECEDING + | PRIMARY_ROLE + | PRIOR + | PRIORITY + | PRIORITY_LEVEL + | PRIVATE + | PRIVATE_KEY + | PRIVILEGES + | PROCCACHE + | PROCEDURE_NAME + | PROPERTY + | PROVIDER + | PROVIDER_KEY_NAME + | PWDCOMPARE + | PWDENCRYPT + | QUERY + | QUERY_SQUARE_BRACKET + | QUEUE + | QUEUE_DELAY + | QUOTED_IDENTIFIER + | QUOTENAME + | RANDOMIZED + | RANGE + | RANK + | RC2 + | RC4 + | RC4_128 + | READ_COMMITTED_SNAPSHOT + | READ_ONLY + | READ_ONLY_ROUTING_LIST + | READ_WRITE + | READCOMMITTED + | READCOMMITTEDLOCK + | READONLY + | READPAST + | READUNCOMMITTED + | READWRITE + | REBUILD + | RECEIVE + | RECOMPILE + | RECOVERY + | RECURSIVE_TRIGGERS + | RELATIVE + | REMOTE + | REMOTE_PROC_TRANSACTIONS + | REMOTE_SERVICE_NAME + | REMOVE + | REORGANIZE + | REPAIR_ALLOW_DATA_LOSS + | REPAIR_FAST + | REPAIR_REBUILD + | REPEATABLE + | REPEATABLEREAD + | REPLACE + | REPLICA + | REPLICATE + | REQUEST_MAX_CPU_TIME_SEC + | REQUEST_MAX_MEMORY_GRANT_PERCENT + | REQUEST_MEMORY_GRANT_TIMEOUT_SEC + | REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT + | RESAMPLE + | RESERVE_DISK_SPACE + | RESOURCE + | RESOURCE_MANAGER_LOCATION + | RESTRICTED_USER + | RESUMABLE + | RETENTION + | REVERSE + | ROBUST + | ROOT + | ROUTE + | ROW + | ROW_NUMBER + | ROWGUID + | ROWLOCK + | ROWS + | RTRIM + | SAMPLE + | SCHEMA_ID + | SCHEMA_NAME + | SCHEMABINDING + | SCOPE_IDENTITY + | SCOPED + | SCROLL + | SCROLL_LOCKS + | SEARCH + | SECONDARY + | SECONDARY_ONLY + | SECONDARY_ROLE + | SECONDS + | SECRET + | SECURABLES + | SECURITY + | SECURITY_LOG + | SEEDING_MODE + | SELF + | SEMI_SENSITIVE + | SEND + | SENT + | SEQUENCE + | SEQUENCE_NUMBER + | SERIALIZABLE + | SERVERPROPERTY + | SERVICEBROKER + | SESSIONPROPERTY + | SESSION_TIMEOUT + | SETERROR + | SHARE + | SHARED + | SHOWCONTIG + | SHOWPLAN + | SHOWPLAN_ALL + | SHOWPLAN_TEXT + | SHOWPLAN_XML + | SIGNATURE + | SIMPLE + | SINGLE_USER + | SIZE + | SMALLINT + | SNAPSHOT + | SORT_IN_TEMPDB + | SOUNDEX + | SPACE_KEYWORD + | SPARSE + | SPATIAL_WINDOW_MAX_CELLS + | SQL_VARIANT_PROPERTY + | STANDBY + | START_DATE + | STATIC + | STATISTICS_INCREMENTAL + | STATISTICS_NORECOMPUTE + | STATS_DATE + | STATS_STREAM + | STATUS + | STATUSONLY + | STDEV + | STDEVP + | STOPLIST + | STR + | STRING_AGG + | STRING_ESCAPE + | STUFF + | SUBJECT + | SUBSCRIBE + | SUBSCRIPTION + | SUBSTRING + | SUM + | SUSER_ID + | SUSER_NAME + | SUSER_SID + | SUSER_SNAME + | SUSPEND + | SYMMETRIC + | SYNCHRONOUS_COMMIT + | SYNONYM + | SYSTEM + | TABLERESULTS + | TABLOCK + | TABLOCKX + | TAKE + | TARGET_RECOVERY_TIME + | TB + | TEXTIMAGE_ON + | THROW + | TIES + | TIME + | TIMEOUT + | TIMER + | TINYINT + | TORN_PAGE_DETECTION + | TRACKING + | TRANSACTION_ID + | TRANSFORM_NOISE_WORDS + | TRANSLATE + | TRIM + | TRIPLE_DES + | TRIPLE_DES_3KEY + | TRUSTWORTHY + | TRY + | TSQL + | TWO_DIGIT_YEAR_CUTOFF + | TYPE + | TYPE_ID + | TYPE_NAME + | TYPE_WARNING + | TYPEPROPERTY + | UNBOUNDED + | UNCOMMITTED + | UNICODE + | UNKNOWN + | UNLIMITED + | UNMASK + | UOW + | UPDLOCK + | UPPER + | USER_ID + | USER_NAME + | USING + | VALID_XML + | VALIDATION + | VALUE + | VALUE_SQUARE_BRACKET + | VAR + | VARBINARY_KEYWORD + | VARP + | VERIFY_CLONEDB + | VERSION + | VIEW_METADATA + | VIEWS + | WAIT + | WELL_FORMED_XML + | WITHOUT_ARRAY_WRAPPER + | WORK + | WORKLOAD + | XLOCK + | XML + | XML_COMPRESSION + | XMLDATA + | XMLNAMESPACES + | XMLSCHEMA + | XSINIL + | ZONE +//More keywords that can also be used as IDs + | ABORT_AFTER_WAIT + | ABSENT + | ADMINISTER + | AES + | ALLOW_CONNECTIONS + | ALLOW_MULTIPLE_EVENT_LOSS + | ALLOW_SINGLE_EVENT_LOSS + | ANONYMOUS + | APPEND + | APPLICATION + | ASYMMETRIC + | ASYNCHRONOUS_COMMIT + | AUTHENTICATE + | AUTHENTICATION + | AUTOMATED_BACKUP_PREFERENCE + | AUTOMATIC + | AVAILABILITY_MODE + | BEFORE + | BLOCK + | BLOCKERS + | BLOCKSIZE + | BLOCKING_HIERARCHY + | BUFFER + | BUFFERCOUNT + | CACHE + | CALLED + | CERTIFICATE + | CHANGETABLE + | CHANGES + | CHECK_POLICY + | CHECK_EXPIRATION + | CLASSIFIER_FUNCTION + | CLUSTER + | COMPRESS + | COMPRESSION + | CONNECT + | CONNECTION + | CONFIGURATION + | CONNECTIONPROPERTY + | CONTAINMENT + | CONTEXT + | CONTEXT_INFO + | CONTINUE_AFTER_ERROR + | CONTRACT + | CONTRACT_NAME + | CONVERSATION + | COPY_ONLY + | CURRENT_REQUEST_ID + | CURRENT_TRANSACTION_ID + | CYCLE + | DATA_COMPRESSION + | DATA_SOURCE + | DATABASE_MIRRORING + | DATASPACE + | DDL + | DECOMPRESS + | DEFAULT_DATABASE + | DEFAULT_SCHEMA + | DIAGNOSTICS + | DIFFERENTIAL + | DISTRIBUTION + | DTC_SUPPORT + | ENABLED + | ENDPOINT + | ERROR + | ERROR_LINE + | ERROR_MESSAGE + | ERROR_NUMBER + | ERROR_PROCEDURE + | ERROR_SEVERITY + | ERROR_STATE + | EVENT + | EVENTDATA + | EVENT_RETENTION_MODE + | EXECUTABLE_FILE + | EXPIREDATE + | EXTENSION + | EXTERNAL_ACCESS + | FAILOVER + | FAILURECONDITIONLEVEL + | FAN_IN + | FILE_SNAPSHOT + | FORCESEEK + | FORCE_SERVICE_ALLOW_DATA_LOSS + | FORMATMESSAGE + | GET + | GET_FILESTREAM_TRANSACTION_CONTEXT + | GETANCESTOR + | GETANSINULL + | GETDESCENDANT + | GETLEVEL + | GETREPARENTEDVALUE + | GETROOT + | GOVERNOR + | HASHED + | HEALTHCHECKTIMEOUT + | HEAP + | HIERARCHYID + | HOST_ID + | HOST_NAME + | IIF + | IO + | INCLUDE + | INCREMENT + | INFINITE + | INIT + | INSTEAD + | ISDESCENDANTOF + | ISNULL + | ISNUMERIC + | KERBEROS + | KEY_PATH + | KEY_STORE_PROVIDER_NAME + | LANGUAGE + | LIBRARY + | LIFETIME + | LINKED + | LINUX + | LISTENER_IP + | LISTENER_PORT + | LOCAL_SERVICE_NAME + | LOG + | MASK + | MATCHED + | MASTER + | MAX_MEMORY + | MAXTRANSFER + | MAXVALUE + | MAX_DISPATCH_LATENCY + | MAX_DURATION + | MAX_EVENT_SIZE + | MAX_SIZE + | MAX_OUTSTANDING_IO_PER_VOLUME + | MEDIADESCRIPTION + | MEDIANAME + | MEMBER + | MEMORY_PARTITION_MODE + | MESSAGE_FORWARDING + | MESSAGE_FORWARD_SIZE + | MINVALUE + | MIRROR + | MUST_CHANGE + | NEWID + | NEWSEQUENTIALID + | NOFORMAT + | NOINIT + | NONE + | NOREWIND + | NOSKIP + | NOUNLOAD + | NO_CHECKSUM + | NO_COMPRESSION + | NO_EVENT_LOSS + | NOTIFICATION + | NTLM + | OLD_PASSWORD + | ON_FAILURE + | OPERATIONS + | PAGE + | PARAM_NODE + | PARTIAL + | PASSWORD + | PERMISSION_SET + | PER_CPU + | PER_DB + | PER_NODE + | PERSISTED + | PLATFORM + | POLICY + | PREDICATE + | PROCESS + | PROFILE + | PYTHON + | R + | READ_WRITE_FILEGROUPS + | REGENERATE + | RELATED_CONVERSATION + | RELATED_CONVERSATION_GROUP + | REQUIRED + | RESET + | RESOURCES + | RESTART + | RESUME + | RETAINDAYS + | RETURNS + | REWIND + | ROLE + | ROUND_ROBIN + | ROWCOUNT_BIG + | RSA_512 + | RSA_1024 + | RSA_2048 + | RSA_3072 + | RSA_4096 + | SAFETY + | SAFE + | SCHEDULER + | SCHEME + | SCRIPT + | SERVER + | SERVICE + | SERVICE_BROKER + | SERVICE_NAME + | SESSION + | SESSION_CONTEXT + | SETTINGS + | SHRINKLOG + | SID + | SKIP_KEYWORD + | SOFTNUMA + | SOURCE + | SPECIFICATION + | SPLIT + | SQL + | SQLDUMPERFLAGS + | SQLDUMPERPATH + | SQLDUMPERTIMEOUT + | STATE + | STATS + | START + | STARTED + | STARTUP_STATE + | STOP + | STOPPED + | STOP_ON_ERROR + | SUPPORTED + | SWITCH + | TAPE + | TARGET + | TCP + | TOSTRING + | TRACE + | TRACK_CAUSALITY + | TRANSFER + | UNCHECKED + | UNLOCK + | UNSAFE + | URL + | USED + | VERBOSELOGGING + | VISIBILITY + | WAIT_AT_LOW_PRIORITY + | WINDOWS + | WITHOUT + | WITNESS + | XACT_ABORT + | XACT_STATE + // + | ABS + | ACOS + | ASIN + | ATAN + | ATN2 + | CEILING + | COS + | COT + | DEGREES + | EXP + | FLOOR + | LOG10 + | PI + | POWER + | RADIANS + | RAND + | ROUND + | SIGN + | SIN + | SQRT + | SQUARE + | TAN + // + | CURRENT_TIMEZONE + | CURRENT_TIMEZONE_ID + | DATE_BUCKET + | DATEDIFF_BIG + | DATEFROMPARTS + | DATETIME2FROMPARTS + | DATETIMEFROMPARTS + | DATETIMEOFFSETFROMPARTS + | DATETRUNC + | DAY + | EOMONTH + | ISDATE + | MONTH + | SMALLDATETIMEFROMPARTS + | SWITCHOFFSET + | SYSDATETIME + | SYSDATETIMEOFFSET + | SYSUTCDATETIME + | TIMEFROMPARTS + | TODATETIMEOFFSET + | YEAR + // + | QUARTER + | DAYOFYEAR + | WEEK + | HOUR + | MINUTE + | SECOND + | MILLISECOND + | MICROSECOND + | NANOSECOND + | TZOFFSET + | ISO_WEEK + | WEEKDAY + // + | YEAR_ABBR + | QUARTER_ABBR + | MONTH_ABBR + | DAYOFYEAR_ABBR + | DAY_ABBR + | WEEK_ABBR + | HOUR_ABBR + | MINUTE_ABBR + | SECOND_ABBR + | MILLISECOND_ABBR + | MICROSECOND_ABBR + | NANOSECOND_ABBR + | TZOFFSET_ABBR + | ISO_WEEK_ABBR + | WEEKDAY_ABBR + // + | SP_EXECUTESQL + //Build-ins: + | VARCHAR + | NVARCHAR + | PRECISION //For some reason this is possible to use as ID + | FILESTREAM_ON + ; + +// https://msdn.microsoft.com/en-us/library/ms175874.aspx +id_ + : ID + | TEMP_ID + | DOUBLE_QUOTE_ID + | DOUBLE_QUOTE_BLANK + | SQUARE_BRACKET_ID + | keyword + | RAW + ; + +simple_id + : ID + ; + +id_or_string + : id_ + | STRING + ; + +// https://msdn.microsoft.com/en-us/library/ms188074.aspx +// Spaces are allowed for comparison operators. +comparison_operator + : '=' | '>' | '<' | '<' '=' | '>' '=' | '<' '>' | '!' '=' | '!' '>' | '!' '<' + ; + +assignment_operator + : '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '^=' | '|=' + ; + +file_size + : DECIMAL( KB | MB | GB | TB | '%' )? + ; diff --git a/tsql/examples/Column_Elem.sql b/tsql/examples/Column_Elem.sql new file mode 100644 index 0000000..860c9fe --- /dev/null +++ b/tsql/examples/Column_Elem.sql @@ -0,0 +1,22 @@ +USE tempdb + +CREATE TABLE col_elem_ex +( + ident int NOT NULL IDENTITY(1,1), + rguid UNIQUEIDENTIFIER NOT NULL DEFAULT NEWID() ROWGUIDCOL, + col1 INT +) + +INSERT INTO col_elem_ex(col1) VALUES(2) + +SELECT $IDENTITY AS ident_col FROM col_elem_ex + +SELECT $ROWGUID AS guid_col FROM col_elem_ex + +SELECT col_elem_ex.col1 AS qualified_col FROM col_elem_ex + +SELECT col1 AS nonQualified_col FROM col_elem_ex + +SELECT NULL AS null_col FROM col_elem_ex + +DROP TABLE col_elem_ex diff --git a/tsql/examples/Set.sql b/tsql/examples/Set.sql new file mode 100644 index 0000000..3bab7e6 --- /dev/null +++ b/tsql/examples/Set.sql @@ -0,0 +1,5 @@ +SET XACT_ABORT ON +GO + +SET XACT_ABORT, NOCOUNT OFF +GO diff --git a/tsql/examples/analytic_windowed_functions.sql b/tsql/examples/analytic_windowed_functions.sql new file mode 100644 index 0000000..c3b0c04 --- /dev/null +++ b/tsql/examples/analytic_windowed_functions.sql @@ -0,0 +1,60 @@ +USE AdventureWorks2012; +GO + +SELECT FIRST_VALUE(SalesOrderNumber) OVER(PARTITION BY CustomerID ORDER BY OrderDate) + AS FirstSONumberPerCustomer +FROM Sales.SalesOrderHeader; + + +SELECT LAST_VALUE(SalesOrderNumber) OVER(PARTITION BY CustomerID ORDER BY OrderDate ROWS UNBOUNDED PRECEDING) + AS FirstSONumberPerCustomer +FROM Sales.SalesOrderHeader; + +SELECT LAG(PurchaseOrderNumber,2) OVER(PARTITION BY CustomerID ORDER BY OrderDate) AS PrevPONumberOffset2 +FROM sales.SalesOrderHeader; + +SELECT LEAD(PurchaseOrderNumber) OVER(PARTITION BY CustomerID ORDER BY OrderDate) AS NextPONumber +FROM sales.SalesOrderHeader; + +SELECT Department, LastName, Rate, + CUME_DIST () OVER (PARTITION BY Department ORDER BY Rate) AS CumeDist, + PERCENT_RANK() OVER (PARTITION BY Department ORDER BY Rate ) AS PctRank +FROM HumanResources.vEmployeeDepartmentHistory AS edh + INNER JOIN HumanResources.EmployeePayHistory AS e + ON e.BusinessEntityID = edh.BusinessEntityID +WHERE Department IN (N'Information Services',N'Document Control') +ORDER BY Department, Rate DESC; + +SELECT DISTINCT Name AS DepartmentName + ,PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY ph.Rate) + OVER (PARTITION BY Name) AS MedianCont + ,PERCENTILE_DISC(0.5) WITHIN GROUP (ORDER BY ph.Rate) + OVER (PARTITION BY Name) AS MedianDisc +FROM HumanResources.Department AS d +INNER JOIN HumanResources.EmployeeDepartmentHistory AS dh + ON dh.DepartmentID = d.DepartmentID +INNER JOIN HumanResources.EmployeePayHistory AS ph + ON ph.BusinessEntityID = dh.BusinessEntityID +WHERE dh.EndDate IS NULL; + + +SELECT DISTINCT Name AS DepartmentName + ,PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY ph.Rate) + OVER (PARTITION BY Name) AS MedianCont + ,PERCENTILE_DISC(0.5) WITHIN GROUP (ORDER BY ph.Rate) + OVER (PARTITION BY Name) AS MedianDisc +FROM HumanResources.Department AS d +INNER JOIN HumanResources.EmployeeDepartmentHistory AS dh + ON dh.DepartmentID = d.DepartmentID +INNER JOIN HumanResources.EmployeePayHistory AS ph + ON ph.BusinessEntityID = dh.BusinessEntityID +WHERE dh.EndDate IS NULL; + +SELECT Department, LastName, Rate, + CUME_DIST () OVER (PARTITION BY Department ORDER BY Rate) AS CumeDist, + PERCENT_RANK() OVER (PARTITION BY Department ORDER BY Rate ) AS PctRank +FROM HumanResources.vEmployeeDepartmentHistory AS edh + INNER JOIN HumanResources.EmployeePayHistory AS e + ON e.BusinessEntityID = edh.BusinessEntityID +WHERE Department IN (N'Information Services',N'Document Control') +ORDER BY Department, Rate DESC; diff --git a/tsql/examples/applicaton_roles.sql b/tsql/examples/applicaton_roles.sql new file mode 100644 index 0000000..803c396 --- /dev/null +++ b/tsql/examples/applicaton_roles.sql @@ -0,0 +1,12 @@ +ALTER APPLICATION ROLE weekly_receipts +WITH NAME = receipts_ledger; +GO +ALTER APPLICATION ROLE receipts_ledger +WITH NAME = weekly_ledger, +PASSWORD = '897yUUbv77bsrEE00nk2i', +DEFAULT_SCHEMA = Production; +GO +CREATE APPLICATION ROLE weekly_receipts + WITH PASSWORD = '987G^bv876sPY)Y5m23' + , DEFAULT_SCHEMA = Sales; +GO diff --git a/tsql/examples/assemblies.sql b/tsql/examples/assemblies.sql new file mode 100644 index 0000000..a654a23 --- /dev/null +++ b/tsql/examples/assemblies.sql @@ -0,0 +1,20 @@ +ALTER ASSEMBLY MyClass +ADD FILE FROM 'C:\MyClassProject\Class1.cs'; +ALTER ASSEMBLY ComplexNumber WITH PERMISSION_SET = EXTERNAL_ACCESS; +ALTER ASSEMBLY ComplexNumber +FROM 'C:\Program Files\Microsoft SQL Server\130\Tools\Samples\1033\Engine\Programmability\CLR\UserDefinedDataType\CS\ComplexNumber\obj\Debug\ComplexNumber.dll' ; + + +CREATE ASSEMBLY SQLCLRTest +FROM 'C:\MyDBApp\SQLCLRTest.dll'; + +CREATE ASSEMBLY SQLCLRTest +FROM 'C:\MyDBApp\SQLCLRTest.dll' +WITH PERMISSION_SET = SAFE; + +CREATE ASSEMBLY SQLCLRTest +FROM 'C:\MyDBApp\SQLCLRTest.dll' +WITH PERMISSION_SET = EXTERNAL_ACCESS; +CREATE ASSEMBLY SQLCLRTest +FROM 'C:\MyDBApp\SQLCLRTest.dll' +WITH PERMISSION_SET = UNSAFE; diff --git a/tsql/examples/asymmetric_keys.sql b/tsql/examples/asymmetric_keys.sql new file mode 100644 index 0000000..f8c338a --- /dev/null +++ b/tsql/examples/asymmetric_keys.sql @@ -0,0 +1,24 @@ +ALTER ASYMMETRIC KEY PacificSales09 +WITH PRIVATE KEY ( +DECRYPTION BY PASSWORD = '', +ENCRYPTION BY PASSWORD = ''); +GO +ALTER ASYMMETRIC KEY PacificSales19 REMOVE PRIVATE KEY; +GO +--Left out open master key because it doesn't match 2008 and up syntax +ALTER ASYMMETRIC KEY PacificSales09 WITH PRIVATE KEY ( +DECRYPTION BY PASSWORD = '' ); +go +CREATE ASYMMETRIC KEY PacificSales09 + WITH ALGORITHM = RSA_2048 + ENCRYPTION BY PASSWORD = ''; +GO +CREATE ASYMMETRIC KEY PacificSales19 AUTHORIZATION Christina + FROM FILE = 'c:\PacSales\Managers\ChristinaCerts.tmp' + ENCRYPTION BY PASSWORD = ''; +GO +CREATE ASYMMETRIC KEY PacificSales19 AUTHORIZATION Christina + FROM FILE = 'c:\PacSales\Managers\ChristinaCerts.tmp' + ENCRYPTION BY PASSWORD = ''; +GO + diff --git a/tsql/examples/authorizations.sql b/tsql/examples/authorizations.sql new file mode 100644 index 0000000..cc70be5 --- /dev/null +++ b/tsql/examples/authorizations.sql @@ -0,0 +1,19 @@ +ALTER AUTHORIZATION ON OBJECT::Parts.Sprockets TO MichikoOsada; +GO +ALTER AUTHORIZATION ON Parts.Sprockets TO MichikoOsada; +GO +ALTER AUTHORIZATION ON Sprockets TO MichikoOsada; +ALTER AUTHORIZATION ON OBJECT::Sprockets TO MichikoOsada; +ALTER AUTHORIZATION ON OBJECT::Production.ProductionView06 TO SCHEMA OWNER; +GO +ALTER AUTHORIZATION ON SCHEMA::SeattleProduction11 TO SandraAlayo; +GO +ALTER AUTHORIZATION ON ENDPOINT::CantabSalesServer1 TO JaePak; +GO +ALTER AUTHORIZATION ON Sprockets TO MichikoOsada; +ALTER AUTHORIZATION ON dbo.Sprockets TO MichikoOsada; +ALTER AUTHORIZATION ON OBJECT::Sprockets TO MichikoOsada; +ALTER AUTHORIZATION ON OBJECT::dbo.Sprockets TO MichikoOsada; +ALTER AUTHORIZATION ON DATABASE::Parts TO MichikoOsada; +-- The following test is for when azure syntax is included +--ALTER AUTHORIZATION ON database::targetDB TO [rachel@cqclinic.onmicrosoft.com]; diff --git a/tsql/examples/availability_group.sql b/tsql/examples/availability_group.sql new file mode 100644 index 0000000..9ff2c79 --- /dev/null +++ b/tsql/examples/availability_group.sql @@ -0,0 +1,87 @@ +-- Found some of these samples at: +--https://technet.microsoft.com/en-us/library/ff878303(v=sql.110).aspx + +ALTER AVAILABILITY GROUP AccountsAG JOIN; +GO +ALTER AVAILABILITY GROUP AccountsAG FORCE_FAILOVER_ALLOW_DATA_LOSS; +GO +ALTER AVAILABILITY GROUP MyAG ADD DATABASE MyDb3; +GO +ALTER AVAILABILITY GROUP MyAg FAILOVER; +ALTER AVAILABILITY GROUP AccountsAG MODIFY REPLICA ON 'INSTANCE09' + WITH (AVAILABILITY_MODE = SYNCHRONOUS_COMMIT); +ALTER AVAILABILITY GROUP AccountsAG MODIFY REPLICA ON 'INSTANCE09' + WITH (FAILOVER_MODE = AUTOMATIC); +ALTER AVAILABILITY GROUP MyAG MODIFY REPLICA ON 'COMPUTER01' WITH + (FAILOVER_MODE = AUTOMATIC); +ALTER AVAILABILITY GROUP [ag1] JOIN +ALTER AVAILABILITY GROUP [ag1] GRANT CREATE ANY DATABASE +GO +ALTER AVAILABILITY GROUP [ag1] +ADD LISTENER 'ag1-listener' ( WITH IP ( ('2001:db88:f000:f00f:9876:cf3c:a010:b945'),('2001:4898:e0dc:f213:5678:4ce2:8790:7654') ) , PORT = 60173); +ALTER AVAILABILITY GROUP AG1 SET (FAILURE_CONDITION_LEVEL = 1); +GO +ALTER AVAILABILITY GROUP [distributedag] +JOIN +AVAILABILITY GROUP ON +'ag1' WITH +( +LISTENER_URL = 'tcp://ag1-listener.contoso.com:5022', +AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT, +FAILOVER_MODE = MANUAL, +SEEDING_MODE = AUTOMATIC +), +'ag2' WITH +( +LISTENER_URL = 'tcp://ag2-listener.contoso.com:5022', +AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT, +FAILOVER_MODE = MANUAL, +SEEDING_MODE = AUTOMATIC +); +GO +ALTER AVAILABILITY GROUP [distributedag] +MODIFY +AVAILABILITY GROUP ON +'ag1' WITH +( +LISTENER_URL = 'tcp://ag1-listener.contoso.com:5022', +AVAILABILITY_MODE = ASYNCHRONOUS_COMMIT, +FAILOVER_MODE = MANUAL, +SEEDING_MODE = MANUAL +), +'ag2' WITH +( +LISTENER_URL = 'tcp://ag2-listener.contoso.com:5022', +AVAILABILITY_MODE = SYNCHRONOUS_COMMIT, +FAILOVER_MODE = MANUAL, +SEEDING_MODE = MANUAL +); + +ALTER AVAILABILITY GROUP [SQLFCIDAG] +MODIFY AVAILABILITY GROUP ON +'SQLFCIAG' WITH +( +LISTENER_URL = 'tcp://SQLFCIAG-2.contoso.com:5022' +) +ALTER AVAILABILITY GROUP MyaAG +WITH ( +DTC_SUPPORT = PER_DB +); +ALTER AVAILABILITY GROUP AG2 + ADD REPLICA ON + 'COMPUTER03\HADR_INSTANCE' WITH + ( + ENDPOINT_URL = 'TCP://COMPUTER03:7022', + PRIMARY_ROLE ( ALLOW_CONNECTIONS = READ_WRITE ), + SECONDARY_ROLE (ALLOW_CONNECTIONS = READ_ONLY ) + ); +GO +ALTER AVAILABILITY GROUP availability_group_name DENY CREATE ANY DATABASE +GO +ALTER AVAILABILITY GROUP ag1 +MODIFY REPLICA ON 'primary_node' WITH (SEEDING_MODE = AUTOMATIC) +GO +ALTER AVAILABILITY GROUP [AGName] + MODIFY REPLICA ON 'Replica_Name' + WITH (SEEDING_MODE = AUTOMATIC) +; diff --git a/tsql/examples/azure_synapse_analytics.sql b/tsql/examples/azure_synapse_analytics.sql new file mode 100644 index 0000000..9c38888 --- /dev/null +++ b/tsql/examples/azure_synapse_analytics.sql @@ -0,0 +1,31 @@ +CREATE TABLE [Monty].[Spam] +( + Meat int +) +WITH +( + CLUSTERED COLUMNSTORE INDEX, + DISTRIBUTION = HASH(Meat) +); + +CREATE TABLE [Monty].[Eggs] +( + Ham int, + Chilli int, + Milk int +) +WITH +( + CLUSTERED INDEX(Ham DESC, Chilli ASC, Milk), + DISTRIBUTION = ROUND_ROBIN +); + +CREATE TABLE [Monty].[Coconut] +( + LumberJack int +) +WITH +( + DISTRIBUTION = REPLICATE, + HEAP +); diff --git a/tsql/examples/backup.sql b/tsql/examples/backup.sql new file mode 100644 index 0000000..ac83619 --- /dev/null +++ b/tsql/examples/backup.sql @@ -0,0 +1,65 @@ +BACKUP DATABASE AdventureWorks2012 +TO DISK='X:\SQLServerBackups\AdventureWorks1.bak', +DISK='Y:\SQLServerBackups\AdventureWorks2.bak', +DISK='Z:\SQLServerBackups\AdventureWorks3.bak' +WITH FORMAT, + MEDIANAME = 'AdventureWorksStripedSet0', + MEDIADESCRIPTION = 'Striped media set for AdventureWorks2012 database'; +GO +BACKUP DATABASE AdventureWorks2012 +TO DISK='X:\SQLServerBackups\AdventureWorks1a.bak', +DISK='Y:\SQLServerBackups\AdventureWorks2a.bak', +DISK='Z:\SQLServerBackups\AdventureWorks3a.bak' +MIRROR TO DISK='X:\SQLServerBackups\AdventureWorks1b.bak', +DISK='Y:\SQLServerBackups\AdventureWorks2b.bak', +DISK='Z:\SQLServerBackups\AdventureWorks3b.bak'; +GO +BACKUP DATABASE AdventureWorks2012 + TO DISK = 'Z:\SQLServerBackups\AdvWorksData.bak' + WITH FORMAT; +GO +BACKUP DATABASE AdventureWorks2012 TO AdvWorksData; +GO +BACKUP DATABASE Sales + FILEGROUP = 'SalesGroup1', + FILEGROUP = 'SalesGroup2' + TO DISK = 'Z:\SQLServerBackups\SalesFiles.bck'; +GO +BACKUP DATABASE Sales + FILEGROUP = 'SalesGroup1', + FILEGROUP = 'SalesGroup2' + TO DISK = 'Z:\SQLServerBackups\SalesFiles.bck' + WITH + DIFFERENTIAL; +GO +BACKUP DATABASE AdventureWorks2012 +TO TAPE = '\\.\tape0' +MIRROR TO TAPE = '\\.\tape1' +MIRROR TO TAPE = '\\.\tape2' +MIRROR TO TAPE = '\\.\tape3' +WITH + FORMAT, + MEDIANAME = 'AdventureWorksSet0' +BACKUP DATABASE AdventureWorks2012 +TO TAPE = '\\.\tape0', TAPE = '\\.\tape1' +MIRROR TO TAPE = '\\.\tape2', TAPE = '\\.\tape3' +WITH + FORMAT, + MEDIANAME = 'AdventureWorksSet1'; +BACKUP DATABASE AdventureWorks2012 TO DISK='Z:\SQLServerBackups\AdvWorksData.bak' +WITH + FORMAT, + COMPRESSION; +BACKUP DATABASE Sales +TO URL = 'https://mystorageaccount.blob.core.windows.net/myfirstcontainer/Sales_20160726.bak' +WITH STATS = 5; +BACKUP LOG AdventureWorks2012 + TO AdvWorksLog; + +BACKUP LOG AdventureWorks2012 +TO TAPE = '\\.\tape0', TAPE = '\\.\tape1' +MIRROR TO TAPE = '\\.\tape2', TAPE = '\\.\tape3' +WITH + NOINIT, + MEDIANAME = 'AdventureWorksSet1'; + diff --git a/tsql/examples/backup_certificate.sql b/tsql/examples/backup_certificate.sql new file mode 100644 index 0000000..8dc01f0 --- /dev/null +++ b/tsql/examples/backup_certificate.sql @@ -0,0 +1,15 @@ +BACKUP CERTIFICATE sales05 TO FILE = 'c:\storedcerts\sales05cert'; +GO +BACKUP CERTIFICATE sales05 TO FILE = 'c:\storedcerts\sales05cert' + WITH PRIVATE KEY ( FILE = 'c:\storedkeys\sales05key' , + ENCRYPTION BY PASSWORD = '997jkhUbhk$w4ez0876hKHJH5gh' ); +GO +BACKUP CERTIFICATE sales09 TO FILE = 'c:\storedcerts\sales09cert' + WITH PRIVATE KEY ( DECRYPTION BY PASSWORD = '9875t6#6rfid7vble7r' , + FILE = 'c:\storedkeys\sales09key' , + ENCRYPTION BY PASSWORD = '9n34khUbhk$w4ecJH5gh' ); +GO +BACKUP CERTIFICATE sales05 TO FILE = '\\ServerA7\storedcerts\sales05cert' + WITH PRIVATE KEY ( FILE = '\\ServerA7\storedkeys\sales05key' , + ENCRYPTION BY PASSWORD = '997jkhUbhk$w4ez0876hKHJH5gh' ); +GO diff --git a/tsql/examples/backup_master_key.sql b/tsql/examples/backup_master_key.sql new file mode 100644 index 0000000..7b1e6a3 --- /dev/null +++ b/tsql/examples/backup_master_key.sql @@ -0,0 +1,3 @@ +BACKUP MASTER KEY TO FILE = 'c:\temp\exportedmasterkey' + ENCRYPTION BY PASSWORD = 'sd092735kjn$&adsg'; +GO diff --git a/tsql/examples/backup_service_master_key.sql b/tsql/examples/backup_service_master_key.sql new file mode 100644 index 0000000..357f2de --- /dev/null +++ b/tsql/examples/backup_service_master_key.sql @@ -0,0 +1 @@ +BACKUP SERVICE MASTER KEY TO FILE = 'c:\temp_backups\keys\service_master_key' ENCRYPTION BY PASSWORD = '3dH85Hhk003GHk2597gheij4'; diff --git a/tsql/examples/broker_priority.sql b/tsql/examples/broker_priority.sql new file mode 100644 index 0000000..7b2e4e2 --- /dev/null +++ b/tsql/examples/broker_priority.sql @@ -0,0 +1,88 @@ +ALTER BROKER PRIORITY SimpleContractDefaultPriority + FOR CONVERSATION + SET (PRIORITY_LEVEL = 3); +ALTER BROKER PRIORITY SimpleContractPriority + FOR CONVERSATION + SET (CONTRACT_NAME = SimpleContractB, + LOCAL_SERVICE_NAME = TargetServiceB, + REMOTE_SERVICE_NAME = N'InitiatorServiceB', + PRIORITY_LEVEL = 8); +CREATE BROKER PRIORITY InitiatorAToTargetPriority + FOR CONVERSATION + SET (CONTRACT_NAME = SimpleContract, + LOCAL_SERVICE_NAME = InitiatorServiceA, + REMOTE_SERVICE_NAME = N'TargetService', + PRIORITY_LEVEL = 3); +CREATE BROKER PRIORITY TargetToInitiatorAPriority + FOR CONVERSATION + SET (CONTRACT_NAME = SimpleContract, + LOCAL_SERVICE_NAME = TargetService, + REMOTE_SERVICE_NAME = N'InitiatorServiceA', + PRIORITY_LEVEL = 3); +CREATE BROKER PRIORITY SimpleContractDefaultPriority + FOR CONVERSATION + SET (CONTRACT_NAME = SimpleContract, + LOCAL_SERVICE_NAME = ANY, + REMOTE_SERVICE_NAME = ANY, + PRIORITY_LEVEL = 7); +CREATE BROKER PRIORITY [//Adventure-Works.com/Expenses/BasePriority] + FOR CONVERSATION + SET (CONTRACT_NAME = ANY, + LOCAL_SERVICE_NAME = ANY, + REMOTE_SERVICE_NAME = ANY, + PRIORITY_LEVEL = 3); +CREATE BROKER PRIORITY GoldInitToTargetPriority + FOR CONVERSATION + SET (CONTRACT_NAME = SimpleContract, + LOCAL_SERVICE_NAME = GoldInitiatorService, + REMOTE_SERVICE_NAME = N'TargetService', + PRIORITY_LEVEL = 6); +CREATE BROKER PRIORITY GoldTargetToInitPriority + FOR CONVERSATION + SET (CONTRACT_NAME = SimpleContract, + LOCAL_SERVICE_NAME = TargetService, + REMOTE_SERVICE_NAME = N'GoldInitiatorService', + PRIORITY_LEVEL = 6); +CREATE BROKER PRIORITY SilverInitToTargetPriority + FOR CONVERSATION + SET (CONTRACT_NAME = SimpleContract, + LOCAL_SERVICE_NAME = SilverInitiatorService, + REMOTE_SERVICE_NAME = N'TargetService', + PRIORITY_LEVEL = 4); +CREATE BROKER PRIORITY SilverTargetToInitPriority + FOR CONVERSATION + SET (CONTRACT_NAME = SimpleContract, + LOCAL_SERVICE_NAME = TargetService, + REMOTE_SERVICE_NAME = N'SilverInitiatorService', + PRIORITY_LEVEL = 4); +CREATE BROKER PRIORITY BronzeInitToTargetPriority + FOR CONVERSATION + SET (CONTRACT_NAME = SimpleContract, + LOCAL_SERVICE_NAME = BronzeInitiatorService, + REMOTE_SERVICE_NAME = N'TargetService', + PRIORITY_LEVEL = 2); +CREATE BROKER PRIORITY BronzeTargetToInitPriority + FOR CONVERSATION + SET (CONTRACT_NAME = SimpleContract, + LOCAL_SERVICE_NAME = TargetService, + REMOTE_SERVICE_NAME = N'BronzeInitiatorService', + PRIORITY_LEVEL = 2); +CREATE BROKER PRIORITY GoldPriority + FOR CONVERSATION + SET (CONTRACT_NAME = GoldContract, + LOCAL_SERVICE_NAME = ANY, + REMOTE_SERVICE_NAME = ANY, + PRIORITY_LEVEL = 6); +CREATE BROKER PRIORITY SilverPriority + FOR CONVERSATION + SET (CONTRACT_NAME = SilverContract, + LOCAL_SERVICE_NAME = ANY, + REMOTE_SERVICE_NAME = ANY, + PRIORITY_LEVEL = 4); +CREATE BROKER PRIORITY BronzePriority + FOR CONVERSATION + SET (CONTRACT_NAME = BronzeContract, + LOCAL_SERVICE_NAME = ANY, + REMOTE_SERVICE_NAME = ANY, + PRIORITY_LEVEL = 2); + diff --git a/tsql/examples/built_in_functions_cryptographic.sql b/tsql/examples/built_in_functions_cryptographic.sql new file mode 100644 index 0000000..b639726 --- /dev/null +++ b/tsql/examples/built_in_functions_cryptographic.sql @@ -0,0 +1,2 @@ +SELECT Cert_ID('ABerglundCert3'); +GO diff --git a/tsql/examples/built_in_functions_cursor.sql b/tsql/examples/built_in_functions_cursor.sql new file mode 100644 index 0000000..e339b01 --- /dev/null +++ b/tsql/examples/built_in_functions_cursor.sql @@ -0,0 +1,55 @@ +USE AdventureWorks2012; +GO +SELECT @@CURSOR_ROWS; +DECLARE Name_Cursor CURSOR FOR +SELECT LastName ,@@CURSOR_ROWS FROM Person.Person; +OPEN Name_Cursor; +FETCH NEXT FROM Name_Cursor; +SELECT @@CURSOR_ROWS; +CLOSE Name_Cursor; +DEALLOCATE Name_Cursor; +GO + +DECLARE Employee_Cursor CURSOR FOR +SELECT BusinessEntityID, JobTitle +FROM AdventureWorks2012.HumanResources.Employee; +OPEN Employee_Cursor; +FETCH NEXT FROM Employee_Cursor; +WHILE @@FETCH_STATUS = 0 + BEGIN + FETCH NEXT FROM Employee_Cursor; + END; +CLOSE Employee_Cursor; +DEALLOCATE Employee_Cursor; +GO + +CREATE TABLE #TMP +( + ii INT +) +GO + +INSERT INTO #TMP(ii) VALUES(1) +INSERT INTO #TMP(ii) VALUES(2) +INSERT INTO #TMP(ii) VALUES(3) + +GO + +--Create a cursor. +DECLARE cur CURSOR +FOR SELECT * FROM #TMP + +--Display the status of the cursor before and after opening +--closing the cursor. + +SELECT CURSOR_STATUS('global','cur') AS 'After declare' +OPEN cur +SELECT CURSOR_STATUS('global','cur') AS 'After Open' +CLOSE cur +SELECT CURSOR_STATUS('global','cur') AS 'After Close' + +--Remove the cursor. +DEALLOCATE cur + +--Drop the table. +DROP TABLE #TMP diff --git a/tsql/examples/built_in_functions_data_type.sql b/tsql/examples/built_in_functions_data_type.sql new file mode 100644 index 0000000..a6f6843 --- /dev/null +++ b/tsql/examples/built_in_functions_data_type.sql @@ -0,0 +1,121 @@ +SELECT length = DATALENGTH(EnglishProductName), EnglishProductName +FROM dbo.DimProduct +ORDER BY EnglishProductName; +GO +USE AdventureWorks2012; +GO +SELECT IDENT_CURRENT ('Person.Address') AS Current_Identity; +GO +USE AdventureWorks2012; +GO +IF OBJECT_ID(N't6', N'U') IS NOT NULL + DROP TABLE t6; +GO +IF OBJECT_ID(N't7', N'U') IS NOT NULL + DROP TABLE t7; +GO +CREATE TABLE t6(id INT IDENTITY); +CREATE TABLE t7(id INT IDENTITY(100,1)); +GO +CREATE TRIGGER t6ins ON t6 FOR INSERT +AS +BEGIN + INSERT t7 DEFAULT VALUES +END; +GO +--End of trigger definition + +SELECT id FROM t6; +--IDs empty. + +SELECT id FROM t7; +--ID is empty. + +--Do the following in Session 1 +INSERT t6 DEFAULT VALUES; +SELECT @@IDENTITY; +/*Returns the value 100. This was inserted by the trigger.*/ + +SELECT SCOPE_IDENTITY(); +/* Returns the value 1. This was inserted by the +INSERT statement two statements before this query.*/ + +SELECT IDENT_CURRENT('t7'); +/* Returns value inserted into t7, that is in the trigger.*/ + +SELECT IDENT_CURRENT('t6'); +/* Returns value inserted into t6. This was the INSERT statement four statements before this query.*/ + +-- Do the following in Session 2. +SELECT @@IDENTITY; +/* Returns NULL because there has been no INSERT action +up to this point in this session.*/ + +SELECT SCOPE_IDENTITY(); +/* Returns NULL because there has been no INSERT action +up to this point in this scope in this session.*/ + +SELECT IDENT_CURRENT('t7'); +/* Returns the last value inserted into t7.*/ + +USE AdventureWorks2012; +GO +SELECT IDENT_INCR('Person.Address') AS Identity_Increment; +GO +USE AdventureWorks2012; +GO +SELECT TABLE_SCHEMA, TABLE_NAME, + IDENT_INCR(TABLE_SCHEMA + '.' + TABLE_NAME) AS IDENT_INCR +FROM INFORMATION_SCHEMA.TABLES +WHERE IDENT_INCR(TABLE_SCHEMA + '.' + TABLE_NAME) IS NOT NULL; + +USE AdventureWorks2012; +GO +SELECT IDENT_SEED('Person.Address') AS Identity_Seed; +GO +USE AdventureWorks2012; +GO +SELECT TABLE_SCHEMA, TABLE_NAME, + IDENT_SEED(TABLE_SCHEMA + '.' + TABLE_NAME) AS IDENT_SEED +FROM INFORMATION_SCHEMA.TABLES +WHERE IDENT_SEED(TABLE_SCHEMA + '.' + TABLE_NAME) IS NOT NULL; +GO +--(1) +SELECT IDENTITY(int, 1,1) AS ID_Num +INTO NewTable +FROM OldTable; + +--(2) +SELECT ID_Num = IDENTITY(int, 1, 1) +INTO NewTable +FROM OldTable; +USE AdventureWorks2012; +GO +IF OBJECT_ID (N'Person.NewContact', N'U') IS NOT NULL + DROP TABLE Person.NewContact; +GO +ALTER DATABASE AdventureWorks2012 SET RECOVERY BULK_LOGGED; +GO +SELECT IDENTITY(smallint, 100, 1) AS ContactNum, + FirstName AS First, + LastName AS Last +INTO Person.NewContact +FROM Person.Person; +GO +ALTER DATABASE AdventureWorks2012 SET RECOVERY FULL; +GO +SELECT ContactNum, First, Last FROM Person.NewContact; +GO +CREATE TABLE tableA(colA sql_variant, colB int) +INSERT INTO tableA values ( cast (46279.1 as decimal(8,2)), 1689) + +SELECT SQL_VARIANT_PROPERTY(colA,'BaseType') AS 'Base Type', + SQL_VARIANT_PROPERTY(colA,'Precision') AS 'Precision', + SQL_VARIANT_PROPERTY(colA,'Scale') AS 'Scale' +FROM tableA +WHERE colB = 1689 +DECLARE @v1 sql_variant; +SET @v1 = 'ABC'; +SELECT @v1; +SELECT SQL_VARIANT_PROPERTY(@v1, 'BaseType'); +SELECT SQL_VARIANT_PROPERTY(@v1, 'MaxLength'); diff --git a/tsql/examples/built_in_functions_date.sql b/tsql/examples/built_in_functions_date.sql new file mode 100644 index 0000000..41dd1da --- /dev/null +++ b/tsql/examples/built_in_functions_date.sql @@ -0,0 +1,204 @@ +-- CURRENT_TIMESTAMP +SELECT CURRENT_TIMESTAMP; +SELECT CURRENT_TIMESTAMP AS datetime; + +GO +-- CURRENT_TIMEZONE +SELECT CURRENT_TIMEZONE(); +SELECT CURRENT_TIMEZONE() AS timezone; + +GO +-- CURRENT_TIMEZONE_ID +SELECT CURRENT_TIMEZONE_ID(); +SELECT CURRENT_TIMEZONE_ID() AS timezone_id; + +GO +-- DATE_BUCKET +DECLARE @date DATETIME2 = '2020-04-15 21:22:11'; +SELECT DATE_BUCKET(WEEK, 1, @date); + +DECLARE @date DATETIME2 = '2020-06-15 21:22:11'; +DECLARE @origin DATETIME2 = '2019-01-01 00:00:00'; +SELECT DATE_BUCKET(WEEK, 5, @date, @origin); + +GO +-- DATE_ADD +SELECT DATEADD(month, 1, '20060830'); +SELECT DATEADD(month, 1, '2006-08-31'); + +GO +-- DATE_DIFF +DECLARE @startdate DATETIME2 = '2007-05-05 12:10:09.3312722'; +DECLARE @enddate DATETIME2 = '2007-05-04 12:10:09.3312722'; +SELECT DATEDIFF(day, @startdate, @enddate); +SELECT DATEDIFF(millisecond, GETDATE(), SYSDATETIME()); + +SELECT DATEDIFF(year, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF(quarter, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF(month, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF(dayofyear, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF(day, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF(week, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF(hour, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF(minute, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF(second, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF(millisecond, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF(microsecond, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); + +GO +-- DATEDIFF_BIG +DECLARE @startDate DATETIME2 = '2007-05-06 12:10:09'; +DECLARE @endDate DATETIME2 = '2007-05-07 12:10:09'; +SELECT DATEDIFF_BIG(day, @startDate, @endDate); + +SELECT DATEDIFF_BIG(year, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF_BIG(quarter, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF_BIG(month, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF_BIG(dayofyear, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF_BIG(day, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF_BIG(week, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF_BIG(hour, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF_BIG(minute, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF_BIG(second, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); +SELECT DATEDIFF_BIG(millisecond, '2005-12-31 23:59:59.9999999', '2006-01-01 00:00:00.0000000'); + +GO +-- DATEFROMPARTS +DECLARE @dateformatsYear INT = 2010; +DECLARE @dateformatsMonth INT = 12; +DECLARE @dateformatsDay INT = 31; +SELECT DATEFROMPARTS (2010, 12, 31); +SELECT DATEFROMPARTS (@dateformatsYear, @dateformatsMonth, @dateformatsDay); + +GO +-- DATENAME +SELECT DATENAME(year, '12:10:30.123'), + DATENAME(month, '12:10:30.123'), + DATENAME(day, '12:10:30.123'), + DATENAME(dayofyear, '12:10:30.123'), + DATENAME(weekday, '12:10:30.123'); +DECLARE @t time = '12:10:30.123'; +SELECT DATENAME(year, @t); + +GO +-- DATEPART +SELECT DATEPART (tzoffset, '2007-05-10 00:00:01.1234567 +05:10'); +SELECT DATEPART(year, '12:10:30.123'), + DATEPART(month, '12:10:30.123'), + DATEPART(day, '12:10:30.123'), + DATEPART(dayofyear, '12:10:30.123'), + DATEPART(weekday, '12:10:30.123'); +SELECT DATEPART(millisecond, '00:00:01.1234567'); +SELECT DATEPART(microsecond, '00:00:01.1234567'); +SELECT DATEPART(nanosecond, '00:00:01.1234567'); + +DECLARE @t time = '12:10:30.123'; +SELECT DATEPART(year, @t); + +SELECT DATEPART(year, 0), DATEPART(month, 0), DATEPART(day, 0); + +GO +-- DATETIME2FROMPARTS +SELECT DATETIME2FROMPARTS (2010, 12, 31, 23, 59, 59, 0, 0); +SELECT DATETIME2FROMPARTS (2011, 8, 15, 14, 23, 44, 5, 1); +SELECT DATETIME2FROMPARTS (2011, 8, 15, 14, 23, 44, 50, 2); +SELECT DATETIME2FROMPARTS (2011, 8, 15, 14, 23, 44, 500, 3); + +GO +-- DATETIMEFROMPARTS +SELECT DATETIMEFROMPARTS (2010, 12, 31, 23, 59, 59, 0); + +GO +-- DATETIMEOFFSETFROMPARTS +SELECT DATETIMEOFFSETFROMPARTS (2010, 12, 31, 14, 23, 23, 0, 12, 0, 7); +SELECT DATETIMEOFFSETFROMPARTS (2011, 8, 15, 14, 30, 00, 5, 12, 30, 1); +SELECT DATETIMEOFFSETFROMPARTS (2011, 8, 15, 14, 30, 00, 50, 12, 30, 2); +SELECT DATETIMEOFFSETFROMPARTS (2011, 8, 15, 14, 30, 00, 500, 12, 30, 3); + +GO +-- DATETRUNC +DECLARE @d datetime2 = '2021-12-08 11:30:15.1234567'; +SELECT 'Year', DATETRUNC(year, @d); +SELECT 'Quarter', DATETRUNC(quarter, @d); +SELECT 'Month', DATETRUNC(month, @d); +SELECT 'Week', DATETRUNC(week, @d); +SELECT 'Iso_week', DATETRUNC(iso_week, @d); +SELECT 'DayOfYear', DATETRUNC(dayofyear, @d); +SELECT 'Day', DATETRUNC(day, @d); +SELECT 'Hour', DATETRUNC(hour, @d); +SELECT 'Minute', DATETRUNC(minute, @d); +SELECT 'Second', DATETRUNC(second, @d); +SELECT 'Millisecond', DATETRUNC(millisecond, @d); +SELECT 'Microsecond', DATETRUNC(microsecond, @d); + +GO +-- DAY +SELECT DAY('2015-04-30 01:01:01.1234567'); + +GO +-- EOMONTH +DECLARE @date DATETIME = '12/1/2011'; +SELECT EOMONTH (@date); +SELECT EOMONTH (@date) AS 'This Month'; +SELECT EOMONTH (@date, 1) AS 'Next Month'; +SELECT EOMONTH (@date, -1) AS 'Last Month'; + +GO +-- GETDATE +SELECT GETDATE(); +SELECT GETDATE() AS curr_date; + +GO +-- GETUTCDATE +SELECT GETUTCDATE(); +SELECT GETUTCDATE() AS curr_utc_date; + +GO +-- ISDATE +SELECT ISDATE('04/15/2008'); +SELECT ISDATE('15/04/2008'); + +GO +-- MONTH +SELECT MONTH('2007-04-30T01:01:01.1234567 -07:00'); + +GO +-- SMALLDATETIMEFROMPARTS +SELECT SMALLDATETIMEFROMPARTS (2010, 12, 31, 23, 59); + +GO +-- SWITCHOFFSET +SELECT SWITCHOFFSET ('1998-09-20 7:45:50.71345 -5:00', '-08:00'); + +GO +-- SYSDATETIME +SELECT SYSDATETIME(); +SELECT SYSDATETIME() AS sys_date; + +GO +-- SYSDATETIMEOFFSET +SELECT SYSDATETIMEOFFSET(); +SELECT SYSDATETIMEOFFSET() AS sys_date_offset; + +GO +-- SYSUTCDATETIME +SELECT SYSUTCDATETIME(); +SELECT SYSUTCDATETIME() AS sys_utc_datetime; + +GO +-- TIMEFROMPARTS +SELECT TIMEFROMPARTS (23, 59, 59, 0, 0); +SELECT TIMEFROMPARTS (14, 23, 44, 5, 1); +SELECT TIMEFROMPARTS (14, 23, 44, 50, 2); +SELECT TIMEFROMPARTS (14, 23, 44, 500, 3); + +GO +-- TODATETIMEOFFSET +DECLARE @todaysDateTime DATETIME2 = '2015-04-30 01:01:01.1234567' +SELECT TODATETIMEOFFSET (@todaysDateTime, '-07:00'); +SELECT TODATETIMEOFFSET(@todaysDateTime, -120); +SELECT TODATETIMEOFFSET(@todaysDateTime, '+13:00'); + +GO +-- YEAR +SELECT YEAR('2010-04-30T01:01:01.1234567-07:00'); \ No newline at end of file diff --git a/tsql/examples/built_in_functions_json.sql b/tsql/examples/built_in_functions_json.sql new file mode 100644 index 0000000..9469e99 --- /dev/null +++ b/tsql/examples/built_in_functions_json.sql @@ -0,0 +1,194 @@ +DECLARE @param varchar(max) +SET @param = '[{"hello":"world",foo:"bar"}]' + +IF (ISJSON(@param) > 0) +BEGIN + print 1 +END + +SELECT id, json_col +FROM tab1 +WHERE ISJSON(json_col) = 1 + +SELECT id, json_col +FROM tab1 +WHERE ISJSON(json_col, SCALAR) = 1 + +SELECT ISJSON('true', VALUE) + +SELECT ISJSON('test string', VALUE) + +SELECT ISJSON('"test string"', SCALAR) + +SELECT JSON_OBJECT(); + +SELECT JSON_OBJECT('name':'value', 'type':1) + +SELECT JSON_OBJECT('name':'value', 'type':NULL ABSENT ON NULL) + +SELECT JSON_OBJECT('name':'value', 'type':JSON_ARRAY(1, 2)) + +SELECT JSON_OBJECT('name':'value', 'type':JSON_OBJECT('type_id':1, 'name':'a')) + +DECLARE @id_key nvarchar(10) = N'id',@id_value nvarchar(64) = NEWID(); +SELECT JSON_OBJECT('user_name':USER_NAME(), @id_key:@id_value, 'sid':(SELECT @@SPID)) + +SELECT s.session_id, JSON_OBJECT('security_id':s.security_id, 'login':s.login_name, 'status':s.status) as info +FROM sys.dm_exec_sessions AS s +WHERE s.is_user_process = 1; + +SELECT JSON_ARRAY(); + +SELECT JSON_ARRAY('a', 1, 'b', 2) + +SELECT JSON_ARRAY('a', 1, 'b', NULL) + +SELECT JSON_ARRAY('a', 1, NULL, 2 NULL ON NULL) + +SELECT JSON_ARRAY('a', JSON_OBJECT('name':'value', 'type':1), JSON_ARRAY(1, null, 2 NULL ON NULL)) + +DECLARE @id_value nvarchar(64) = NEWID(); +SELECT JSON_ARRAY(1, @id_value, (SELECT @@SPID)); + +SELECT s.session_id, JSON_ARRAY(s.host_name, s.program_name, s.client_interface_name) +FROM sys.dm_exec_sessions AS s +WHERE s.is_user_process = 1; + +SELECT FirstName, LastName, + JSON_VALUE(jsonInfo,'$.info.address.town') AS Town +FROM Person.Person +WHERE JSON_VALUE(jsonInfo,'$.info.address.state') LIKE 'US%' +ORDER BY JSON_VALUE(jsonInfo,'$.info.address.town') + +DECLARE @jsonInfo NVARCHAR(MAX) +DECLARE @town NVARCHAR(32) + +SET @jsonInfo=N'{"info":{"address":[{"town":"Paris"},{"town":"London"}]}}'; + +SET @town=JSON_VALUE(@jsonInfo,'$.info.address[0].town'); -- Paris +SET @town=JSON_VALUE(@jsonInfo,'$.info.address[1].town'); -- London + +CREATE TABLE dbo.Store + ( + StoreID INT IDENTITY(1,1) NOT NULL, + Address VARCHAR(500), + jsonContent NVARCHAR(4000), + Longitude AS JSON_VALUE(jsonContent, '$.address[0].longitude'), + Latitude AS JSON_VALUE(jsonContent, '$.address[0].latitude') + ) + + SELECT PersonID,FullName, + JSON_QUERY(CustomFields,'$.OtherLanguages') AS Languages +FROM Application.People + +SELECT StockItemID, StockItemName, + JSON_QUERY(Tags) as Tags, + JSON_QUERY(CONCAT('["',ValidFrom,'","',ValidTo,'"]')) ValidityPeriod +FROM Warehouse.StockItems +FOR JSON PATH + +DECLARE @info NVARCHAR(100)='{"name":"John","skills":["C#","SQL"]}' + +PRINT @info + +-- Update name + +SET @info=JSON_MODIFY(@info,'$.name','Mike') + +PRINT @info + +-- Insert surname + +SET @info=JSON_MODIFY(@info,'$.surname','Smith') + +PRINT @info + +-- Set name NULL + +SET @info=JSON_MODIFY(@info,'strict $.name',NULL) + +PRINT @info + +-- Delete name + +SET @info=JSON_MODIFY(@info,'$.name',NULL) + +PRINT @info + +-- Add skill + +SET @info=JSON_MODIFY(@info,'append $.skills','Azure') + +PRINT @info + +DECLARE @info NVARCHAR(100)='{"name":"John","skills":["C#","SQL"]}' + +PRINT @info + +-- Multiple updates + +SET @info=JSON_MODIFY(JSON_MODIFY(JSON_MODIFY(@info,'$.name','Mike'),'$.surname','Smith'),'append $.skills','Azure') + +PRINT @info + +DECLARE @product NVARCHAR(100)='{"price":49.99}' + +PRINT @product + +-- Rename property + +SET @product= + JSON_MODIFY( + JSON_MODIFY(@product,'$.Price',CAST(JSON_VALUE(@product,'$.price') AS NUMERIC(4,2))), + '$.price', + NULL + ) + +PRINT @product + +DECLARE @stats NVARCHAR(100)='{"click_count": 173}' + +PRINT @stats + +-- Increment value + +SET @stats=JSON_MODIFY(@stats,'$.click_count', + CAST(JSON_VALUE(@stats,'$.click_count') AS INT)+1) + +PRINT @stats + +DECLARE @info NVARCHAR(100)='{"name":"John","skills":["C#","SQL"]}' + +PRINT @info + +-- Update skills array + +SET @info=JSON_MODIFY(@info,'$.skills','["C#","T-SQL","Azure"]') + +PRINT @info + +DECLARE @info NVARCHAR(100)='{"name":"John","skills":["C#","SQL"]}' + +PRINT @info + +-- Update skills array + +SET @info=JSON_MODIFY(@info,'$.skills',JSON_QUERY('["C#","T-SQL","Azure"]')) + +PRINT @info + +UPDATE Employee +SET jsonCol=JSON_MODIFY(jsonCol,'$.info.address.town','London') +WHERE EmployeeID=17 + +DECLARE @jsonInfo NVARCHAR(MAX) + +SET @jsonInfo=N'{"info":{"address":[{"town":"Paris"},{"town":"London"}]}}'; + +SELECT JSON_PATH_EXISTS(@jsonInfo,'$.info.address'); -- 1 + +DECLARE @jsonInfo NVARCHAR(MAX) + +SET @jsonInfo=N'{"info":{"address":[{"town":"Paris"},{"town":"London"}]}}'; + +SELECT JSON_PATH_EXISTS(@jsonInfo,'$.info.addresses'); -- 0 diff --git a/tsql/examples/built_in_functions_logical.sql b/tsql/examples/built_in_functions_logical.sql new file mode 100644 index 0000000..e6be38f --- /dev/null +++ b/tsql/examples/built_in_functions_logical.sql @@ -0,0 +1,89 @@ +SELECT GREATEST ( '6.62', 3.1415, N'7' ) AS GreatestVal; +GO + +SELECT GREATEST ('Glacier', N'Joshua Tree', 'Mount Rainier') AS GreatestString; +GO + +SELECT P.Name, P.SellStartDate, P.DiscontinuedDate, PM.ModifiedDate AS ModelModifiedDate + , GREATEST(P.SellStartDate, P.DiscontinuedDate, PM.ModifiedDate) AS LatestDate +FROM SalesLT.Product AS P +INNER JOIN SalesLT.ProductModel AS PM on P.ProductModelID = PM.ProductModelID +WHERE GREATEST(P.SellStartDate, P.DiscontinuedDate, PM.ModifiedDate) >='2007-01-01' +AND P.SellStartDate >='2007-01-01' +AND P.Name LIKE 'Touring %' +ORDER BY P.Name; + +CREATE TABLE dbo.studies ( + VarX varchar(10) NOT NULL, + Correlation decimal(4, 3) NULL +); + +INSERT INTO dbo.studies VALUES ('Var1', 0.2), ('Var2', 0.825), ('Var3', 0.61); +GO + +DECLARE @PredictionA DECIMAL(2,1) = 0.7; +DECLARE @PredictionB DECIMAL(3,1) = 0.65; + +SELECT VarX, Correlation +FROM dbo.studies +WHERE Correlation > GREATEST(@PredictionA, @PredictionB); +GO + +CREATE TABLE dbo.studies ( + VarX varchar(10) NOT NULL, + Correlation decimal(4, 3) NULL +); + +INSERT INTO dbo.studies VALUES ('Var1', 0.2), ('Var2', 0.825), ('Var3', 0.61); +GO + +DECLARE @VarX decimal(4, 3) = 0.59; + +SELECT VarX, Correlation, GREATEST(Correlation, 0, @VarX) AS GreatestVar +FROM dbo.studies; +GO + +SELECT LEAST ( '6.62', 3.1415, N'7' ) AS LeastVal; +GO + +SELECT LEAST ('Glacier', N'Joshua Tree', 'Mount Rainier') AS LeastString; +GO + +SELECT P.Name, P.SellStartDate, P.DiscontinuedDate, PM.ModifiedDate AS ModelModifiedDate + , LEAST(P.SellStartDate, P.DiscontinuedDate, PM.ModifiedDate) AS EarliestDate +FROM SalesLT.Product AS P +INNER JOIN SalesLT.ProductModel AS PM on P.ProductModelID = PM.ProductModelID +WHERE LEAST(P.SellStartDate, P.DiscontinuedDate, PM.ModifiedDate) >='2007-01-01' +AND P.SellStartDate >='2007-01-01' +AND P.Name LIKE 'Touring %' +ORDER BY P.Name; + +CREATE TABLE dbo.studies ( + VarX varchar(10) NOT NULL, + Correlation decimal(4, 3) NULL +); + +INSERT INTO dbo.studies VALUES ('Var1', 0.2), ('Var2', 0.825), ('Var3', 0.61); +GO + +DECLARE @PredictionA DECIMAL(2,1) = 0.7; +DECLARE @PredictionB DECIMAL(3,1) = 0.65; + +SELECT VarX, Correlation +FROM dbo.studies +WHERE Correlation < LEAST(@PredictionA, @PredictionB); +GO + +CREATE TABLE dbo.studies ( + VarX varchar(10) NOT NULL, + Correlation decimal(4, 3) NULL +); + +INSERT INTO dbo.studies VALUES ('Var1', 0.2), ('Var2', 0.825), ('Var3', 0.61); +GO + +DECLARE @VarX decimal(4, 3) = 0.59; + +SELECT VarX, Correlation, LEAST(Correlation, 1.0, @VarX) AS LeastVar +FROM dbo.studies; +GO diff --git a/tsql/examples/built_in_functions_math.sql b/tsql/examples/built_in_functions_math.sql new file mode 100644 index 0000000..b3834d3 --- /dev/null +++ b/tsql/examples/built_in_functions_math.sql @@ -0,0 +1,201 @@ +GO +-- ABS +SELECT ABS(-1.0), ABS(0.0), ABS(1.0); + +DECLARE @i INT; +SET @i = -2147483648; +SELECT ABS(@i); + +GO +-- ACOS +SELECT ACOS(-1.0); + +DECLARE @cos FLOAT; +SET @cos = -1.0; +SELECT ACOS(@cos); + +GO +-- ASIN +SELECT ASIN(-1.0); + +DECLARE @angle FLOAT +SET @angle = -1.00 +SELECT ASIN(@angle); + +GO +-- ATAN +SELECT ATAN(-1.0); + +DECLARE @atan FLOAT +SET @atan = -1.00 +SELECT ATAN(@atan); + +GO +-- ATN2 +SELECT ATN2(35.175643, 129.44); + +DECLARE @atn2y FLOAT = 35.175643, @atn2x FLOAT = 129.44; +SELECT ATN2(@atn2y, @atn2x); + +GO +-- CEILING +SELECT CEILING(-1.0); + +DECLARE @ceiling FLOAT +SET @ceiling = -1.00 +SELECT CEILING(@ceiling); + +GO +-- COS +SELECT COS(14.78); + +DECLARE @cos FLOAT +SET @cos = 14.78 +SELECT COS(@cos); + +SELECT COS(14.78); + +DECLARE @cos FLOAT +SET @cos = 14.78 +SELECT COS(@cos); + +GO +-- COT +SELECT COT(12.1); + +DECLARE @cot FLOAT +SET @cot = 12.1 +SELECT COT(@cot); + +GO +-- DEGREES +SELECT DEGREES(3.14159265359); + +DECLARE @degrees FLOAT +SET @degrees = 3.14159265359 +SELECT DEGREES(@degrees); + +GO +-- EXP +SELECT EXP(10); + +DECLARE @exp FLOAT +SET @exp = 10 +SELECT EXP(@degrees); + +GO +-- FLOOR +SELECT FLOOR(123.45); + +DECLARE @floor FLOAT +SET @floor = 123.45 +SELECT FLOOR(@degrees); + +GO +-- LOG +SELECT LOG(10); +SELECT LOG(10, 2); + +DECLARE @log FLOAT +DECLARE @base INT +SET @log = 10 +SET @base = 2 +SELECT LOG(@log); +SELECT LOG(@log, @base); + +GO +-- LOG10 +SELECT LOG10(3); + +DECLARE @log10 FLOAT +SET @log10 = 3 +SELECT LOG10(@log); + +GO +-- PI +SELECT PI(); + +GO +-- POWER +SELECT POWER(2, 3); + +DECLARE @powerX FLOAT +DECLARE @powerY FLOAT +SET @powerX = 2 +SET @powerY = 3 +SELECT POWER(@powerX, @powerY); + +GO +-- RADIANS +SELECT RADIANS(5.55555); + +DECLARE @radians FLOAT +SET @radians = 5.55555 +SELECT RADIANS(@radians); + +GO +-- RAND +SELECT RAND(); +SELECT RAND(5); + +DECLARE @seed FLOAT +SET @seed = 5 +SELECT RAND(@seed); + +GO +-- ROUND +SELECT ROUND(123.9994, 3); +SELECT ROUND(123.9994, 3, 5); + +DECLARE @round FLOAT +DECLARE @roundLength FLOAT +DECLARE @roundFunction FLOAT +SET @round = 123.9994 +SET @roundLength = 3 +SET @roundFunction = 5 +SELECT ROUND(@round, @roundLength); +SELECT ROUND(@round, @roundLength, @roundFunction); + +GO +-- SIGN +SELECT SIGN(5); + +DECLARE @sign INT +SET @sign = 5 +SELECT SIGN(@sign); + +GO +-- SIN +SELECT SIN(45.175643); + +DECLARE @sin FLOAT +SET @sin = 45.175643 +SELECT SIN(@sin); + +GO +-- SQRT +SELECT SQRT(9); + +DECLARE @sqrt FLOAT +SET @sqrt = 9 +SELECT SQRT(@sqrt); + +GO +-- SQUARE +SELECT SQUARE(5); + +DECLARE @square FLOAT +SET @square = 5 +SELECT SQUARE(@square); + +GO +-- TAN +SELECT TAN(0.45); + +DECLARE @tan FLOAT +SET @tan = 5 +SELECT TAN(@tan); + + + + diff --git a/tsql/examples/built_in_functions_metadata.sql b/tsql/examples/built_in_functions_metadata.sql new file mode 100644 index 0000000..eaeb29a --- /dev/null +++ b/tsql/examples/built_in_functions_metadata.sql @@ -0,0 +1,529 @@ +USE AdventureWorks2012; +GO +IF APP_NAME() = 'Microsoft SQL Server Management Studio - Query' +PRINT 'This process was started by ' + APP_NAME() + '. The date is ' + CONVERT ( VARCHAR(100) , GETDATE(), 101) + '.'; +ELSE +PRINT 'This process was started by ' + APP_NAME() + '. The date is ' + CONVERT ( VARCHAR(100) , GETDATE(), 102) + '.'; +GO + +USE AdventureWorks2012; +GO +BEGIN TRAN; +DECLARE @result INT; +EXEC @result=sp_getapplock + @DbPrincipal='public', + @Resource='Form1', + @LockMode='Shared', + @LockOwner='Transaction'; +SELECT APPLOCK_MODE('public', 'Form1', 'Transaction'); +GO + +Use AdventureWorks2012; +GO +BEGIN TRAN; +SELECT APPLOCK_MODE('public', 'Form1', 'Transaction'); +--Result set: NoLock + +SELECT APPLOCK_TEST('public', 'Form1', 'Shared', 'Transaction'); +--Result set: 1 (Lock is grantable.) + +SELECT APPLOCK_TEST('public', 'Form1', 'Exclusive', 'Transaction'); +--Result set: 0 (Lock is not grantable.) +GO + +EXEC sp_releaseapplock @Resource='Form1', @DbPrincipal='public'; +GO + +SELECT APPLOCK_TEST('public', 'Form1', 'Exclusive', 'Transaction'); +--Result set: '1' (The lock is grantable.) +GO + +COMMIT TRAN; +GO + +USE AdventureWorks2012; +GO +SELECT ASSEMBLYPROPERTY ('HelloWorld' , 'PublicKey'); + +USE AdventureWorks2012; +GO +CREATE TABLE t1(c1 VARCHAR(40), c2 NVARCHAR(40) ); +GO +SELECT COL_LENGTH('t1','c1')AS 'VarChar', + COL_LENGTH('t1','c2')AS 'NVarChar'; +GO +DROP TABLE t1; + +-- Uses AdventureWorks + +SELECT COL_NAME(OBJECT_ID('dbo.FactResellerSales'), 1) AS FirstColumnName, +COL_NAME(OBJECT_ID('dbo.FactResellerSales'), 2) AS SecondColumnName; + +USE AdventureWorks2012; +GO +SELECT COLUMNPROPERTY( OBJECT_ID('Person.Person'),'LastName','PRECISION')AS 'Column Length'; +GO + +SELECT DATABASEPROPERTYEX('AdventureWorks2014', 'IsAutoShrink'); + +SELECT + DATABASEPROPERTYEX('AdventureWorks2014', 'Collation') AS Collation, + DATABASEPROPERTYEX('AdventureWorks2014', 'Edition') AS Edition, + DATABASEPROPERTYEX('AdventureWorks2014', 'ServiceObjective') AS ServiceObjective, + DATABASEPROPERTYEX('AdventureWorks2014', 'MaxSizeInBytes') AS MaxSizeInBytes + +SELECT DATABASEPROPERTYEX(DB_NAME(), 'Updateability'); + +SELECT DB_ID() AS [Database ID]; +GO + +SELECT DB_ID(N'AdventureWorks2008R2') AS [Database ID]; +GO + +DECLARE @db_id INT; +DECLARE @object_id INT; +SET @db_id = DB_ID(N'AdventureWorks2012'); +SET @object_id = OBJECT_ID(N'AdventureWorks2012.Person.Address'); +IF @db_id IS NULL + BEGIN; + PRINT N'Invalid database'; + END; +ELSE IF @object_id IS NULL + BEGIN; + PRINT N'Invalid object'; + END; +ELSE + BEGIN; + SELECT * FROM sys.dm_db_index_operational_stats(@db_id, @object_id, NULL, NULL); + END; +GO + +SELECT DB_ID(); + +SELECT DB_ID('AdventureWorksPDW2012'); + +SELECT DB_NAME() AS [Current Database]; +GO + +USE master; +GO +SELECT DB_NAME(3) AS [Database Name]; +GO + +SELECT DB_NAME(database_id) AS [Database], database_id +FROM sys.databases; + +USE AdventureWorks2012; +GO +SELECT FILE_ID('AdventureWorks2012_Data')AS 'File ID'; +GO + +USE AdventureWorks2012; +GO +SELECT FILE_IDEX('AdventureWorks2012_Data') AS 'File ID'; +GO + +USE AdventureWorks2012; +GO +SELECT FILE_IDEX((SELECT TOP (1) name FROM sys.database_files WHERE type = 1)) AS 'File ID'; +GO + +SELECT FILE_IDEX((SELECT name FROM sys.master_files WHERE type = 4)) +AS 'File_ID'; + +SELECT FILE_NAME(1) AS 'File Name 1', FILE_NAME(2) AS 'File Name 2'; +GO + +SELECT FILEGROUP_ID('PRIMARY') AS [Filegroup ID]; +GO + +SELECT FILEGROUP_NAME(1) AS [Filegroup Name]; +GO + +SELECT FILEGROUPPROPERTY('PRIMARY', 'IsDefault') AS 'Default Filegroup'; +GO + +SELECT FILEPROPERTY('AdventureWorks2012_Data', 'IsPrimaryFile')AS [Primary File]; +GO + +SELECT s.file_id, + s.type_desc, + s.name, + FILEPROPERTYEX(s.name, 'BlobTier') AS BlobTier, + FILEPROPERTYEX(s.name, 'AccountType') AS AccountType, + FILEPROPERTYEX(s.name, 'IsInferredTier') AS IsInferredTier, + FILEPROPERTYEX(s.name, 'IsPageBlob') AS IsPageBlob +FROM sys.database_files AS s +WHERE s.type_desc IN ('ROWS', 'LOG'); + +USE AdventureWorks2012; +GO +SELECT fulltextcatalogproperty('Cat_Desc', 'ItemCount'); +GO + +SELECT fulltextserviceproperty('VerifySignature'); + +USE AdventureWorks2012; +GO +SELECT + INDEX_COL (N'AdventureWorks2012.Sales.SalesOrderDetail', 1,1) AS + [Index Column 1], + INDEX_COL (N'AdventureWorks2012.Sales.SalesOrderDetail', 1,2) AS + [Index Column 2] +; +GO + +USE AdventureWorks2012; +GO +SELECT + INDEXKEY_PROPERTY(OBJECT_ID('Production.Location', 'U'), + 1,1,'ColumnId') AS [Column ID], + INDEXKEY_PROPERTY(OBJECT_ID('Production.Location', 'U'), + 1,1,'IsDescending') AS [Asc or Desc order]; + +SELECT + INDEXPROPERTY(OBJECT_ID('HumanResources.Employee'), + 'PK_Employee_BusinessEntityID','IsClustered')AS [Is Clustered], + INDEXPROPERTY(OBJECT_ID('HumanResources.Employee'), + 'PK_Employee_BusinessEntityID','IndexDepth') AS [Index Depth], + INDEXPROPERTY(OBJECT_ID('HumanResources.Employee'), + 'PK_Employee_BusinessEntityID','IndexFillFactor') AS [Fill Factor]; + +-- Uses AdventureWorks + +SELECT +INDEXPROPERTY(OBJECT_ID('dbo.FactResellerSales'), + 'ClusteredIndex_6d10fa223e5e4c1fbba087e29e16a7a2','IsClustered') AS [Is Clustered], +INDEXPROPERTY(OBJECT_ID('dbo.FactResellerSales'), + 'ClusteredIndex_6d10fa223e5e4c1fbba087e29e16a7a2','IsColumnstore') AS [Is Columnstore Index], +INDEXPROPERTY(OBJECT_ID('dbo.FactResellerSales'), + 'ClusteredIndex_6d10fa223e5e4c1fbba087e29e16a7a2','IndexFillFactor') AS [Fill Factor]; +GO + +USE AdventureWorks2012; +GO +SELECT OBJECT_DEFINITION (OBJECT_ID(N'Person.uAddress')) AS [Trigger Definition]; +GO + +USE AdventureWorks2012; +GO +SELECT OBJECT_DEFINITION (OBJECT_ID(N'sys.sp_columns')) AS [Object Definition]; +GO + +USE master; +GO +SELECT OBJECT_ID(N'AdventureWorks2012.Production.WorkOrder') AS 'Object ID'; +GO + +USE AdventureWorks2012; +GO +IF OBJECT_ID (N'dbo.AWBuildVersion', N'U') IS NOT NULL +DROP TABLE dbo.AWBuildVersion; +GO + +DECLARE @db_id INT; +DECLARE @object_id INT; +SET @db_id = DB_ID(N'AdventureWorks2012'); +SET @object_id = OBJECT_ID(N'AdventureWorks2012.Person.Address'); +IF @db_id IS NULL + BEGIN; + PRINT N'Invalid database'; + END; +ELSE IF @object_id IS NULL + BEGIN; + PRINT N'Invalid object'; + END; +ELSE + BEGIN; + SELECT * FROM sys.dm_db_index_operational_stats(@db_id, @object_id, NULL, NULL); + END; +GO + +SELECT OBJECT_ID('AdventureWorksPDW2012.dbo.FactFinance') AS 'Object ID'; + +USE AdventureWorks2012; +GO +SELECT DISTINCT OBJECT_NAME(object_id) +FROM master.sys.objects; +GO + +USE AdventureWorks2012; +GO +SELECT DISTINCT OBJECT_SCHEMA_NAME(object_id, 1) AS schema_name +FROM master.sys.objects; +GO + +USE AdventureWorks2012; +GO +DECLARE @MyID INT; +SET @MyID = (SELECT OBJECT_ID('AdventureWorks2012.Production.Product', + 'U')); +SELECT name, object_id, type_desc +FROM sys.objects +WHERE name = OBJECT_NAME(@MyID); +GO + +SELECT DB_NAME(st.dbid) AS database_name, + OBJECT_SCHEMA_NAME(st.objectid, st.dbid) AS schema_name, + OBJECT_NAME(st.objectid, st.dbid) AS object_name, + st.text AS query_text +FROM sys.dm_exec_query_stats AS qs +CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) AS st +WHERE st.objectid IS NOT NULL; +GO + +SELECT QUOTENAME(DB_NAME(database_id)) + + N'.' + + QUOTENAME(OBJECT_SCHEMA_NAME(object_id, database_id)) + + N'.' + + QUOTENAME(OBJECT_NAME(object_id, database_id)) + , * +FROM sys.dm_db_index_operational_stats(NULL, NULL, NULL, NULL); +GO + +SELECT name, object_id, type_desc +FROM sys.objects +WHERE name = OBJECT_NAME(274100017); + +USE master; +GO +SELECT OBJECTPROPERTY(OBJECT_ID(N'AdventureWorks2012.HumanResources.vEmployee'), 'IsView'); +GO + +USE AdventureWorks2012; +GO +IF OBJECTPROPERTY (OBJECT_ID(N'Production.UnitMeasure'),'ISTABLE') = 1 + PRINT 'UnitMeasure is a table.' +ELSE IF OBJECTPROPERTY (OBJECT_ID(N'Production.UnitMeasure'),'ISTABLE') = 0 + PRINT 'UnitMeasure is not a table.' +ELSE IF OBJECTPROPERTY (OBJECT_ID(N'Production.UnitMeasure'),'ISTABLE') IS NULL + PRINT 'ERROR: UnitMeasure is not a valid object.'; +GO + +USE AdventureWorks2012; +GO +SELECT OBJECTPROPERTY(OBJECT_ID('dbo.ufnGetProductDealerPrice'), 'IsDeterministic'); +GO + +-- Uses AdventureWorks + +SELECT name, object_id, type_desc +FROM sys.objects +WHERE OBJECTPROPERTY(object_id, N'SchemaId') = SCHEMA_ID(N'dbo') +ORDER BY type_desc, name; +GO + +-- Uses AdventureWorks + +IF OBJECTPROPERTY (OBJECT_ID(N'dbo.DimReseller'),'ISTABLE') = 1 + SELECT 'DimReseller is a table.' +ELSE + SELECT 'DimReseller is not a table.'; +GO + +USE master; +GO +SELECT OBJECTPROPERTYEX(OBJECT_ID(N'AdventureWorks2012.HumanResources.vEmployee'), 'IsView'); +GO + +USE AdventureWorks2012; +GO +CREATE SYNONYM MyEmployeeTable FOR HumanResources.Employee; +GO +SELECT OBJECTPROPERTYEX ( object_id(N'MyEmployeeTable'), N'BaseType')AS [Base Type]; +GO + +USE AdventureWorks2012; +GO +SELECT OBJECTPROPERTYEX(OBJECT_ID(N'HumanResources.Employee'), N'TABLEUPDATETRIGGERCOUNT'); +GO + +USE AdventureWorks2012; +GO +SELECT name, object_id, schema_id, type_desc +FROM sys.objects +WHERE OBJECTPROPERTYEX(object_id, N'TableHasForeignKey') = 1 +ORDER BY name; +GO + +-- Uses AdventureWorks + +SELECT OBJECTPROPERTYEX ( object_id(N'dbo.DimReseller'), N'BaseType')AS BaseType; + +-- Uses AdventureWorks + +SELECT PARSENAME('AdventureWorksPDW2012.dbo.DimCustomer', 1) AS 'Object Name'; +SELECT PARSENAME('AdventureWorksPDW2012.dbo.DimCustomer', 2) AS 'Schema Name'; +SELECT PARSENAME('AdventureWorksPDW2012.dbo.DimCustomer', 3) AS 'Database Name'; +SELECT PARSENAME('AdventureWorksPDW2012.dbo.DimCustomer', 4) AS 'Server Name'; +GO + +SELECT SCHEMA_ID(); + +SELECT SCHEMA_ID('dbo'); + +SELECT SCHEMA_NAME(); + +SELECT SCHEMA_NAME(1); + +USE tempdb; +GO +CREATE TABLE TZ ( + Z_id INT IDENTITY(1,1)PRIMARY KEY, + Z_name VARCHAR(20) NOT NULL); + +INSERT TZ + VALUES ('Lisa'),('Mike'),('Carla'); + +SELECT * FROM TZ; + +CREATE TABLE TY ( + Y_id INT IDENTITY(100,5)PRIMARY KEY, + Y_name VARCHAR(20) NULL); + +INSERT TY (Y_name) + VALUES ('boathouse'), ('rocks'), ('elevator'); + +SELECT * FROM TY; +GO + +CREATE TRIGGER Ztrig +ON TZ +FOR INSERT AS + BEGIN + INSERT TY VALUES ('') + END; +GO + +INSERT TZ VALUES ('Rosalie'); + +SELECT SCOPE_IDENTITY() AS [SCOPE_IDENTITY]; +GO +SELECT @@IDENTITY AS [@@IDENTITY]; +GO + +USE AdventureWorks2012; +GO +INSERT INTO Person.ContactType ([Name]) VALUES ('Assistant to the Manager'); +GO +SELECT SCOPE_IDENTITY() AS [SCOPE_IDENTITY]; +GO +SELECT @@IDENTITY AS [@@IDENTITY]; +GO + +INSERT INTO Sales.Customer ([TerritoryID],[PersonID]) VALUES (8,NULL); +GO +SELECT SCOPE_IDENTITY() AS [SCOPE_IDENTITY]; +GO +SELECT @@IDENTITY AS [@@IDENTITY]; +GO + +SELECT + SERVERPROPERTY('MachineName') AS ComputerName, + SERVERPROPERTY('ServerName') AS InstanceName, + SERVERPROPERTY('Edition') AS Edition, + SERVERPROPERTY('ProductVersion') AS ProductVersion, + SERVERPROPERTY('ProductLevel') AS ProductLevel; +GO + +USE AdventureWorks2012; +GO +SELECT name AS stats_name, + STATS_DATE(object_id, stats_id) AS statistics_update_date +FROM sys.stats +WHERE object_id = OBJECT_ID('Person.Address'); +GO + +USE AdventureWorks2012; +GO +SELECT name AS index_name, + STATS_DATE(object_id, index_id) AS statistics_update_date +FROM sys.indexes +WHERE object_id = OBJECT_ID('Person.Address'); +GO + +--First, create a statistics object +USE AdventureWorksPDW2012; +GO +CREATE STATISTICS Customer_LastName_Stats +ON AdventureWorksPDW2012.dbo.DimCustomer (LastName) +WITH SAMPLE 50 PERCENT; +GO + +--Return the date when Customer_LastName_Stats was last updated +USE AdventureWorksPDW2012; +GO +SELECT stats_id, name AS stats_name, + STATS_DATE(object_id, stats_id) AS statistics_date +FROM sys.stats s +WHERE s.object_id = OBJECT_ID('dbo.DimCustomer') + AND s.name = 'Customer_LastName_Stats'; +GO + +--Update Customer_LastName_Stats so it will have a different timestamp in the next query +GO +UPDATE STATISTICS dbo.dimCustomer (Customer_LastName_Stats); + +--Return the date when Customer_LastName_Stats was last updated. +SELECT stats_id, name AS stats_name, + STATS_DATE(object_id, stats_id) AS statistics_date +FROM sys.stats s +WHERE s.object_id = OBJECT_ID('dbo.DimCustomer') + AND s.name = 'Customer_LastName_Stats'; +GO + +--Return the dates all statistics on the table were last updated. +SELECT stats_id, name AS stats_name, + STATS_DATE(object_id, stats_id) AS statistics_date +FROM sys.stats s +WHERE s.object_id = OBJECT_ID('dbo.DimCustomer'); +GO + +USE AdventureWorksPDW2012; +GO +SELECT name AS index_name, + STATS_DATE(object_id, index_id) AS statistics_update_date +FROM sys.indexes +WHERE object_id = OBJECT_ID('dbo.DimCustomer'); +GO + +/* +-- Full example can be uncommented when create type grammar is fixed. +USE tempdb; +GO +CREATE TYPE NewType FROM int; +GO +CREATE SCHEMA NewSchema; +GO +CREATE TYPE NewSchema.NewType FROM int; +GO +*/ +SELECT TYPE_ID('NewType') AS [1 Part Data Type ID], + TYPE_ID('NewSchema.NewType') AS [2 Part Data Type ID]; +GO + +SELECT TYPE_NAME(TYPE_ID('datetime')) AS [TYPE_NAME] + ,TYPE_ID('datetime') AS [TYPE_ID]; +GO + +SELECT TYPE_NAME(TYPE_ID('datetime')) AS typeName, + TYPE_ID('datetime') AS typeID FROM table1; + +SELECT o.name AS obj_name, c.name AS col_name, + TYPE_NAME(c.user_type_id) AS type_name +FROM sys.objects AS o +JOIN sys.columns AS c ON o.object_id = c.object_id +WHERE o.name = 'Vendor' +ORDER BY col_name; +GO + +SELECT TYPE_NAME(36) AS Type36, TYPE_NAME(239) AS Type239; +GO + +SELECT * FROM sys.types; +GO + +SELECT TYPEPROPERTY(SCHEMA_NAME(schema_id) + '.' + name, 'OwnerId') AS owner_id, name, system_type_id, user_type_id, schema_id +FROM sys.types; + +SELECT TYPEPROPERTY( 'tinyint', 'PRECISION'); diff --git a/tsql/examples/built_in_functions_security.sql b/tsql/examples/built_in_functions_security.sql new file mode 100644 index 0000000..c609a76 --- /dev/null +++ b/tsql/examples/built_in_functions_security.sql @@ -0,0 +1,383 @@ +CREATE DATABASE TEST1; +GO +USE TEST1 +CREATE CERTIFICATE Shipping04 +ENCRYPTION BY PASSWORD = 'pGFD4bb925DGvbd2439587y' +WITH SUBJECT = 'Sammamish Shipping Records', +EXPIRY_DATE = '20401031'; +GO +SELECT CERTENCODED(CERT_ID('Shipping04')); +GO + +CREATE DATABASE TEST1; +GO +USE TEST1 +CREATE MASTER KEY ENCRYPTION BY PASSWORD = 'Use 5tr0ng P^55Words' +GO +CREATE CERTIFICATE Shipping04 +WITH SUBJECT = 'Sammamish Shipping Records', +EXPIRY_DATE = '20401031'; +GO +SELECT CERTPRIVATEKEY(CERT_ID('Shipping04'), 'jklalkaa/; uia3dd'); +GO + +SELECT CURRENT_USER; +GO + +USE AdventureWorks2012; +GO +IF EXISTS (SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES + WHERE TABLE_NAME = 'orders22') + DROP TABLE orders22; +GO +SET NOCOUNT ON; +CREATE TABLE orders22 +( +order_id int IDENTITY(1000, 1) NOT NULL, +cust_id int NOT NULL, +order_date smalldatetime NOT NULL DEFAULT GETDATE(), +order_amt money NOT NULL, +order_person char(30) NOT NULL DEFAULT CURRENT_USER +); +GO + +SELECT CURRENT_USER; +GO +EXECUTE AS USER = 'Arnalfo'; +GO +SELECT CURRENT_USER; +GO +REVERT; +GO +SELECT CURRENT_USER; +GO +EXECUTE AS CALLER +GO +SELECT CURRENT_USER; +GO + +SELECT DATABASE_PRINCIPAL_ID(); +GO + +SELECT DATABASE_PRINCIPAL_ID('db_owner'); +GO + +SELECT HAS_DBACCESS('AdventureWorks2012'); +GO + +SELECT HAS_DBACCESS('AdventureWorksPDW2012'); +GO + +SELECT HAS_PERMS_BY_NAME(null, null, 'VIEW SERVER STATE'); + +SELECT HAS_PERMS_BY_NAME('Ps', 'LOGIN', 'IMPERSONATE'); + +SELECT HAS_PERMS_BY_NAME(db_name(), 'DATABASE', 'ANY'); + +EXECUTE AS user = 'Pd' +GO +SELECT HAS_PERMS_BY_NAME(db_name(), 'DATABASE', 'ANY'); +GO +REVERT; +GO + +SELECT HAS_PERMS_BY_NAME(db_name(), 'DATABASE', 'CREATE PROCEDURE') + & HAS_PERMS_BY_NAME('S', 'SCHEMA', 'ALTER') AS _can_create_procs, + HAS_PERMS_BY_NAME(db_name(), 'DATABASE', 'CREATE TABLE') & + HAS_PERMS_BY_NAME('S', 'SCHEMA', 'ALTER') AS _can_create_tables; + +SELECT HAS_PERMS_BY_NAME +(QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(name), + 'OBJECT', 'SELECT') AS have_select, * FROM sys.tables + +SELECT HAS_PERMS_BY_NAME('Sales.SalesPerson', 'OBJECT', 'INSERT'); + +SELECT HAS_PERMS_BY_NAME('AdventureWorks2012.Sales.SalesPerson', + 'OBJECT', 'INSERT'); + +SELECT name AS column_name, + HAS_PERMS_BY_NAME('T', 'OBJECT', 'SELECT', name, 'COLUMN') + AS can_select + FROM sys.columns AS c + WHERE c.object_id=object_id('T'); + +-- Test membership in db_owner and print appropriate message. +IF IS_MEMBER ('db_owner') = 1 + PRINT 'Current user is a member of the db_owner role' +ELSE IF IS_MEMBER ('db_owner') = 0 + PRINT 'Current user is NOT a member of the db_owner role' +ELSE IF IS_MEMBER ('db_owner') IS NULL + PRINT 'ERROR: Invalid group / role specified'; +GO + +-- Execute SELECT if user is a member of ADVWORKS\Shipping. +IF IS_MEMBER ('ADVWORKS\Shipping') = 1 + SELECT 'User ' + USER + ' is a member of ADVWORKS\Shipping.'; +GO + +IF IS_ROLEMEMBER ('db_datareader') = 1 + print 'Current user is a member of the db_datareader role' +ELSE IF IS_ROLEMEMBER ('db_datareader') = 0 + print 'Current user is NOT a member of the db_datareader role' +ELSE IF IS_ROLEMEMBER ('db_datareader') IS NULL + print 'ERROR: The database role specified is not valid.'; + +IF IS_SRVROLEMEMBER ('sysadmin') = 1 + print 'Current user''s login is a member of the sysadmin role' +ELSE IF IS_SRVROLEMEMBER ('sysadmin') = 0 + print 'Current user''s login is NOT a member of the sysadmin role' +ELSE IF IS_SRVROLEMEMBER ('sysadmin') IS NULL + print 'ERROR: The server role specified is not valid.'; + +SELECT IS_SRVROLEMEMBER('diskadmin', 'Contoso\Pat'); + +SELECT LOGINPROPERTY('John3', 'IsMustChange'); +GO + +SELECT LOGINPROPERTY('John3', 'IsLocked'); +GO + +USE AdventureWorks2012; +GO +--Create a temporary login and user. +CREATE LOGIN login1 WITH PASSWORD = 'J345#$)thb'; +CREATE USER user1 FOR LOGIN login1; +GO +--Execute a context switch to the temporary login account. +DECLARE @original_login sysname; +DECLARE @current_context sysname; +EXECUTE AS LOGIN = 'login1'; +SET @original_login = ORIGINAL_LOGIN(); +SET @current_context = SUSER_SNAME(); +SELECT 'The current executing context is: '+ @current_context; +SELECT 'The original login in this session was: '+ @original_login +GO +-- Return to the original execution context +-- and remove the temporary principal. +REVERT; +GO +DROP LOGIN login1; +DROP USER user1; +GO + +IF PERMISSIONS()&2=2 + CREATE TABLE test_table (col1 INT) +ELSE + PRINT 'ERROR: The current user cannot create a table.'; + +IF PERMISSIONS(OBJECT_ID('AdventureWorks2012.Person.Address','U'))&8=8 + PRINT 'The current user can insert data into Person.Address.' +ELSE + PRINT 'ERROR: The current user cannot insert data into Person.Address.'; + +IF PERMISSIONS(OBJECT_ID('AdventureWorks2012.Person.Address','U'))&0x80000=0x80000 + PRINT 'INSERT on Person.Address is grantable.' +ELSE + PRINT 'You may not GRANT INSERT permissions on Person.Address.'; + +SELECT PWDENCRYPT('password'); + +SELECT name FROM sys.sql_logins +WHERE PWDCOMPARE('', password_hash) = 1 ; + +SELECT name FROM sys.sql_logins +WHERE PWDCOMPARE('password', password_hash) = 1 ; + +DECLARE @session_usr NCHAR(30); +SET @session_usr = SESSION_USER; +SELECT 'This session''s current user is: '+ @session_usr; +GO + +USE AdventureWorks2012; +GO +CREATE TABLE deliveries3 +( + order_id INT IDENTITY(5000, 1) NOT NULL, + cust_id INT NOT NULL, + order_date SMALLDATETIME NOT NULL DEFAULT GETDATE(), + delivery_date SMALLDATETIME NOT NULL DEFAULT + DATEADD(dd, 10, GETDATE()), + received_shipment NCHAR(30) NOT NULL DEFAULT SESSION_USER +); +GO + +EXECUTE AS USER = 'Wanida' +INSERT deliveries3 (cust_id) +VALUES (7510); +INSERT deliveries3 (cust_id) +VALUES (7231); +REVERT; +EXECUTE AS USER = 'Sylvester' +INSERT deliveries3 (cust_id) +VALUES (7028); +REVERT; +EXECUTE AS USER = 'Alejandro' +INSERT deliveries3 (cust_id) +VALUES (7392); +INSERT deliveries3 (cust_id) +VALUES (7452); +REVERT; +GO + +SELECT order_id AS 'Order #', cust_id AS 'Customer #', + delivery_date AS 'When Delivered', received_shipment + AS 'Received By' +FROM deliveries3 +ORDER BY order_id; +GO + +SELECT SESSION_USER; + +SELECT SESSIONPROPERTY ('CONCAT_NULL_YIELDS_NULL') + +SELECT SUSER_ID('sa'); + +SELECT SUSER_NAME(1); + +SELECT SUSER_SID(); + +SELECT SUSER_SID('sa'); +GO + +SELECT SUSER_SID('London\Workstation1'); +GO + +USE AdventureWorks2012; +GO +CREATE TABLE sid_example +( +login_sid VARBINARY(85) DEFAULT SUSER_SID(), +login_name VARCHAR(30) DEFAULT SYSTEM_USER, +login_dept VARCHAR(10) DEFAULT 'SALES', +login_date DATETIME DEFAULT GETDATE() +); +GO +INSERT sid_example DEFAULT VALUES; +GO + +SELECT SUSER_SNAME(SUSER_SID('TestComputer\User', 0)); + +SELECT SUSER_SNAME(); +GO + +SELECT SUSER_SNAME(0x010500000000000515000000a065cf7e784b9b5fe77c87705a2e0000); +GO + +USE AdventureWorks2019; +GO + +CREATE TABLE sname_example ( + login_sname SYSNAME DEFAULT SUSER_SNAME(), + employee_id UNIQUEIDENTIFIER DEFAULT NEWID(), + login_date DATETIME DEFAULT GETDATE() + ); +GO + +INSERT sname_example DEFAULT +VALUES; +GO + +SELECT SUSER_SNAME(); +GO + +EXECUTE AS LOGIN = 'WanidaBenShoof'; +SELECT SUSER_SNAME(); + +REVERT; +GO + +SELECT SUSER_SNAME(); +GO + +SELECT SUSER_SNAME(0x01); +GO + +SELECT SUSER_SNAME() AS CurrentLogin; +GO + +DECLARE @sys_usr CHAR(30); +SET @sys_usr = SYSTEM_USER; +SELECT 'The current system user is: '+ @sys_usr; +GO + +USE AdventureWorks2012; +GO +CREATE TABLE Sales.Sales_Tracking +( + Territory_id INT IDENTITY(2000, 1) NOT NULL, + Rep_id INT NOT NULL, + Last_sale DATETIME NOT NULL DEFAULT GETDATE(), + SRep_tracking_user VARCHAR(30) NOT NULL DEFAULT SYSTEM_USER +); +GO +INSERT Sales.Sales_Tracking (Rep_id) +VALUES (151); +INSERT Sales.Sales_Tracking (Rep_id, Last_sale) +VALUES (293, '19980515'); +INSERT Sales.Sales_Tracking (Rep_id, Last_sale) +VALUES (27882, '19980620'); +INSERT Sales.Sales_Tracking (Rep_id) +VALUES (21392); +INSERT Sales.Sales_Tracking (Rep_id, Last_sale) +VALUES (24283, '19981130'); +GO + +SELECT SYSTEM_USER; + +DECLARE @usr CHAR(30) +SET @usr = user +SELECT 'The current user''s database username is: '+ @usr +GO + +USE AdventureWorks2012; +GO +CREATE TABLE inventory22 +( + part_id INT IDENTITY(100, 1) NOT NULL, + description VARCHAR(30) NOT NULL, + entry_person VARCHAR(30) NOT NULL DEFAULT USER +) +GO +INSERT inventory22 (description) +VALUES ('Red pencil') +INSERT inventory22 (description) +VALUES ('Blue pencil') +INSERT inventory22 (description) +VALUES ('Green pencil') +INSERT inventory22 (description) +VALUES ('Black pencil') +INSERT inventory22 (description) +VALUES ('Yellow pencil') +GO + +SELECT USER; +GO +EXECUTE AS USER = 'Mario'; +GO +SELECT USER; +GO +REVERT; +GO +SELECT USER; +GO + +USE AdventureWorks2012; +SELECT USER_ID('Harold'); +GO + +SELECT USER_NAME(13); +GO + +SELECT name FROM sysusers WHERE name = USER_NAME(1); +GO + +SELECT USER_NAME(); +GO +EXECUTE AS USER = 'Zelig'; +GO +SELECT USER_NAME(); +GO +REVERT; +GO +SELECT USER_NAME(); +GO diff --git a/tsql/examples/built_in_functions_string.sql b/tsql/examples/built_in_functions_string.sql new file mode 100644 index 0000000..7c45cdc --- /dev/null +++ b/tsql/examples/built_in_functions_string.sql @@ -0,0 +1,635 @@ +SELECT ASCII('A') AS A, ASCII('B') AS B, +ASCII('a') AS a, ASCII('b') AS b, +ASCII(1) AS [1], ASCII(2) AS [2]; + +SELECT ASCII('P') AS [ASCII], ASCII('æ') AS [Extended_ASCII]; + +SELECT NCHAR(80) AS [CHARACTER], NCHAR(195) AS [CHARACTER]; + +SELECT UNICODE('æ') AS [Extended_ASCII], NCHAR(230) AS [CHARACTER]; + +SET TEXTSIZE 0; +-- Create variables for the character string and for the current +-- position in the string. +DECLARE @position INT, @string CHAR(8); +-- Initialize the current position and the string variables. +SET @position = 1; +SET @string = 'New Moon'; +WHILE @position <= DATALENGTH(@string) + BEGIN + SELECT ASCII(SUBSTRING(@string, @position, 1)), + CHAR(ASCII(SUBSTRING(@string, @position, 1))) + SET @position = @position + 1 + END; +GO + +SELECT p.FirstName + ' ' + p.LastName, + CHAR(13) + pe.EmailAddress +FROM Person.Person p +INNER JOIN Person.EmailAddress pe ON p.BusinessEntityID = pe.BusinessEntityID + AND p.BusinessEntityID = 1; +GO + +SELECT CHAR(65) AS [65], CHAR(66) AS [66], +CHAR(97) AS [97], CHAR(98) AS [98], +CHAR(49) AS [49], CHAR(50) AS [50]; + +SELECT name, 'was created on ', create_date, CHAR(13), name, 'is currently ', state_desc +FROM sys.databases; +GO + +SELECT CHAR(188) AS single_byte_representing_complete_character, + CHAR(0xBC) AS single_byte_representing_complete_character; +GO + +SELECT CHAR(129) AS first_byte_of_double_byte_character, + CHAR(0x81) AS first_byte_of_double_byte_character; +GO + +CREATE DATABASE [multibyte-char-context] + COLLATE Japanese_CI_AI +GO +USE [multibyte-char-context] +GO +SELECT NCHAR(0x266A) AS [eighth-note] + , CONVERT(CHAR(2), 0x81F4) AS [context-dependent-convert] + , CAST(0x81F4 AS CHAR(2)) AS [context-dependent-cast] + +; WITH uni(c) AS ( + -- BMP character + SELECT NCHAR(9835) + UNION ALL + -- non-BMP supplementary character or, under downlevel collation, NULL + SELECT NCHAR(127925) + ), + enc(u16c, u8c) AS ( + SELECT c, CONVERT(VARCHAR(4), c COLLATE Latin1_General_100_CI_AI_SC_UTF8) + FROM uni + ) + SELECT u16c AS [Music note] + , u8c AS [Music note (UTF-8)] + , UNICODE(u16c) AS [Code Point] + , CONVERT(VARBINARY(4), u16c) AS [UTF-16LE bytes] + , CONVERT(VARBINARY(4), u8c) AS [UTF-8 bytes] + FROM enc + +DECLARE @document VARCHAR(64); +SELECT @document = 'Reflectors are vital safety' + + ' components of your bicycle.'; +SELECT CHARINDEX('bicycle', @document); +GO + +DECLARE @document VARCHAR(64); + +SELECT @document = 'Reflectors are vital safety' + + ' components of your bicycle.'; +SELECT CHARINDEX('vital', @document, 5); +GO + +DECLARE @document VARCHAR(64); + +SELECT @document = 'Reflectors are vital safety' + + ' components of your bicycle.'; +SELECT CHARINDEX('bike', @document); +GO + +USE tempdb; +GO +--perform a case sensitive search +SELECT CHARINDEX ( 'TEST', + 'This is a Test' + COLLATE Latin1_General_CS_AS); + +USE tempdb; +GO +SELECT CHARINDEX ( 'Test', + 'This is a Test' + COLLATE Latin1_General_CS_AS); + +USE tempdb; +GO +SELECT CHARINDEX ( 'TEST', + 'This is a Test' + COLLATE Latin1_General_CI_AS); +GO + +SELECT CHARINDEX('is', 'This is a string'); + +SELECT CHARINDEX('is', 'This is a string', 4); + +SELECT TOP(1) CHARINDEX('at', 'This is a string') FROM dbo.DimCustomer; + +SELECT CONCAT ( 'Happy ', 'Birthday ', 11, '/', '25' ) AS Result; + +CREATE TABLE #temp ( + emp_name NVARCHAR(200) NOT NULL, + emp_middlename NVARCHAR(200) NULL, + emp_lastname NVARCHAR(200) NOT NULL +); +INSERT INTO #temp VALUES( 'Name', NULL, 'Lastname' ); +SELECT CONCAT( emp_name, emp_middlename, emp_lastname ) AS Result +FROM #temp; + +SELECT CONCAT_WS( ' - ', database_id, recovery_model_desc, containment_desc) AS DatabaseInfo +FROM sys.databases; + +SELECT CONCAT_WS(',','1 Microsoft Way', NULL, NULL, 'Redmond', 'WA', 98052) AS Address; + +SELECT +STRING_AGG(CONCAT_WS( ',', database_id, recovery_model_desc, containment_desc), char(13)) AS DatabaseInfo +FROM sys.databases + +SELECT +STRING_AGG(CONCAT_WS( ',', database_id, ISNULL(recovery_model_desc,''), ISNULL(containment_desc,'N/A')), char(13)) AS DatabaseInfo +FROM sys.databases; + +-- Returns a DIFFERENCE value of 4, the least possible difference. +SELECT SOUNDEX('Green'), SOUNDEX('Greene'), DIFFERENCE('Green','Greene'); +GO +-- Returns a DIFFERENCE value of 0, the highest possible difference. +SELECT SOUNDEX('Blotchet-Halls'), SOUNDEX('Greene'), DIFFERENCE('Blotchet-Halls', 'Greene'); +GO + +DECLARE @d DATE = '11/22/2020'; +SELECT FORMAT( @d, 'd', 'en-US' ) 'US English' + ,FORMAT( @d, 'd', 'en-gb' ) 'Great Britain English' + ,FORMAT( @d, 'd', 'de-de' ) 'German' + ,FORMAT( @d, 'd', 'zh-cn' ) 'Chinese Simplified (PRC)'; + +SELECT FORMAT( @d, 'D', 'en-US' ) 'US English' + ,FORMAT( @d, 'D', 'en-gb' ) 'Great Britain English' + ,FORMAT( @d, 'D', 'de-de' ) 'German' + ,FORMAT( @d, 'D', 'zh-cn' ) 'Chinese Simplified (PRC)'; + +DECLARE @d DATE = GETDATE(); +SELECT FORMAT( @d, 'dd/MM/yyyy', 'en-US' ) AS 'Date' + ,FORMAT(123456789,'###-##-####') AS 'Custom Number'; + +SELECT TOP(5) CurrencyRateID, EndOfDayRate + ,FORMAT(EndOfDayRate, 'N', 'en-us') AS 'Numeric Format' + ,FORMAT(EndOfDayRate, 'G', 'en-us') AS 'General Format' + ,FORMAT(EndOfDayRate, 'C', 'en-us') AS 'Currency Format' +FROM Sales.CurrencyRate +ORDER BY CurrencyRateID; + +SELECT TOP(5) CurrencyRateID, EndOfDayRate + ,FORMAT(EndOfDayRate, 'N', 'de-de') AS 'Numeric Format' + ,FORMAT(EndOfDayRate, 'G', 'de-de') AS 'General Format' + ,FORMAT(EndOfDayRate, 'C', 'de-de') AS 'Currency Format' +FROM Sales.CurrencyRate +ORDER BY CurrencyRateID; + +SELECT FORMAT(cast('07:35' as time), N'hh.mm'); --> returns NULL +SELECT FORMAT(cast('07:35' as time), N'hh:mm'); --> returns NULL + +SELECT FORMAT(cast('07:35' as time), N'hh\.mm'); --> returns 07.35 +SELECT FORMAT(cast('07:35' as time), N'hh\:mm'); --> returns 07:35 + +SELECT FORMAT(SYSDATETIME(), N'hh:mm tt'); -- returns 03:46 PM +SELECT FORMAT(SYSDATETIME(), N'hh:mm t'); -- returns 03:46 P + +select FORMAT(CAST('2018-01-01 01:00' AS datetime2), N'hh:mm tt') -- returns 01:00 AM +select FORMAT(CAST('2018-01-01 01:00' AS datetime2), N'hh:mm t') -- returns 01:00 A + +select FORMAT(CAST('2018-01-01 14:00' AS datetime2), N'hh:mm tt') -- returns 02:00 PM +select FORMAT(CAST('2018-01-01 14:00' AS datetime2), N'hh:mm t') -- returns 02:00 P + +select FORMAT(CAST('2018-01-01 14:00' AS datetime2), N'HH:mm') -- returns 14:00 +SELECT LEFT(Name, 5) +FROM Production.Product +ORDER BY ProductID; +GO + +SELECT LEFT('abcdefg',2); +GO + +-- Uses AdventureWorks + +SELECT LEFT(EnglishProductName, 5) +FROM dbo.DimProduct +ORDER BY ProductKey; + +-- Uses AdventureWorks + +SELECT LEFT('abcdefg',2) FROM dbo.DimProduct; + +DECLARE @v1 VARCHAR(40), + @v2 NVARCHAR(40); +SELECT +@v1 = 'Test of 22 characters ', +@v2 = 'Test of 22 characters '; +SELECT LEN(@v1) AS [VARCHAR LEN] , DATALENGTH(@v1) AS [VARCHAR DATALENGTH]; +SELECT LEN(@v2) AS [NVARCHAR LEN], DATALENGTH(@v2) AS [NVARCHAR DATALENGTH]; + +SELECT LEN(FirstName) AS Length, FirstName, LastName +FROM Sales.vIndividualCustomer +WHERE CountryRegionName = 'Australia'; +GO + +USE AdventureWorks2016 +GO +SELECT DISTINCT LEN(FirstName) AS FNameLength, FirstName, LastName +FROM dbo.DimEmployee AS e +INNER JOIN dbo.DimGeography AS g + ON e.SalesTerritoryKey = g.SalesTerritoryKey +WHERE EnglishCountryRegionName = 'Australia'; + +-- Uses AdventureWorks + +SELECT LOWER(SUBSTRING(EnglishProductName, 1, 20)) AS Lower, + UPPER(SUBSTRING(EnglishProductName, 1, 20)) AS Upper, + LOWER(UPPER(SUBSTRING(EnglishProductName, 1, 20))) As LowerUpper +FROM dbo.DimProduct +WHERE ListPrice between 11.00 and 20.00; + +SELECT LTRIM(' Five spaces are at the beginning of this string.'); + +DECLARE @string_to_trim VARCHAR(60); +SET @string_to_trim = ' 5 spaces are at the beginning of this string.'; +SELECT + @string_to_trim AS 'Original string', + LTRIM(@string_to_trim) AS 'Without spaces'; +GO + +CREATE DATABASE test COLLATE Finnish_Swedish_100_CS_AS_SC; +DECLARE @d NVARCHAR(10) = N'𣅿'; +-- Old style method. +SELECT NCHAR(0xD84C) + NCHAR(0xDD7F); + +-- Preferred method. +SELECT NCHAR(143743); + +-- Alternative preferred method. +SELECT NCHAR(UNICODE(@d)); + +DECLARE @nstring NCHAR(8); +SET @nstring = N'København'; +SELECT UNICODE(SUBSTRING(@nstring, 2, 1)), + NCHAR(UNICODE(SUBSTRING(@nstring, 2, 1))); +GO + +-- The @position variable holds the position of the character currently +-- being processed. The @nstring variable is the Unicode character +-- string to process. +DECLARE @position INT, @nstring NCHAR(9); +-- Initialize the current position variable to the first character in +-- the string. +SET @position = 1; +-- Initialize the character string variable to the string to process. +-- Notice that there is an N before the start of the string. This +-- indicates that the data following the N is Unicode data. +SET @nstring = N'København'; +-- Print the character number of the position of the string you are at, +-- the actual Unicode character you are processing, and the UNICODE +-- value for this particular character. +PRINT 'Character #' + ' ' + 'Unicode Character' + ' ' + 'UNICODE Value'; +WHILE @position <= DATALENGTH(@nstring) + BEGIN + SELECT @position, + NCHAR(UNICODE(SUBSTRING(@nstring, @position, 1))), + CONVERT(NCHAR(17), SUBSTRING(@nstring, @position, 1)), + UNICODE(SUBSTRING(@nstring, @position, 1)) + SELECT @position = @position + 1 + END; +GO + +SELECT position = PATINDEX('%ter%', 'interesting data'); + +SELECT position = PATINDEX('%ensure%',DocumentSummary) +FROM Production.Document +WHERE DocumentNode = 0x7B40; +GO + +SELECT position = PATINDEX('%en_ure%', 'Please ensure the door is locked!'); + +SELECT position = PATINDEX('%[^ 0-9A-Za-z]%', 'Please ensure the door is locked!'); + +USE tempdb; +GO +SELECT PATINDEX ( '%ein%', 'Das ist ein Test' COLLATE Latin1_General_BIN) ; +GO + +DECLARE @MyValue VARCHAR(10) = 'safety'; +SELECT position = PATINDEX('%' + @MyValue + '%', DocumentSummary) +FROM Production.Document +WHERE DocumentNode = 0x7B40; + +SELECT QUOTENAME('abc[]def'); + +DECLARE @columnName NVARCHAR(255)='user''s "custom" name' +DECLARE @sql NVARCHAR(MAX) = 'SELECT FirstName AS ' + QUOTENAME(@columnName) + ' FROM dbo.DimCustomer' + +EXEC sp_executesql @sql + +SELECT QUOTENAME('abc def'); + +SELECT REPLACE('abcdefghicde','cde','xxx'); +GO + +SELECT REPLACE('This is a Test' COLLATE Latin1_General_BIN, +'Test', 'desk' ); +GO + +DECLARE @STR NVARCHAR(100), @LEN1 INT, @LEN2 INT; +SET @STR = N'This is a sentence with spaces in it.'; +SET @LEN1 = LEN(@STR); +SET @STR = REPLACE(@STR, N' ', N''); +SET @LEN2 = LEN(@STR); +SELECT N'Number of spaces in the string: ' + CONVERT(NVARCHAR(20), @LEN1 - @LEN2); + +GO + +SELECT [Name] +, REPLICATE('0', 4) + [ProductLine] AS 'Line Code' +FROM [Production].[Product] +WHERE [ProductLine] = 'T' +ORDER BY [Name]; +GO + +IF EXISTS(SELECT name FROM sys.tables + WHERE name = 't1') + DROP TABLE t1; +GO +CREATE TABLE t1 +( + c1 varchar(3), + c2 char(3) +); +GO +INSERT INTO t1 VALUES ('2', '2'), ('37', '37'),('597', '597'); +GO +SELECT REPLICATE('0', 3 - DATALENGTH(c1)) + c1 AS 'Varchar Column', + REPLICATE('0', 3 - DATALENGTH(c2)) + c2 AS 'Char Column' +FROM t1; +GO + +-- Uses AdventureWorks + +SELECT EnglishProductName AS Name, + ProductAlternateKey AS ItemCode, + REPLICATE('0', 4) + ProductAlternateKey AS FullItemCode +FROM dbo.DimProduct +ORDER BY Name; + +SELECT FirstName, REVERSE(FirstName) AS Reverse +FROM Person.Person +WHERE BusinessEntityID < 5 +ORDER BY FirstName; +GO + +DECLARE @myvar VARCHAR(10); +SET @myvar = 'sdrawkcaB'; +SELECT REVERSE(@myvar) AS Reversed ; +GO + +SELECT REVERSE(1234) AS Reversed ; +GO + +SELECT name, REVERSE(name) FROM sys.databases; +GO + +SELECT RIGHT(FirstName, 5) AS 'First Name' +FROM Person.Person +WHERE BusinessEntityID < 5 +ORDER BY FirstName; +GO + +-- Uses AdventureWorks + +SELECT RIGHT(LastName, 5) AS Name +FROM dbo.DimEmployee +ORDER BY EmployeeKey; + +SELECT RIGHT('abcdefg', 2); + +SELECT RTRIM('Removes trailing spaces. '); + +SELECT RTRIM('Four spaces are after the period in this sentence. ') + 'Next string.'; + +DECLARE @string_to_trim VARCHAR(60); +SET @string_to_trim = 'Four spaces are after the period in this sentence. '; +SELECT @string_to_trim + ' Next string.'; +SELECT RTRIM(@string_to_trim) + ' Next string.'; +GO + +-- Using SOUNDEX +SELECT SOUNDEX ('Smith'), SOUNDEX ('Smythe'); + +-- Using DIFFERENCE +SELECT DIFFERENCE('Smithers', 'Smythers'); +GO + +SELECT DIFFERENCE('Anothers', 'Brothers'); +GO + +USE AdventureWorks2012; +GO +SELECT RTRIM(LastName) + ',' + SPACE(2) + LTRIM(FirstName) +FROM Person.Person +ORDER BY LastName, FirstName; +GO + +-- Uses AdventureWorks + +SELECT RTRIM(LastName) + ',' + SPACE(2) + LTRIM(FirstName) +FROM dbo.DimCustomer +ORDER BY LastName, FirstName; +GO + +SELECT STR(123.45, 6, 1); +GO + +SELECT STR(123.45, 2, 2); +GO + +SELECT STR (FLOOR (123.45), 8, 3); +GO + +USE AdventureWorks2019 +GO +SELECT STRING_AGG (CONVERT(NVARCHAR(max),FirstName), CHAR(13)) AS csv +FROM Person.Person; +GO + +USE AdventureWorks2019 +GO +SELECT STRING_AGG(CONVERT(NVARCHAR(max), ISNULL(FirstName,'N/A')), ',') AS csv +FROM Person.Person; +GO + +USE AdventureWorks2019 +GO +SELECT STRING_AGG(CONVERT(NVARCHAR(max), CONCAT(FirstName, ' ', LastName, '(', ModifiedDate, ')')), CHAR(13)) AS names +FROM Person.Person; +GO + +SELECT a.articleId, title, STRING_AGG (tag, ',') as tags +FROM dbo.Article AS a +LEFT JOIN dbo.ArticleTag AS t + ON a.ArticleId = t.ArticleId +GROUP BY a.articleId, title; +GO + +USE AdventureWorks2019 +GO + +SELECT TOP 10 City, STRING_AGG(CONVERT(NVARCHAR(max), EmailAddress), ';') AS emails +FROM Person.BusinessEntityAddress AS BEA +INNER JOIN Person.Address AS A ON BEA.AddressID = A.AddressID +INNER JOIN Person.EmailAddress AS EA ON BEA.BusinessEntityID = EA.BusinessEntityID +GROUP BY City; +GO + +USE AdventureWorks2019 +GO + +SELECT TOP 10 City, STRING_AGG(CONVERT(NVARCHAR(max), EmailAddress), ';') WITHIN GROUP (ORDER BY EmailAddress ASC) AS Emails +FROM Person.BusinessEntityAddress AS BEA +INNER JOIN Person.Address AS A ON BEA.AddressID = A.AddressID +INNER JOIN Person.EmailAddress AS EA ON BEA.BusinessEntityID = EA.BusinessEntityID +GROUP BY City; +GO + +SELECT STRING_ESCAPE('\ / +\\ " ', 'json') AS escapedText; + +SET @json = FORMATMESSAGE('{ "id": %d,"name": "%s", "surname": "%s" }', + 17, STRING_ESCAPE(@name,'json'), STRING_ESCAPE(@surname,'json') ); + +SELECT STUFF('abcdef', 2, 3, 'ijklmn'); + +DECLARE @VAR INT; +SET @VAR = 3; +SELECT STUFF('abcdef', 2, @VAR, 'ijklmn'); +GO + +SELECT name, SUBSTRING(name, 1, 1) AS Initial , +SUBSTRING(name, 3, 2) AS ThirdAndFourthCharacters +FROM sys.databases +WHERE database_id < 5; + +SELECT x = SUBSTRING('abcdef', 2, 3); + +USE pubs; +SELECT pub_id, SUBSTRING(logo, 1, 10) AS logo, + SUBSTRING(pr_info, 1, 10) AS pr_info +FROM pub_info +WHERE pub_id = '1756'; + +IF EXISTS (SELECT table_name FROM INFORMATION_SCHEMA.TABLES + WHERE table_name = 'npub_info') + DROP TABLE npub_info; +GO +-- Create npub_info table in pubs database. Borrowed from instpubs.sql. +USE pubs; +GO +CREATE TABLE npub_info +( + pub_id CHAR(4) NOT NULL + REFERENCES publishers(pub_id) + CONSTRAINT UPKCL_npubinfo PRIMARY KEY CLUSTERED, +pr_info ntext NULL +); + +GO + +-- Fill the pr_info column in npub_info with international data. +RAISERROR('Now at the inserts to pub_info...',0,1); + +GO + +INSERT npub_info VALUES('0736', N'üThis is sample text data for New Moon Books, publisher 0736 in the pubs database') +,('0877', N'üThis is sample text data for Binnet & Hardley, publisher 0877 in the pubs databa') +,('1389', N'üThis is sample text data for Algodata Infosystems, publisher 1389 in the pubs da') +,('9952', N'üThis is sample text data for Scootney Books, publisher 9952 in the pubs database') +,('1622', N'üThis is sample text data for Five Lakes Publishing, publisher 1622 in the pubs d') +,('1756', N'üThis is sample text data for Ramona Publishers, publisher 1756 in the pubs datab') +,('9901', N'üThis is sample text data for GGG&G, publisher 9901 in the pubs database. GGG&G i') +,('9999', N'üThis is sample text data for Lucerne Publishing, publisher 9999 in the pubs data'); +GO +-- Join between npub_info and pub_info on pub_id. +SELECT pr.pub_id, SUBSTRING(pr.pr_info, 1, 35) AS pr_info, + SUBSTRING(npr.pr_info, 1, 35) AS npr_info +FROM pub_info pr INNER JOIN npub_info npr + ON pr.pub_id = npr.pub_id +ORDER BY pr.pub_id ASC; + +-- Uses AdventureWorks + +SELECT LastName, SUBSTRING(FirstName, 1, 1) AS Initial +FROM dbo.DimEmployee +WHERE LastName LIKE 'Bar%' +ORDER BY LastName; + +USE ssawPDW; + +SELECT TOP 1 SUBSTRING('abcdef', 2, 3) AS x FROM dbo.DimCustomer; + +SELECT TRANSLATE('2*[3+4]/{7-2}', '[]{}', '()()'); + +SELECT +REPLACE +( + REPLACE + ( + REPLACE + ( + REPLACE + ( + '2*[3+4]/{7-2}', + '[', + '(' + ), + ']', + ')' + ), + '{', + '(' + ), + '}', + ')' +); + +SELECT TRANSLATE('[137.4,72.3]' , '[,]', '( )') AS Point, + TRANSLATE('(137.4 72.3)' , '( )', '[,]') AS Coordinates; + +SELECT TRANSLATE('abcdef','abc','bcd') AS Translated, + REPLACE(REPLACE(REPLACE('abcdef','a','b'),'b','c'),'c','d') AS Replaced; + +SELECT TRIM( ' test ') AS Result; + +SELECT TRIM( '.,! ' FROM ' # test .') AS Result; + +DECLARE @nstring NCHAR(12); +SET @nstring = N'Åkergatan 24'; +SELECT UNICODE(@nstring), NCHAR(UNICODE(@nstring)); + +-- The @position variable holds the position of the character currently +-- being processed. The @nstring variable is the Unicode character +-- string to process. +DECLARE @position INT, @nstring NCHAR(12); +-- Initialize the current position variable to the first character in +-- the string. +SET @position = 1; +-- Initialize the character string variable to the string to process. +-- Notice that there is an N before the start of the string, which +-- indicates that the data following the N is Unicode data. +SET @nstring = N'Åkergatan 24'; +-- Print the character number of the position of the string you are at, +-- the actual Unicode character you are processing, and the UNICODE +-- value for this particular character. +PRINT 'Character #' + ' ' + 'Unicode Character' + ' ' + 'UNICODE Value'; +WHILE @position <= LEN(@nstring) +-- While these are still characters in the character string, + +BEGIN; + SELECT @position AS [position], + SUBSTRING(@nstring, @position, 1) AS [character], + UNICODE(SUBSTRING(@nstring, @position, 1)) AS [code_point]; + SET @position = @position + 1; +END; + +-- Uses AdventureWorks + +SELECT UPPER(RTRIM(LastName)) + ', ' + FirstName AS Name +FROM dbo.DimEmployee +ORDER BY LastName; diff --git a/tsql/examples/built_in_functions_system.sql b/tsql/examples/built_in_functions_system.sql new file mode 100644 index 0000000..e8259e0 --- /dev/null +++ b/tsql/examples/built_in_functions_system.sql @@ -0,0 +1,453 @@ +USE AdventureWorks2012; +GO +CREATE TABLE myTable (column1 INT, column2 VARCHAR(256)); +GO +INSERT INTO myTable VALUES (1, 'test'); +GO +SELECT BINARY_CHECKSUM(*) from myTable; +GO +UPDATE myTable set column2 = 'TEST'; +GO +SELECT BINARY_CHECKSUM(*) from myTable; +GO + +-- Create a checksum index. + +SET ARITHABORT ON; +USE AdventureWorks2012; +GO +ALTER TABLE Production.Product +ADD cs_Pname AS CHECKSUM(Name); +GO +CREATE INDEX Pname_index ON Production.Product (cs_Pname); +GO + +/*Use the index in a SELECT query. Add a second search +condition to catch stray cases where checksums match, +but the values are not the same.*/ + +SELECT * +FROM Production.Product +WHERE CHECKSUM(N'Bearing Ball') = cs_Pname +AND Name = N'Bearing Ball'; +GO +INSERT INTO player (name, surname, info ) +VALUES (N'Ovidiu', N'Cracium', + COMPRESS(N'{"sport":"Tennis","age": 28,"rank":1,"points":15258, turn":17}')); + +INSERT INTO player (name, surname, info ) +VALUES (N'Michael', N'Raheem', compress(@info)); +DELETE FROM player +OUTPUT deleted.id, deleted.name, deleted.surname, deleted.datemodifier, COMPRESS(deleted.info) +INTO dbo.inactivePlayers +WHERE datemodified < @startOfYear; + +SELECT +ConnectionProperty('net_transport') AS 'Net transport', +ConnectionProperty('protocol_type') AS 'Protocol type'; + +SET CONTEXT_INFO 0x1256698456; +GO +SELECT CONTEXT_INFO(); +GO + +SELECT CURRENT_REQUEST_ID(); + +SELECT CURRENT_TRANSACTION_ID(); + +SELECT _id, name, surname, datemodified, + CAST(DECOMPRESS(info) AS NVARCHAR(MAX)) AS info +FROM player; + +CREATE TABLE example_table ( + _id INT PRIMARY KEY IDENTITY, + name NVARCHAR(max), + surname NVARCHAR(max), + info VARBINARY(max), + info_json as CAST(DECOMPRESS(info) as NVARCHAR(max)) +); + +BEGIN TRY + -- Generate a divide-by-zero error. + SELECT 1/0; +END TRY +BEGIN CATCH + SELECT ERROR_LINE() AS ErrorLine; +END CATCH; +GO + +-- Verify that the stored procedure does not already exist. +IF OBJECT_ID ( 'usp_ExampleProc', 'P' ) IS NOT NULL + DROP PROCEDURE usp_ExampleProc; +GO + +-- Create a stored procedure that +-- generates a divide-by-zero error. +CREATE PROCEDURE usp_ExampleProc +AS + SELECT 1/0; +GO + +BEGIN TRY + -- Execute the stored procedure inside the TRY block. + EXECUTE usp_ExampleProc; +END TRY +BEGIN CATCH + SELECT ERROR_LINE() AS ErrorLine; +END CATCH; +GO + +BEGIN TRY + -- Generate a divide-by-zero error. + SELECT 1/0; +END TRY +BEGIN CATCH + SELECT + ERROR_NUMBER() AS ErrorNumber, + ERROR_SEVERITY() AS ErrorSeverity, + ERROR_STATE() AS ErrorState, + ERROR_PROCEDURE() AS ErrorProcedure, + ERROR_LINE() AS ErrorLine, + ERROR_MESSAGE() AS ErrorMessage; +END CATCH; +GO + +BEGIN TRY + -- Generate a divide-by-zero error. + SELECT 1/0; +END TRY +BEGIN CATCH + SELECT ERROR_MESSAGE() AS ErrorMessage; +END CATCH; +GO + +BEGIN TRY + -- Generate a divide-by-zero error. + SELECT 1/0; +END TRY +BEGIN CATCH + SELECT + ERROR_NUMBER() AS ErrorNumber + ,ERROR_SEVERITY() AS ErrorSeverity + ,ERROR_STATE() AS ErrorState + ,ERROR_PROCEDURE() AS ErrorProcedure + ,ERROR_LINE() AS ErrorLine + ,ERROR_MESSAGE() AS ErrorMessage; +END CATCH; +GO + +-- Verify that the stored procedure does not already exist. +IF OBJECT_ID ( 'usp_ExampleProc', 'P' ) IS NOT NULL + DROP PROCEDURE usp_ExampleProc; +GO + +-- Create a stored procedure that +-- generates a divide-by-zero error. +CREATE PROCEDURE usp_ExampleProc +AS + SELECT 1/0; +GO + +BEGIN TRY + -- Execute the stored procedure inside the TRY block. + EXECUTE usp_ExampleProc; +END TRY +BEGIN CATCH + SELECT ERROR_PROCEDURE() AS ErrorProcedure; +END CATCH; +GO + +-- Verify that the stored procedure does not already exist. +IF OBJECT_ID ( 'usp_ExampleProc', 'P' ) IS NOT NULL + DROP PROCEDURE usp_ExampleProc; +GO + +-- Create a stored procedure that +-- generates a divide-by-zero error. +CREATE PROCEDURE usp_ExampleProc +AS + SELECT 1/0; +GO + +BEGIN TRY + -- Execute the stored procedure inside the TRY block. + EXECUTE usp_ExampleProc; +END TRY +BEGIN CATCH + SELECT + ERROR_NUMBER() AS ErrorNumber, + ERROR_SEVERITY() AS ErrorSeverity, + ERROR_STATE() AS ErrorState, + ERROR_PROCEDURE() AS ErrorProcedure, + ERROR_MESSAGE() AS ErrorMessage, + ERROR_LINE() AS ErrorLine; + END CATCH; +GO + +SELECT text FROM sys.messages WHERE message_id = 20009 AND language_id = 1033; +DECLARE @var1 VARCHAR(200); +SELECT @var1 = FORMATMESSAGE(20009, 'First Variable', 'Second Variable'); +SELECT @var1; + +SELECT FORMATMESSAGE('This is the %s and this is the %s.', 'first variable', 'second variable') AS Result; + +SELECT FORMATMESSAGE('Signed int %i, %d %i, %d, %+i, %+d, %+i, %+d', 5, -5, 50, -50, -11, -11, 11, 11); +SELECT FORMATMESSAGE('Signed int with up to 3 leading zeros %03i', 5); +SELECT FORMATMESSAGE('Signed int with up to 20 leading zeros %020i', 5); +SELECT FORMATMESSAGE('Signed int with leading zero 0 %020i', -55); +SELECT FORMATMESSAGE('Bigint %I64d', 3000000000); +SELECT FORMATMESSAGE('Unsigned int %u, %u', 50, -50); +SELECT FORMATMESSAGE('Unsigned octal %o, %o', 50, -50); +SELECT FORMATMESSAGE('Unsigned hexadecimal %x, %X, %X, %X, %x', 11, 11, -11, 50, -50); +SELECT FORMATMESSAGE('Unsigned octal with prefix: %#o, %#o', 50, -50); +SELECT FORMATMESSAGE('Unsigned hexadecimal with prefix: %#x, %#X, %#X, %X, %x', 11, 11, -11, 50, -50); +SELECT FORMATMESSAGE('Hello %s!', 'TEST'); +SELECT FORMATMESSAGE('Hello %20s!', 'TEST'); +SELECT FORMATMESSAGE('Hello %-20s!', 'TEST'); + +SELECT GET_FILESTREAM_TRANSACTION_CONTEXT(); + +USE AdventureWorks2012; +GO +SELECT GETANSINULL('AdventureWorks2012') +GO + +CREATE TABLE Orders + (OrderID INT PRIMARY KEY, + CustomerID NCHAR(5) REFERENCES Customers(CustomerID), + TerminalID CHAR(8) NOT NULL DEFAULT HOST_ID(), + OrderDate DATETIME NOT NULL, + ShipDate DATETIME NULL, + ShipperID INT NULL REFERENCES Shippers(ShipperID)); +GO + +CREATE TABLE Orders + (OrderID INT PRIMARY KEY, + CustomerID NCHAR(5) REFERENCES Customers(CustomerID), + Workstation NCHAR(30) NOT NULL DEFAULT HOST_NAME(), + OrderDate DATETIME NOT NULL, + ShipDate DATETIME NULL, + ShipperID INT NULL REFERENCES Shippers(ShipperID)); +GO + +USE AdventureWorks2012; +GO +SELECT AVG(ISNULL(Weight, 50)) +FROM Production.Product; +GO + +USE AdventureWorks2012; +GO +SELECT Description, DiscountPct, MinQty, ISNULL(MaxQty, 0.00) AS 'Max Quantity' +FROM Sales.SpecialOffer; +GO + +USE AdventureWorks2012; +GO +SELECT Name, Weight +FROM Production.Product +WHERE Weight IS NULL; +GO + +-- Uses AdventureWorks + +SELECT AVG(ISNULL(Weight, 50)) +FROM dbo.DimProduct; + +-- Uses AdventureWorks + +SELECT ResellerName, + ISNULL(MinPaymentAmount,0) AS MinimumPayment +FROM dbo.DimReseller +ORDER BY ResellerName; + +-- Uses AdventureWorks + +SELECT EnglishProductName, Weight +FROM dbo.DimProduct +WHERE Weight IS NULL; + +USE AdventureWorks2012; +GO +SELECT City, PostalCode +FROM Person.Address +WHERE ISNUMERIC(PostalCode) <> 1; +GO + +USE master; +GO +SELECT name, ISNUMERIC(name) AS IsNameANumber, database_id, ISNUMERIC(database_id) AS IsIdANumber +FROM sys.databases; +GO + +-- Create a table that has a ROWVERSION column in it. +CREATE TABLE RowVersionTestTable (rv ROWVERSION) +GO + +-- Print the current values for the database. +PRINT '' +PRINT 'DBTS' +PRINT @@DBTS +PRINT 'MIN_ACTIVE_ROWVERSION' +PRINT MIN_ACTIVE_ROWVERSION() +GO +---------------- Results ---------------- +--DBTS +--0x00000000000007E2 +--MIN_ACTIVE_ROWVERSION +--0x00000000000007E3 + +-- Insert a row. +INSERT INTO RowVersionTestTable VALUES (DEFAULT) +SELECT * FROM RowVersionTestTable +GO +---------------- Results ---------------- +--rv +--0x00000000000007E3 + +-- Print the current values for the database. +PRINT '' +PRINT 'DBTS' +PRINT @@DBTS +PRINT 'MIN_ACTIVE_ROWVERSION' +PRINT MIN_ACTIVE_ROWVERSION() +GO +---------------- Results ---------------- +--DBTS +--0x00000000000007E3 +--MIN_ACTIVE_ROWVERSION +--0x00000000000007E4 + +-- Insert a new row inside a transaction but do not commit. +BEGIN TRAN +INSERT INTO RowVersionTestTable VALUES (DEFAULT) +SELECT * FROM RowVersionTestTable +GO +---------------- Results ---------------- +--rv +--0x00000000000007E3 +--0x00000000000007E4 + +-- Print the current values for the database. +PRINT '' +PRINT 'DBTS' +PRINT @@DBTS +PRINT 'MIN_ACTIVE_ROWVERSION' +PRINT MIN_ACTIVE_ROWVERSION() +GO +---------------- Results ---------------- +--DBTS +--0x00000000000007E4 +--MIN_ACTIVE_ROWVERSION +--0x00000000000007E4 + +-- Commit the transaction. +COMMIT +GO + +-- Print the current values for the database. +PRINT '' +PRINT 'DBTS' +PRINT @@DBTS +PRINT 'MIN_ACTIVE_ROWVERSION' +PRINT MIN_ACTIVE_ROWVERSION() +GO +---------------- Results ---------------- +--DBTS +--0x00000000000007E4 +--MIN_ACTIVE_ROWVERSION +--0x00000000000007E5 + +-- Creating a local variable with DECLARE/SET syntax. +DECLARE @myid uniqueidentifier +SET @myid = NEWID() +PRINT 'Value of @myid is: '+ CONVERT(varchar(255), @myid) + +-- Creating a table using NEWID for uniqueidentifier data type. +CREATE TABLE cust +( + CustomerID uniqueidentifier NOT NULL + DEFAULT newid(), + Company VARCHAR(30) NOT NULL, + ContactName VARCHAR(60) NOT NULL, + Address VARCHAR(30) NOT NULL, + City VARCHAR(30) NOT NULL, + StateProvince VARCHAR(10) NULL, + PostalCode VARCHAR(10) NOT NULL, + CountryRegion VARCHAR(20) NOT NULL, + Telephone VARCHAR(15) NOT NULL, + Fax VARCHAR(15) NULL +); +GO +-- Inserting 5 rows into cust table. +INSERT cust +(Company, ContactName, Address, City, StateProvince, + PostalCode, CountryRegion, Telephone, Fax) +VALUES + ('Wartian Herkku', 'Pirkko Koskitalo', 'Torikatu 38', 'Oulu', NULL, + '90110', 'Finland', '981-443655', '981-443655') +,('Wellington Importadora', 'Paula Parente', 'Rua do Mercado, 12', 'Resende', 'SP', + '08737-363', 'Brasil', '(14) 555-8122', '') +,('Cactus Comidas para Ilevar', 'Patricio Simpson', 'Cerrito 333', 'Buenos Aires', NULL, + '1010', 'Argentina', '(1) 135-5555', '(1) 135-4892') +,('Ernst Handel', 'Roland Mendel', 'Kirchgasse 6', 'Graz', NULL, + '8010', 'Austria', '7675-3425', '7675-3426') +,('Maison Dewey', 'Catherine Dewey', 'Rue Joseph-Bens 532', 'Bruxelles', NULL, + 'B-1180', 'Belgium', '(02) 201 24 67', '(02) 201 24 68'); +GO + +DECLARE @myid uniqueidentifier ; +SET @myid = 'A972C577-DFB0-064E-1189-0154C99310DAAC12'; +SELECT @myid; +GO + +CREATE TABLE myTable (ColumnA uniqueidentifier DEFAULT NEWSEQUENTIALID()); + +CREATE TABLE myTable (ColumnA uniqueidentifier DEFAULT dbo.myfunction(NEWSEQUENTIALID())); + +EXEC sp_set_session_context 'user_id', 4; +SELECT SESSION_CONTEXT(N'user_id'); + +USE AdventureWorks2012; +GO + +-- SET XACT_ABORT ON will render the transaction uncommittable +-- when the constraint violation occurs. +SET XACT_ABORT ON; + +BEGIN TRY + BEGIN TRANSACTION; + -- A FOREIGN KEY constraint exists on this table. This + -- statement will generate a constraint violation error. + DELETE FROM Production.Product + WHERE ProductID = 980; + + -- If the delete operation succeeds, commit the transaction. The CATCH + -- block will not execute. + COMMIT TRANSACTION; +END TRY +BEGIN CATCH + -- Test XACT_STATE for 0, 1, or -1. + -- If 1, the transaction is committable. + -- If -1, the transaction is uncommittable and should + -- be rolled back. + -- XACT_STATE = 0 means there is no transaction and + -- a commit or rollback operation would generate an error. + + -- Test whether the transaction is uncommittable. + IF (XACT_STATE()) = -1 + BEGIN + PRINT 'The transaction is in an uncommittable state.' + + ' Rolling back transaction.' + ROLLBACK TRANSACTION; + END; + + -- Test whether the transaction is active and valid. + IF (XACT_STATE()) = 1 + BEGIN + PRINT 'The transaction is committable.' + + ' Committing transaction.' + COMMIT TRANSACTION; + END; +END CATCH; +GO diff --git a/tsql/examples/certificates.sql b/tsql/examples/certificates.sql new file mode 100644 index 0000000..f7b3a9c --- /dev/null +++ b/tsql/examples/certificates.sql @@ -0,0 +1,16 @@ +ALTER CERTIFICATE Shipping04 + WITH PRIVATE KEY (DECRYPTION BY PASSWORD = 'pGF$5DGvbd2439587y', + ENCRYPTION BY PASSWORD = '4-329578thlkajdshglXCSgf'); +GO +ALTER CERTIFICATE Shipping11 + WITH PRIVATE KEY (ENCRYPTION BY PASSWORD = '34958tosdgfkh##38', + DECRYPTION BY PASSWORD = '95hkjdskghFDGGG4%'); +GO +ALTER CERTIFICATE Shipping13 + WITH PRIVATE KEY (FILE = 'c:\\importedkeys\Shipping13', + DECRYPTION BY PASSWORD = 'GDFLKl8^^GGG4000%'); +GO +ALTER CERTIFICATE Shipping15 + WITH PRIVATE KEY (DECRYPTION BY PASSWORD = '95hk000eEnvjkjy#F%'); +GO + diff --git a/tsql/examples/column_encryption_key.sql b/tsql/examples/column_encryption_key.sql new file mode 100644 index 0000000..2525044 --- /dev/null +++ b/tsql/examples/column_encryption_key.sql @@ -0,0 +1,27 @@ +ALTER COLUMN ENCRYPTION KEY MyCEK +ADD VALUE +( + COLUMN_MASTER_KEY = MyCMK2, + ALGORITHM = 'RSA_OAEP', + ENCRYPTED_VALUE = 0x016E000001630075007200720065006E00740075007300650072002F006D0079002F0064006500650063006200660034006100340031003000380034006200350033003200360066003200630062006200350030003600380065003900620061003000320030003600610037003800310066001DDA6134C3B73A90D349C8905782DD819B428162CF5B051639BA46EC69A7C8C8F81591A92C395711493B25DCBCCC57836E5B9F17A0713E840721D098F3F8E023ABCDFE2F6D8CC4339FC8F88630ED9EBADA5CA8EEAFA84164C1095B12AE161EABC1DF778C07F07D413AF1ED900F578FC00894BEE705EAC60F4A5090BBE09885D2EFE1C915F7B4C581D9CE3FDAB78ACF4829F85752E9FC985DEB8773889EE4A1945BD554724803A6F5DC0A2CD5EFE001ABED8D61E8449E4FAA9E4DD392DA8D292ECC6EB149E843E395CDE0F98D04940A28C4B05F747149B34A0BAEC04FFF3E304C84AF1FF81225E615B5F94E334378A0A888EF88F4E79F66CB377E3C21964AACB5049C08435FE84EEEF39D20A665C17E04898914A85B3DE23D56575EBC682D154F4F15C37723E04974DB370180A9A579BC84F6BC9B5E7C223E5CBEE721E57EE07EFDCC0A3257BBEBF9ADFFB00DBF7EF682EC1C4C47451438F90B4CF8DA709940F72CFDC91C6EB4E37B4ED7E2385B1FF71B28A1D2669FBEB18EA89F9D391D2FDDEA0ED362E6A591AC64EF4AE31CA8766C259ECB77D01A7F5C36B8418F91C1BEADDD4491C80F0016B66421B4B788C55127135DA2FA625FB7FD195FB40D90A6C67328602ECAF3EC4F5894BFD84A99EB4753BE0D22E0D4DE6A0ADFEDC80EB1B556749B4A8AD00E73B329C95827AB91C0256347E85E3C5FD6726D0E1FE82C925D3DF4A9 +); +GO +ALTER COLUMN ENCRYPTION KEY MyCEK +DROP VALUE +( + COLUMN_MASTER_KEY = MyCMK +); +GO +CREATE COLUMN ENCRYPTION KEY TwoValueCEK +WITH VALUES +( + COLUMN_MASTER_KEY = CMK1, + ALGORITHM = 'RSA_OAEP', + ENCRYPTED_VALUE = 0x016E000001630075007200720065006E00740075007300650072002F006D0079002F0037006300380061003100310033003400320037003800620037003000630038003100390062003900630039003400360061006600340039006500610030003200650038006200650038003400340065006C33A82ECF04A7185824B4545457AC5244CD9C219E64067B9520C0081B8399B58C2863F7494ABE3694BD87D55FFD7576FFDC47C28F94ECC99577DF4FB8FA19AA95764FEF889CDE0F176DA5897B74382FBB22756CE2921050A09201A0EB6AF3D6091014C30146EA62635EE8CBF0A8074DEDFF125CEA80D1C0F5E8C58750A07D270E2A8BF824EE4C0C156366BF26D38CCE49EBDD5639A2DF029A7DBAE5A5D111F2F2FA3246DF8C2FA83C1E542C10570FADA98F6B29478DC58CE5CBDD407CCEFCDB97814525F6F32BECA266014AC346AC39C4F185C6C0F0A24FEC4DFA015649624692DE7865B9827BA22C3B574C9FD169F822B609F902288C5880EB25F14BD990D871B1BC4BA3A5B237AF76D26354773FA2A25CF4511AF58C911E601CFCB1905128C997844EED056C2AE7F0B48700AB41307E470FF9520997D0EB0D887DE11AFE574FFE845B7DC6C03FEEE8D467236368FC0CB2FDBD54DADC65B10B3DE6C80DF8B7B3F8F3CE5BE914713EE7B1FA5B7A578359592B8A5FDFDDE5FF9F392BC87C3CD02FBA94582AC063BBB9FFAC803FD489E16BEB28C4E3374A8478C737236A0B232F5A9DDE4D119573F1AEAE94B2192B81575AD6F57E670C1B2AB91045124DFDAEC2898F3F0112026DFC93BF9391D667D1AD7ED7D4E6BB119BBCEF1D1ADA589DD3E1082C3DAD13223BE438EB9574DA04E9D8A06320CAC6D3EC21D5D1C2A0AA484C7C +), +( + COLUMN_MASTER_KEY = CMK2, + ALGORITHM = 'RSA_OAEP', + ENCRYPTED_VALUE = 0x016E000001630075007200720065006E00740075007300650072002F006D0079002F0064006500650063006200660034006100340031003000380034006200350033003200360066003200630062006200350030003600380065003900620061003000320030003600610037003800310066001DDA6134C3B73A90D349C8905782DD819B428162CF5B051639BA46EC69A7C8C8F81591A92C395711493B25DCBCCC57836E5B9F17A0713E840721D098F3F8E023ABCDFE2F6D8CC4339FC8F88630ED9EBADA5CA8EEAFA84164C1095B12AE161EABC1DF778C07F07D413AF1ED900F578FC00894BEE705EAC60F4A5090BBE09885D2EFE1C915F7B4C581D9CE3FDAB78ACF4829F85752E9FC985DEB8773889EE4A1945BD554724803A6F5DC0A2CD5EFE001ABED8D61E8449E4FAA9E4DD392DA8D292ECC6EB149E843E395CDE0F98D04940A28C4B05F747149B34A0BAEC04FFF3E304C84AF1FF81225E615B5F94E334378A0A888EF88F4E79F66CB377E3C21964AACB5049C08435FE84EEEF39D20A665C17E04898914A85B3DE23D56575EBC682D154F4F15C37723E04974DB370180A9A579BC84F6BC9B5E7C223E5CBEE721E57EE07EFDCC0A3257BBEBF9ADFFB00DBF7EF682EC1C4C47451438F90B4CF8DA709940F72CFDC91C6EB4E37B4ED7E2385B1FF71B28A1D2669FBEB18EA89F9D391D2FDDEA0ED362E6A591AC64EF4AE31CA8766C259ECB77D01A7F5C36B8418F91C1BEADDD4491C80F0016B66421B4B788C55127135DA2FA625FB7FD195FB40D90A6C67328602ECAF3EC4F5894BFD84A99EB4753BE0D22E0D4DE6A0ADFEDC80EB1B556749B4A8AD00E73B329C95827AB91C0256347E85E3C5FD6726D0E1FE82C925D3DF4A9 +); +GO diff --git a/tsql/examples/column_master_key.sql b/tsql/examples/column_master_key.sql new file mode 100644 index 0000000..1c6a781 --- /dev/null +++ b/tsql/examples/column_master_key.sql @@ -0,0 +1,21 @@ +CREATE COLUMN MASTER KEY MyCMK +WITH ( + KEY_STORE_PROVIDER_NAME = N'MSSQL_CERTIFICATE_STORE', + KEY_PATH = 'Current User/Personal/f2260f28d909d21c642a3d8e0b45a830e79a1420' + ); + +CREATE COLUMN MASTER KEY MyCMK +WITH ( + KEY_STORE_PROVIDER_NAME = N'MSSQL_CNG_STORE', + KEY_PATH = N'My HSM CNG Provider/AlwaysEncryptedKey' +); +CREATE COLUMN MASTER KEY MyCMK +WITH ( + KEY_STORE_PROVIDER_NAME = N'AZURE_KEY_VAULT', + KEY_PATH = N'https://myvault.vault.azure.net:443/keys/ + MyCMK/4c05f1a41b12488f9cba2ea964b6a700'); +CREATE COLUMN MASTER KEY MyCMK +WITH ( + KEY_STORE_PROVIDER_NAME = 'CUSTOM_KEY_STORE', + KEY_PATH = 'https://contoso.vault/sales_db_tce_key' +); diff --git a/tsql/examples/concat_op.sql b/tsql/examples/concat_op.sql new file mode 100644 index 0000000..be19740 --- /dev/null +++ b/tsql/examples/concat_op.sql @@ -0,0 +1 @@ +select '1' || '2' diff --git a/tsql/examples/constants.sql b/tsql/examples/constants.sql new file mode 100644 index 0000000..cacddc2 --- /dev/null +++ b/tsql/examples/constants.sql @@ -0,0 +1,42 @@ +create procedure sp (@val numeric) as begin print @val +end +go + exec sp $ 5 +go + exec sp $ -5 +go + exec sp $ + 5 +go + exec sp - $ 5 +go + exec sp - $ -5 +go + exec sp -1 +go +select + $ 5 +go +select + $ -5 +go +select + $ + 5 +go +select + - $ 5 +go +select + - $ -5 +go +select + + $ -5 +go +select + -1 +go +select + - -1 +go +select + + 1 +go \ No newline at end of file diff --git a/tsql/examples/control_flow.sql b/tsql/examples/control_flow.sql new file mode 100644 index 0000000..f41c4c4 --- /dev/null +++ b/tsql/examples/control_flow.sql @@ -0,0 +1,432 @@ +----------------------------------------------------------------------- +-- BEGIN END https://msdn.microsoft.com/en-us/library/ms190487.aspx + +USE AdventureWorks2012; +GO +BEGIN TRANSACTION; +GO +IF @@TRANCOUNT = 0 +BEGIN + SELECT FirstName, MiddleName + FROM Person.Person WHERE LastName = 'Adams'; + ROLLBACK TRANSACTION; + PRINT N'Rolling back the transaction two times would cause an error.'; +END; +ROLLBACK TRANSACTION; +PRINT N'Rolled back the transaction.'; +GO + +----------------------------------------------------------------------- +-- BREAK https://msdn.microsoft.com/en-us/library/ms181271.aspx + +----------------------------------------------------------------------- +-- CONTINUE https://msdn.microsoft.com/en-us/library/ms174366.aspx + +----------------------------------------------------------------------- +-- GOTO + +DECLARE @Counter int; +SET @Counter = 1; +WHILE @Counter < 10 +BEGIN + SELECT @Counter + SET @Counter = @Counter + 1 + IF @Counter = 4 GOTO Branch_One --Jumps to the first branch. + IF @Counter = 5 GOTO Branch_Two --This will never execute. +END +Branch_One: + SELECT 'Jumping To Branch One.' + GOTO Branch_Three; --This will prevent Branch_Two from executing. +Branch_Two: + SELECT 'Jumping To Branch Two.' +Branch_Three: + SELECT 'Jumping To Branch Three.'; + +----------------------------------------------------------------------- +-- IF ELSE https://msdn.microsoft.com/en-us/library/ms182587.aspx + +DECLARE @compareprice money, @cost money +EXECUTE Production.uspGetList '%Bikes%', 700, + @compareprice OUT, + @cost OUTPUT +IF @cost <= @compareprice +BEGIN + PRINT 'These products can be purchased for less than + $'+RTRIM(CAST(@compareprice AS varchar(20)))+'.' +END +ELSE + PRINT 'The prices for all products in this category exceed + $'+ RTRIM(CAST(@compareprice AS varchar(20)))+'.' + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using a query as part of a Boolean expression + +IF 1 = 1 PRINT 'Boolean_expression is true.' +ELSE PRINT 'Boolean_expression is false.' ; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using a simple Boolean expression + +USE AdventureWorks2012; +GO +IF +(SELECT COUNT(*) FROM Production.Product WHERE Name LIKE 'Touring-3000%' ) > 5 +PRINT 'There are more than 5 Touring-3000 bicycles.' +ELSE PRINT 'There are 5 or less Touring-3000 bicycles.' ; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using a statement block + +USE AdventureWorks2012; +GO +DECLARE @AvgWeight decimal(8,2), @BikeCount int +IF +(SELECT COUNT(*) FROM Production.Product WHERE Name LIKE 'Touring-3000%' ) > 5 +BEGIN + SET @BikeCount = + (SELECT COUNT(*) + FROM Production.Product + WHERE Name LIKE 'Touring-3000%'); + SET @AvgWeight = + (SELECT AVG(Weight) + FROM Production.Product + WHERE Name LIKE 'Touring-3000%'); + PRINT 'There are ' + CAST(@BikeCount AS varchar(3)) + ' Touring-3000 bikes.' + PRINT 'The average weight of the top 5 Touring-3000 bikes is ' + CAST(@AvgWeight AS varchar(8)) + '.'; +END +ELSE +BEGIN +SET @AvgWeight = + (SELECT AVG(Weight) + FROM Production.Product + WHERE Name LIKE 'Touring-3000%' ); + PRINT 'Average weight of the Touring-3000 bikes is ' + CAST(@AvgWeight AS varchar(8)) + '.' ; +END ; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using nested IF...ELSE statements + +DECLARE @Number int; +SET @Number = 50; +IF @Number > 100 + PRINT 'The number is large.'; +ELSE + BEGIN + IF @Number < 10 + PRINT 'The number is small.'; + ELSE + PRINT 'The number is medium.'; + END ; +GO + +----------------------------------------------------------------------- +-- RETURN https://msdn.microsoft.com/en-us/library/ms174998.aspx + +CREATE PROCEDURE findjobs @nm sysname = NULL +AS +IF @nm IS NULL + BEGIN + PRINT 'You must give a user name' + RETURN + END +ELSE + BEGIN + SELECT o.name, o.id, o.uid + FROM sysobjects o INNER JOIN master..syslogins l + ON o.uid = l.sid + WHERE l.name = @nm + END; +GO + +----------------------------------------------------------------------- +-- THROW https://msdn.microsoft.com/en-us/library/ee677615.aspx + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using THROW to raise an exception + +THROW 51000, 'The record does not exist.', 1; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using THROW to raise an exception again + +USE tempdb; +GO +CREATE TABLE dbo.TestRethrow +( ID INT PRIMARY KEY +); +BEGIN TRY + INSERT dbo.TestRethrow(ID) VALUES(1); +-- Force error 2627, Violation of PRIMARY KEY constraint to be raised. + INSERT dbo.TestRethrow(ID) VALUES(1); +END TRY +BEGIN CATCH + + PRINT 'In catch block.'; + THROW; +END CATCH; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using FORMATMESSAGE with THROW + +EXEC sys.sp_addmessage + @msgnum = 60000 +,@severity = 16 +,@msgtext = N'This is a test message with one numeric parameter (%d), one string parameter (%s), and another string parameter (%s).' + ,@lang = 'us_english'; +GO + +DECLARE @msg NVARCHAR(2048) = FORMATMESSAGE(60000, 500, N'First string', N'second string'); + +THROW 60000, @msg, 1; + +----------------------------------------------------------------------- +-- TRY CATCH https://msdn.microsoft.com/en-us/library/ms175976.aspx + +-- Verify that the stored procedure does not already exist. +IF OBJECT_ID ( 'usp_GetErrorInfo', 'P' ) IS NOT NULL + DROP PROCEDURE usp_GetErrorInfo; +GO + +-- Create procedure to retrieve error information. +CREATE PROCEDURE usp_GetErrorInfo +AS +SELECT + ERROR_NUMBER() AS ErrorNumber + ,ERROR_SEVERITY() AS ErrorSeverity + ,ERROR_STATE() AS ErrorState + ,ERROR_PROCEDURE() AS ErrorProcedure + ,ERROR_LINE() AS ErrorLine + ,ERROR_MESSAGE() AS ErrorMessage; +GO + +BEGIN TRY + -- Generate divide-by-zero error. + SELECT 1/0; +END TRY +BEGIN CATCH + -- Execute error retrieval routine. + EXECUTE usp_GetErrorInfo; +END CATCH; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using TRY…CATCH + +BEGIN TRY + -- Generate a divide-by-zero error. + SELECT 1/0; +END TRY +BEGIN CATCH + SELECT + ERROR_NUMBER() AS ErrorNumber + ,ERROR_SEVERITY() AS ErrorSeverity + ,ERROR_STATE() AS ErrorState + ,ERROR_PROCEDURE() AS ErrorProcedure + ,ERROR_LINE() AS ErrorLine + ,ERROR_MESSAGE() AS ErrorMessage; +END CATCH; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using TRY…CATCH in a transaction + +BEGIN TRANSACTION; + +BEGIN TRY + -- Generate a constraint violation error. + DELETE FROM Production.Product + WHERE ProductID = 980; +END TRY +BEGIN CATCH + SELECT + ERROR_NUMBER() AS ErrorNumber + ,ERROR_SEVERITY() AS ErrorSeverity + ,ERROR_STATE() AS ErrorState + ,ERROR_PROCEDURE() AS ErrorProcedure + ,ERROR_LINE() AS ErrorLine + ,ERROR_MESSAGE() AS ErrorMessage; + + IF @@TRANCOUNT > 0 + ROLLBACK TRANSACTION; +END CATCH; + +IF @@TRANCOUNT > 0 + COMMIT TRANSACTION; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using TRY…CATCH with XACT_STATE + +-- Check to see whether this stored procedure exists. +IF OBJECT_ID (N'usp_GetErrorInfo', N'P') IS NOT NULL + DROP PROCEDURE usp_GetErrorInfo; +GO + +-- Create procedure to retrieve error information. +CREATE PROCEDURE usp_GetErrorInfo +AS + SELECT + ERROR_NUMBER() AS ErrorNumber + ,ERROR_SEVERITY() AS ErrorSeverity + ,ERROR_STATE() AS ErrorState + ,ERROR_LINE () AS ErrorLine + ,ERROR_PROCEDURE() AS ErrorProcedure + ,ERROR_MESSAGE() AS ErrorMessage; +GO + +-- SET XACT_ABORT ON will cause the transaction to be uncommittable +-- when the constraint violation occurs. +SET XACT_ABORT ON; + +BEGIN TRY + BEGIN TRANSACTION; + -- A FOREIGN KEY constraint exists on this table. This + -- statement will generate a constraint violation error. + DELETE FROM Production.Product + WHERE ProductID = 980; + + -- If the DELETE statement succeeds, commit the transaction. + COMMIT TRANSACTION; +END TRY +BEGIN CATCH + -- Execute error retrieval routine. + EXECUTE usp_GetErrorInfo; + + -- Test XACT_STATE: + -- If 1, the transaction is committable. + -- If -1, the transaction is uncommittable and should + -- be rolled back. + -- XACT_STATE = 0 means that there is no transaction and + -- a commit or rollback operation would generate an error. + + -- Test whether the transaction is uncommittable. + IF (XACT_STATE()) = -1 + BEGIN + PRINT + N'The transaction is in an uncommittable state.' + + 'Rolling back transaction.' + ROLLBACK TRANSACTION; + END; + + -- Test whether the transaction is committable. + IF (XACT_STATE()) = 1 + BEGIN + PRINT + N'The transaction is committable.' + + 'Committing transaction.' + COMMIT TRANSACTION; + END; +END CATCH; +GO + +----------------------------------------------------------------------- +-- WAITFOR https://msdn.microsoft.com/en-us/library/ms187331.aspx + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using WAITFOR TIME + +EXECUTE sp_add_job @job_name = 'TestJob'; +BEGIN + WAITFOR TIME '22:20'; + EXECUTE sp_update_job @job_name = 'TestJob', + @new_name = 'UpdatedJob'; +END; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using WAITFOR DELAY + +BEGIN + WAITFOR DELAY '02:00'; + EXECUTE sp_helpdb; +END; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using WAITFOR DELAY with a local variable + +IF OBJECT_ID('dbo.TimeDelay_hh_mm_ss','P') IS NOT NULL + DROP PROCEDURE dbo.TimeDelay_hh_mm_ss; +GO +CREATE PROCEDURE dbo.TimeDelay_hh_mm_ss + ( + @DelayLength char(8)= '00:00:00' + ) +AS +DECLARE @ReturnInfo varchar(255) +IF ISDATE('2000-01-01 ' + @DelayLength + '.000') = 0 + BEGIN + SELECT @ReturnInfo = 'Invalid time ' + @DelayLength + + ',hh:mm:ss, submitted.'; + -- This PRINT statement is for testing, not use in production. + PRINT @ReturnInfo + RETURN(1) + END +BEGIN + WAITFOR DELAY @DelayLength + SELECT @ReturnInfo = 'A total time of ' + @DelayLength + ', + hh:mm:ss, has elapsed! Your time is up.' + -- This PRINT statement is for testing, not use in production. + PRINT @ReturnInfo; +END; +GO +/* This statement executes the dbo.TimeDelay_hh_mm_ss procedure. */ +EXEC TimeDelay_hh_mm_ss '00:00:10'; +GO + +-- waitfor with receive statement +WAITFOR ( + RECEIVE * + FROM ExpenseQueue); + +-- waitfor with receive statement and timeout +WAITFOR ( + RECEIVE * + FROM ExpenseQueue ), TIMEOUT 60000; + +-- waitfor with receive statement containing column select +DECLARE @ConversationHandle uniqueidentifier; +WAITFOR ( + RECEIVE TOP (1) + @ConversationHandle = conversation_handle + FROM dbo.ReplicationInboundQueue), TIMEOUT 3000; + +----------------------------------------------------------------------- +-- WHILE https://msdn.microsoft.com/en-us/library/ms178642.aspx + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using BREAK and CONTINUE with nested IF...ELSE and WHILE + +USE AdventureWorks2012; +GO +WHILE (SELECT AVG(ListPrice) FROM Production.Product) < $300 +BEGIN + UPDATE Production.Product + SET ListPrice = ListPrice * 2 + SELECT MAX(ListPrice) FROM Production.Product + IF (SELECT MAX(ListPrice) FROM Production.Product) > $500 + BREAK + ELSE + CONTINUE +END +PRINT 'Too much for the market to bear'; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using WHILE in a cursor + +DECLARE Employee_Cursor CURSOR FOR +SELECT EmployeeID, Title +FROM AdventureWorks2012.HumanResources.Employee +WHERE JobTitle = 'Marketing Specialist'; +OPEN Employee_Cursor; +FETCH NEXT FROM Employee_Cursor; +WHILE @@FETCH_STATUS = 0 + BEGIN + FETCH NEXT FROM Employee_Cursor; + END; +CLOSE Employee_Cursor; +DEALLOCATE Employee_Cursor; +GO + + diff --git a/tsql/examples/create_endpoint.sql b/tsql/examples/create_endpoint.sql new file mode 100644 index 0000000..5975327 --- /dev/null +++ b/tsql/examples/create_endpoint.sql @@ -0,0 +1,25 @@ +CREATE ENDPOINT endpoint_mirroring + STATE = STARTED + AS TCP ( LISTENER_PORT = 7022 ) + FOR DATABASE_MIRRORING ( + AUTHENTICATION = WINDOWS KERBEROS, + ENCRYPTION = SUPPORTED, + ROLE=ALL); +GO + +CREATE ENDPOINT ipv4_endpoint_special +STATE = STARTED +AS TCP ( + LISTENER_PORT = 55555, LISTENER_IP = (10.0.75.1) +) +FOR TSQL (); + +go + +CREATE ENDPOINT ipv6_endpoint_special +STATE = STARTED +AS TCP ( + LISTENER_PORT = 55555, LISTENER_IP = ('::1') +) +FOR TSQL (); +go diff --git a/tsql/examples/create_function_optional_parens.sql b/tsql/examples/create_function_optional_parens.sql new file mode 100644 index 0000000..aea4d67 --- /dev/null +++ b/tsql/examples/create_function_optional_parens.sql @@ -0,0 +1,10 @@ +CREATE FUNCTION [main].[TestParentheses] + ( + @WHY INTEGER + ) + RETURNS TABLE + AS + RETURN + ( + SELECT @WHY + 1 AS UltimateAnswer + ) \ No newline at end of file diff --git a/tsql/examples/create_xml_index.sql b/tsql/examples/create_xml_index.sql new file mode 100644 index 0000000..d5cf44a --- /dev/null +++ b/tsql/examples/create_xml_index.sql @@ -0,0 +1,2 @@ +CREATE PRIMARY XML INDEX s1_ti_x + ON ti_x (xmldata); diff --git a/tsql/examples/credentials.sql b/tsql/examples/credentials.sql new file mode 100644 index 0000000..1db698d --- /dev/null +++ b/tsql/examples/credentials.sql @@ -0,0 +1,13 @@ +ALTER CREDENTIAL Saddles WITH IDENTITY = 'RettigB', + SECRET = 'sdrlk8$40-dksli87nNN8'; +GO + +ALTER CREDENTIAL Frames WITH IDENTITY = 'Aboulrus8'; +GO +CREATE CREDENTIAL AlterEgo WITH IDENTITY = 'Mary5', + SECRET = ''; +GO +CREATE CREDENTIAL CredentialForEKM + WITH IDENTITY='User1OnEKM', SECRET='' + FOR CRYPTOGRAPHIC PROVIDER MyEKMProvider; +GO diff --git a/tsql/examples/cryptographic_provider.sql b/tsql/examples/cryptographic_provider.sql new file mode 100644 index 0000000..ec0c2fc --- /dev/null +++ b/tsql/examples/cryptographic_provider.sql @@ -0,0 +1,12 @@ +ALTER CRYPTOGRAPHIC PROVIDER SecurityProvider +DISABLE; +GO +ALTER CRYPTOGRAPHIC PROVIDER SecurityProvider +FROM FILE = 'c:\SecurityProvider\SecurityProvider_v2.dll'; +GO +ALTER CRYPTOGRAPHIC PROVIDER SecurityProvider +ENABLE; +GO + +CREATE CRYPTOGRAPHIC PROVIDER SecurityProvider + FROM FILE = 'C:\SecurityProvider\SecurityProvider_v1.dll'; diff --git a/tsql/examples/cursors.sql b/tsql/examples/cursors.sql new file mode 100644 index 0000000..8333710 --- /dev/null +++ b/tsql/examples/cursors.sql @@ -0,0 +1,292 @@ +-- Cursors https://msdn.microsoft.com/en-us/library/ms181441(v=sql.120).aspx + +----------------------------------------------------------------------- +-- Close https://msdn.microsoft.com/en-us/library/ms175035.aspx +-- CLOSE { { [ GLOBAL ] cursor_name } | cursor_variable_name } + +DECLARE Employee_Cursor CURSOR FOR +SELECT EmployeeID, Title FROM AdventureWorks2012.HumanResources.Employee; +OPEN Employee_Cursor; +FETCH NEXT FROM Employee_Cursor; +WHILE @@FETCH_STATUS = 0 + BEGIN + FETCH NEXT FROM Employee_Cursor; + END; +CLOSE Employee_Cursor; +DEALLOCATE Employee_Cursor; +GO + +----------------------------------------------------------------------- +-- DEALLOCATE https://msdn.microsoft.com/en-us/library/ms188782(v=sql.120).aspx +-- DEALLOCATE { { [ GLOBAL ] cursor_name } | @cursor_variable_name } + +USE AdventureWorks2012; +GO +-- Create and open a global named cursor that +-- is visible outside the batch. +DECLARE abc CURSOR GLOBAL SCROLL FOR + SELECT * FROM Sales.SalesPerson; +OPEN abc; +GO +-- Reference the named cursor with a cursor variable. +DECLARE @MyCrsrRef1 CURSOR; +SET @MyCrsrRef1 = abc; +-- Now deallocate the cursor reference. +DEALLOCATE @MyCrsrRef1; +-- Cursor abc still exists. +FETCH NEXT FROM abc; +GO +-- Reference the named cursor again. +DECLARE @MyCrsrRef2 CURSOR; +SET @MyCrsrRef2 = abc; +-- Now deallocate cursor name abc. +DEALLOCATE abc; +-- Cursor still exists, referenced by @MyCrsrRef2. +FETCH NEXT FROM @MyCrsrRef2; +-- Cursor finally is deallocated when last referencing +-- variable goes out of scope at the end of the batch. +GO +-- Create an unnamed cursor. +DECLARE @MyCursor CURSOR; +SET @MyCursor = CURSOR LOCAL SCROLL FOR +SELECT * FROM Sales.SalesTerritory; +-- The following statement deallocates the cursor +-- because no other variables reference it. +DEALLOCATE @MyCursor; +GO + +----------------------------------------------------------------------- +-- DECLARE https://msdn.microsoft.com/en-us/library/ms180169(v=sql.120).aspx +--DECLARE cursor_name [ INSENSITIVE ] [ SCROLL ] CURSOR +-- FOR select_statement +-- [ FOR { READ ONLY | UPDATE [ OF column_name [ ,...n ] ] } ] +--[;] +--Transact-SQL Extended Syntax +--DECLARE cursor_name CURSOR [ LOCAL | GLOBAL ] +-- [ FORWARD_ONLY | SCROLL ] +-- [ STATIC | KEYSET | DYNAMIC | FAST_FORWARD ] +-- [ READ_ONLY | SCROLL_LOCKS | OPTIMISTIC ] +-- [ TYPE_WARNING ] +-- FOR select_statement +-- [ FOR UPDATE [ OF column_name [ ,...n ] ] ] +--[;] + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using simple cursor and syntax + +DECLARE vend_cursor CURSOR + FOR SELECT * FROM Purchasing.Vendor +OPEN vend_cursor +FETCH NEXT FROM vend_cursor; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using nested cursors to produce report output + +SET NOCOUNT ON; + +DECLARE @vendor_id int, @vendor_name nvarchar(50), + @message varchar(80), @product nvarchar(50); + +PRINT '-------- Vendor Products Report --------'; + +DECLARE vendor_cursor CURSOR FOR +SELECT VendorID, Name +FROM Purchasing.Vendor +WHERE PreferredVendorStatus = 1 +ORDER BY VendorID; + +OPEN vendor_cursor + +FETCH NEXT FROM vendor_cursor +INTO @vendor_id, @vendor_name + +WHILE @@FETCH_STATUS = 0 +BEGIN + PRINT ' ' + SELECT @message = '----- Products From Vendor: ' + + @vendor_name + + PRINT @message + + -- Declare an inner cursor based + -- on vendor_id from the outer cursor. + + DECLARE product_cursor CURSOR FOR + SELECT v.Name + FROM Purchasing.ProductVendor pv, Production.Product v + WHERE pv.ProductID = v.ProductID AND + pv.VendorID = @vendor_id -- Variable value from the outer cursor + + OPEN product_cursor + FETCH NEXT FROM product_cursor INTO @product + + IF @@FETCH_STATUS <> 0 + PRINT ' <>' + + WHILE @@FETCH_STATUS = 0 + BEGIN + + SELECT @message = ' ' + @product + PRINT @message + FETCH NEXT FROM product_cursor INTO @product + END + + CLOSE product_cursor + DEALLOCATE product_cursor + -- Get the next vendor. + FETCH NEXT FROM vendor_cursor + INTO @vendor_id, @vendor_name +END +CLOSE vendor_cursor; +DEALLOCATE vendor_cursor; + +----------------------------------------------------------------------- +-- FETCH https://msdn.microsoft.com/en-us/library/ms180152(v=sql.120).aspx +--FETCH +-- [ [ NEXT | PRIOR | FIRST | LAST +-- | ABSOLUTE { n | @nvar } +-- | RELATIVE { n | @nvar } +-- ] +-- FROM +-- ] +--{ { [ GLOBAL ] cursor_name } | @cursor_variable_name } +--[ INTO @variable_name [ ,...n ] ] + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using FETCH in a simple cursor + +USE AdventureWorks2012; +GO +DECLARE contact_cursor CURSOR FOR +SELECT LastName FROM Person.Person +WHERE LastName LIKE 'B%' +ORDER BY LastName; + +OPEN contact_cursor; + +-- Perform the first fetch. +FETCH NEXT FROM contact_cursor; + +-- Check @@FETCH_STATUS to see if there are any more rows to fetch. +WHILE @@FETCH_STATUS = 0 +BEGIN + -- This is executed as long as the previous fetch succeeds. + FETCH NEXT FROM contact_cursor; +END + +CLOSE contact_cursor; +DEALLOCATE contact_cursor; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using FETCH to store values in variables + +USE AdventureWorks2012; +GO +-- Declare the variables to store the values returned by FETCH. +DECLARE @LastName varchar(50), @FirstName varchar(50); + +DECLARE contact_cursor CURSOR FOR +SELECT LastName, FirstName FROM Person.Person +WHERE LastName LIKE 'B%' +ORDER BY LastName, FirstName; + +OPEN contact_cursor; + +-- Perform the first fetch and store the values in variables. +-- Note: The variables are in the same order as the columns +-- in the SELECT statement. + +FETCH NEXT FROM contact_cursor +INTO @LastName, @FirstName; + +-- Check @@FETCH_STATUS to see if there are any more rows to fetch. +WHILE @@FETCH_STATUS = 0 +BEGIN + + -- Concatenate and display the current values in the variables. + PRINT 'Contact Name: ' + @FirstName + ' ' + @LastName + + -- This is executed as long as the previous fetch succeeds. + FETCH NEXT FROM contact_cursor + INTO @LastName, @FirstName; +END + +CLOSE contact_cursor; +DEALLOCATE contact_cursor; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Declaring a SCROLL cursor and using the other FETCH options + +USE AdventureWorks2012; +GO +-- Execute the SELECT statement alone to show the +-- full result set that is used by the cursor. +SELECT LastName, FirstName FROM Person.Person +ORDER BY LastName, FirstName; + +-- Declare the cursor. +DECLARE contact_cursor SCROLL CURSOR FOR +SELECT LastName, FirstName FROM Person.Person +ORDER BY LastName, FirstName; + +OPEN contact_cursor; + +-- Fetch the last row in the cursor. +FETCH LAST FROM contact_cursor; + +-- Fetch the row immediately prior to the current row in the cursor. +FETCH PRIOR FROM contact_cursor; + +-- Fetch the second row in the cursor. +FETCH ABSOLUTE 2 FROM contact_cursor; + +-- Fetch the row that is three rows after the current row. +FETCH RELATIVE 3 FROM contact_cursor; + +-- Fetch the row that is two rows prior to the current row. +FETCH RELATIVE -2 FROM contact_cursor; + +CLOSE contact_cursor; +DEALLOCATE contact_cursor; +GO + +----------------------------------------------------------------------- +-- OPEN https://msdn.microsoft.com/en-us/library/ms190500(v=sql.120).aspx +-- OPEN { { [ GLOBAL ] cursor_name } | cursor_variable_name } + +DECLARE Employee_Cursor CURSOR FOR +SELECT LastName, FirstName +FROM AdventureWorks2012.HumanResources.vEmployee +WHERE LastName like 'B%'; + +OPEN Employee_Cursor; + +FETCH NEXT FROM Employee_Cursor; +WHILE @@FETCH_STATUS = 0 +BEGIN + FETCH NEXT FROM Employee_Cursor +END; + +CLOSE Employee_Cursor; +DEALLOCATE Employee_Cursor; + +-- FAST_FORWARD can be after READ_ONLY + +DECLARE Employee_Cursor CURSOR READ_ONLY FAST_FORWARD FOR +SELECT LastName, FirstName +FROM AdventureWorks2012.HumanResources.vEmployee +WHERE LastName like 'B%'; + +OPEN Employee_Cursor; + +FETCH NEXT FROM Employee_Cursor; +WHILE @@FETCH_STATUS = 0 +BEGIN + FETCH NEXT FROM Employee_Cursor +END; + +CLOSE Employee_Cursor; +DEALLOCATE Employee_Cursor; + diff --git a/tsql/examples/database_engine_stored_procedures.sql b/tsql/examples/database_engine_stored_procedures.sql new file mode 100644 index 0000000..005d322 --- /dev/null +++ b/tsql/examples/database_engine_stored_procedures.sql @@ -0,0 +1,36 @@ +-- sp_executesql +DECLARE @IntVariable INT; +DECLARE @SQLString NVARCHAR(500); +DECLARE @ParmDefinition NVARCHAR(500); + +-- Build the SQL string one time. +SET @SQLString = + N'SELECT BusinessEntityID, NationalIDNumber, JobTitle, LoginID + FROM AdventureWorks2012.HumanResources.Employee + WHERE BusinessEntityID = @BusinessEntityID'; +SET @ParmDefinition = N'@BusinessEntityID tinyint'; +-- Execute the string with the first parameter value. +SET @IntVariable = 197; +EXECUTE sp_executesql @SQLString, @ParmDefinition, + @BusinessEntityID = @IntVariable; + -- Execute the same string with the second parameter value. +SET @IntVariable = 109; +EXECUTE sp_executesql @SQLString, @ParmDefinition, + @BusinessEntityID = @IntVariable; + +GO + +DECLARE @IntVariable INT; +DECLARE @SQLString NVARCHAR(500); +DECLARE @ParmDefinition NVARCHAR(500); +DECLARE @max_title VARCHAR(30); + +SET @IntVariable = 197; +SET @SQLString = N'SELECT @max_titleOUT = max(JobTitle) + FROM AdventureWorks2012.HumanResources.Employee + WHERE BusinessEntityID = @level'; +SET @ParmDefinition = N'@level TINYINT, @max_titleOUT VARCHAR(30) OUTPUT'; + +EXECUTE sp_executesql @SQLString, @ParmDefinition, @level = @IntVariable, @max_titleOUT=@max_title OUTPUT; +SELECT @max_title; +GO diff --git a/tsql/examples/database_hadr.sql b/tsql/examples/database_hadr.sql new file mode 100644 index 0000000..b2cc9e7 --- /dev/null +++ b/tsql/examples/database_hadr.sql @@ -0,0 +1 @@ +ALTER DATABASE AccountsDb1 SET HADR AVAILABILITY GROUP = AccountsAG; diff --git a/tsql/examples/db_roles.sql b/tsql/examples/db_roles.sql new file mode 100644 index 0000000..a32ea4e --- /dev/null +++ b/tsql/examples/db_roles.sql @@ -0,0 +1,7 @@ +ALTER ROLE buyers WITH NAME = purchasing; +ALTER ROLE Sales ADD MEMBER Barry; +ALTER ROLE Sales DROP MEMBER Barry; +CREATE ROLE buyers AUTHORIZATION BenMiller; +GO +CREATE ROLE auditors AUTHORIZATION db_securityadmin; +GO diff --git a/tsql/examples/dbcc.sql b/tsql/examples/dbcc.sql new file mode 100644 index 0000000..53391c8 --- /dev/null +++ b/tsql/examples/dbcc.sql @@ -0,0 +1,111 @@ +-- Check the current database. +DBCC CHECKALLOC; +GO +-- Check the AdventureWorks2022 database. +DBCC CHECKALLOC (AdventureWorks2022); +GO +DBCC CHECKALLOC ([AdventureWorks2022]) WITH ALL_ERRORMSGS, ESTIMATEONLY; +GO +DBCC CHECKALLOC (0) +GO + +-- Check the current database. +DBCC CHECKCATALOG; +GO +-- Check the AdventureWorks database. +DBCC CHECKCATALOG (AdventureWorks2022); +GO +DBCC CHECKCATALOG (AdventureWorks2022) WITH NO_INFOMSGS; +GO +DBCC CHECKCATALOG (0) +GO + +DBCC CHECKCONSTRAINTS (Table1); +GO +DBCC CHECKCONSTRAINTS ('Production.CK_ProductCostHistory_EndDate'); +GO +DBCC CHECKCONSTRAINTS WITH ALL_CONSTRAINTS; +GO +DBCC CHECKCONSTRAINTS (Table1) WITH NO_INFOMSGS, ALL_ERRORMSGS, ALL_CONSTRAINTS; +GO + +-- Check the current database. +DBCC CHECKDB; +GO +-- Check the AdventureWorks2019 database without nonclustered indexes. +DBCC CHECKDB (AdventureWorks2019, NOINDEX); +GO +DBCC CHECKDB WITH NO_INFOMSGS; +GO +DBCC CHECKDB (0) +GO + +DBCC CHECKFILEGROUP; +GO +DBCC CHECKFILEGROUP (1, NOINDEX); +GO +DBCC CHECKFILEGROUP (N'PRIMARY', REPAIR_ALLOW_DATA_LOSS) WITH NO_INFOMSGS, ALL_ERRORMSGS; +GO + +DBCC CHECKTABLE ('HumanResources.Employee'); +GO +DECLARE @indid int; +SET @indid = (SELECT index_id + FROM sys.indexes + WHERE object_id = OBJECT_ID('Production.Product') + AND name = 'AK_Product_Name'); +DBCC CHECKTABLE ('Production.Product',@indid); +GO + +DBCC CLEANTABLE (AdventureWorks2019, 'Production.Document', 0) +WITH NO_INFOMSGS; +GO +DBCC CLEANTABLE (AdventureWorks2022, 'dbo.CleanTableTest'); +GO +DBCC CLEANTABLE (0, 'Production.Document') +GO + +DBCC CLONEDATABASE (AdventureWorks2022, AdventureWorks_Clone); +GO +DBCC CLONEDATABASE (AdventureWorks2022, AdventureWorks_Clone) WITH NO_STATISTICS; +GO +DBCC CLONEDATABASE (AdventureWorks2022, AdventureWorks_Clone) WITH NO_STATISTICS, NO_QUERYSTORE; +GO +DBCC CLONEDATABASE (AdventureWorks2022, AdventureWorks_Clone) WITH VERIFY_CLONEDB; +GO +DBCC CLONEDATABASE (AdventureWorks2022, AdventureWorks_Clone) WITH VERIFY_CLONEDB, BACKUP_CLONEDB; +GO + +DBCC DBREINDEX ('HumanResources.Employee', PK_Employee_BusinessEntityID, 80); +GO +DBCC DBREINDEX ('HumanResources.Employee', ' ', 70); +GO + +DBCC xp_sample (FREE); +GO + +DBCC DROPCLEANBUFFERS +GO + +DBCC PROCCACHE WITH NO_INFOMSGS; + +DBCC SHOWCONTIG ('HumanResources.Employee'); +GO +DBCC SHOWCONTIG (@id, @indid); +GO +DBCC SHOWCONTIG ('Production.Product', 1) WITH FAST; +GO +DBCC SHOWCONTIG WITH TABLERESULTS, ALL_INDEXES; +GO + +DBCC SHRINKLOG ( SIZE = 100 MB ); +DBCC SHRINKLOG ( SIZE = DEFAULT ); +DBCC SHRINKLOG; + +-- Uses AdventureWorks2022 +DBCC PDW_SHOWSPACEUSED ( "AdventureWorksPDW2012.dbo.FactInternetSales" ); +DBCC PDW_SHOWSPACEUSED ( "AdventureWorksPDW2012..FactInternetSales" ); +DBCC PDW_SHOWSPACEUSED ( "dbo.FactInternetSales" ); +DBCC PDW_SHOWSPACEUSED ( FactInternetSales ); +-- Uses AdventureWorks2022 +DBCC PDW_SHOWSPACEUSED; diff --git a/tsql/examples/ddl_alter_database.sql b/tsql/examples/ddl_alter_database.sql new file mode 100644 index 0000000..aa3d27e --- /dev/null +++ b/tsql/examples/ddl_alter_database.sql @@ -0,0 +1,3 @@ +ALTER DATABASE AdventureWorks2012 +SET CHANGE_TRACKING = ON +(CHANGE_RETENTION = 2 DAYS, AUTO_CLEANUP = ON) ; diff --git a/tsql/examples/ddl_alter_database_audit_specification.sql b/tsql/examples/ddl_alter_database_audit_specification.sql new file mode 100644 index 0000000..622fe02 --- /dev/null +++ b/tsql/examples/ddl_alter_database_audit_specification.sql @@ -0,0 +1,5 @@ +ALTER DATABASE AUDIT SPECIFICATION HIPAA_Audit_DB_Specification + FOR SERVER AUDIT HIPAA_Audit + ADD (SELECT ON OBJECT::dbo.Table1 BY dbo) +WITH (STATE = ON); +GO diff --git a/tsql/examples/ddl_alter_database_mirroring.sql b/tsql/examples/ddl_alter_database_mirroring.sql new file mode 100644 index 0000000..c903f4a --- /dev/null +++ b/tsql/examples/ddl_alter_database_mirroring.sql @@ -0,0 +1,2 @@ +ALTER DATABASE ADVENTUREWORKS2012 SET PARTNER FAILOVER; +GO diff --git a/tsql/examples/ddl_alter_endpoint.sql b/tsql/examples/ddl_alter_endpoint.sql new file mode 100644 index 0000000..dfe45bd --- /dev/null +++ b/tsql/examples/ddl_alter_endpoint.sql @@ -0,0 +1,8 @@ +ALTER ENDPOINT ENDPOINT_MIRRORING + STATE = STARTED + AS TCP ( LISTENER_PORT = 7022 ) + FOR DATABASE_MIRRORING ( + AUTHENTICATION = WINDOWS KERBEROS, + ENCRYPTION = SUPPORTED, + ROLE=ALL); +GO diff --git a/tsql/examples/ddl_alter_service.sql b/tsql/examples/ddl_alter_service.sql new file mode 100644 index 0000000..a02fdec --- /dev/null +++ b/tsql/examples/ddl_alter_service.sql @@ -0,0 +1,9 @@ +ALTER SERVICE [//Adventure-Works.com/Expenses] + ON QUEUE NewQueue ; + +ALTER SERVICE [//Adventure-Works.com/Expenses] + (ADD CONTRACT [//Adventure-Works.com/Expenses/ExpenseSubmission]) ; + +ALTER SERVICE [//Adventure-Works.com/Expenses] + (ADD CONTRACT [//Adventure-Works.com/Expenses/ExpenseProcessing], + DROP CONTRACT [//Adventure-Works.com/Expenses/ExpenseSubmission]) ; diff --git a/tsql/examples/ddl_alter_table.sql b/tsql/examples/ddl_alter_table.sql new file mode 100644 index 0000000..ffa7f24 --- /dev/null +++ b/tsql/examples/ddl_alter_table.sql @@ -0,0 +1,3 @@ +ALTER TABLE t_order_item + ADD PRIMARY KEY (order_id), FOREIGN KEY (order_id) REFERENCES t_order (order_id) + ON UPDATE CASCADE ON DELETE CASCADE ; diff --git a/tsql/examples/ddl_alter_view.sql b/tsql/examples/ddl_alter_view.sql new file mode 100644 index 0000000..0784244 --- /dev/null +++ b/tsql/examples/ddl_alter_view.sql @@ -0,0 +1,7 @@ +ALTER VIEW HumanResources.EmployeeHireDate +AS +SELECT p.FirstName, p.LastName, e.HireDate +FROM HumanResources.Employee AS e JOIN Person.Person AS p + ON e.BusinessEntityID = p.BusinessEntityID +WHERE HireDate < CONVERT(DATETIME,'20020101',101) ; +GO diff --git a/tsql/examples/ddl_alter_xml_schema_collection.sql b/tsql/examples/ddl_alter_xml_schema_collection.sql new file mode 100644 index 0000000..b246277 --- /dev/null +++ b/tsql/examples/ddl_alter_xml_schema_collection.sql @@ -0,0 +1,12 @@ +CREATE XML SCHEMA COLLECTION MyColl AS ' + + + ' +-- Modify the collection. +ALTER XML SCHEMA COLLECTION MyColl ADD ' + + + '; diff --git a/tsql/examples/ddl_create_alter_database.sql b/tsql/examples/ddl_create_alter_database.sql new file mode 100644 index 0000000..84f05a6 --- /dev/null +++ b/tsql/examples/ddl_create_alter_database.sql @@ -0,0 +1,236 @@ +USE [master] +GO + +/****** Object: Database [TestDb] Script Date: 21/06/2016 07:38:14 ******/ +CREATE DATABASE [TestDb] + CONTAINMENT = NONE + ON PRIMARY +( NAME = N'TestDb', FILENAME = N'C:\Program Files\Microsoft SQL Server\MSSQL12.SQLEXPRESS\MSSQL\DATA\TestDb.mdf' , SIZE = 4288KB , MAXSIZE = UNLIMITED, FILEGROWTH = 1024KB ) + LOG ON +( NAME = N'TestDb_log', FILENAME = N'C:\Program Files\Microsoft SQL Server\MSSQL12.SQLEXPRESS\MSSQL\DATA\TestDb_log.ldf' , SIZE = 1072KB , MAXSIZE = 2048GB , FILEGROWTH = 10%) +GO + +ALTER DATABASE [TestDb] SET COMPATIBILITY_LEVEL = 120 +GO + +ALTER DATABASE [TestDb] SET ANSI_NULL_DEFAULT OFF +GO + +ALTER DATABASE [TestDb] SET ANSI_NULLS OFF +GO + +ALTER DATABASE [TestDb] SET ANSI_PADDING OFF +GO + +ALTER DATABASE [TestDb] SET ANSI_WARNINGS OFF +GO + +ALTER DATABASE [TestDb] SET ARITHABORT OFF +GO + +ALTER DATABASE [TestDb] SET AUTO_CLOSE OFF +GO + +ALTER DATABASE [TestDb] SET AUTO_SHRINK OFF +GO + +ALTER DATABASE [TestDb] SET AUTO_UPDATE_STATISTICS ON +GO + +ALTER DATABASE [TestDb] SET CURSOR_CLOSE_ON_COMMIT OFF +GO + +ALTER DATABASE [TestDb] SET CURSOR_DEFAULT GLOBAL +GO + +ALTER DATABASE [TestDb] SET CONCAT_NULL_YIELDS_NULL OFF +GO + +ALTER DATABASE [TestDb] SET NUMERIC_ROUNDABORT OFF +GO + +ALTER DATABASE [TestDb] SET QUOTED_IDENTIFIER OFF +GO + +ALTER DATABASE [TestDb] SET RECURSIVE_TRIGGERS OFF +GO + +ALTER DATABASE [TestDb] SET ENABLE_BROKER +GO + +ALTER DATABASE [TestDb] SET AUTO_UPDATE_STATISTICS_ASYNC OFF +GO + +ALTER DATABASE [TestDb] SET DATE_CORRELATION_OPTIMIZATION OFF +GO + +ALTER DATABASE [TestDb] SET TRUSTWORTHY OFF +GO + +ALTER DATABASE [TestDb] SET ALLOW_SNAPSHOT_ISOLATION OFF +GO + +ALTER DATABASE [TestDb] SET PARAMETERIZATION SIMPLE +GO + +ALTER DATABASE [TestDb] SET READ_COMMITTED_SNAPSHOT OFF +GO + +ALTER DATABASE [TestDb] SET HONOR_BROKER_PRIORITY OFF +GO + +ALTER DATABASE [TestDb] SET RECOVERY SIMPLE +GO + +ALTER DATABASE [TestDb] SET MULTI_USER +GO + +ALTER DATABASE [TestDb] SET PAGE_VERIFY CHECKSUM +GO + +ALTER DATABASE [TestDb] SET DB_CHAINING OFF +GO + +ALTER DATABASE [TestDb] SET FILESTREAM( NON_TRANSACTED_ACCESS = OFF ) +GO + +ALTER DATABASE [TestDb] SET TARGET_RECOVERY_TIME = 0 SECONDS +GO + +ALTER DATABASE [TestDb] SET DELAYED_DURABILITY = DISABLED +GO + +ALTER DATABASE [TestDb] SET READ_WRITE +GO + +ALTER DATABASE [TestDb] SET ACCELERATED_DATABASE_RECOVERY = OFF +GO + +USE master; +GO +CREATE DATABASE FileStreamDB +ON PRIMARY + ( + NAME = FileStreamDB_data + ,FILENAME = '' + ,SIZE = 10MB + ,MAXSIZE = 50MB + ,FILEGROWTH = 15% + ), +FILEGROUP FileStreamPhotos CONTAINS FILESTREAM DEFAULT + ( + NAME = FSPhotos + ,FILENAME = 'C:\MyFSfolderPhotos' +, MAXSIZE = 5000 MB + ), + ( + NAME = FSPhotos2 + , FILENAME = 'D:\MyFSfolderPhotos' + , MAXSIZE = 10000 MB + ), +FILEGROUP FileStreamResumes CONTAINS FILESTREAM + ( + NAME = FileStreamResumes + ,FILENAME = 'C:\MyFSfolderResumes' + ) +LOG ON + ( + NAME = FileStream_log + ,FILENAME = 'FileStreamDB_log.ldf' + ,SIZE = 5MB + ,MAXSIZE = 25MB + ,FILEGROWTH = 5MB + ) +GO + +-- https://docs.microsoft.com/en-us/sql/t-sql/statements/alter-database-transact-sql-file-and-filegroup-options?view=sql-server-ver15 +ALTER DATABASE AdventureWorks2012 +ADD FILE +( + NAME = Test1dat2, + FILENAME = 'C:\Program Files\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\DATA\t1dat2.ndf', + SIZE = 5MB, + MAXSIZE = 100MB, + FILEGROWTH = 5MB +); +GO + +ALTER DATABASE AdventureWorks2012 +ADD FILEGROUP Test1FG1; +GO + +ALTER DATABASE AdventureWorks2012 +ADD FILE +( + NAME = test1dat3, + FILENAME = 'C:\Program Files\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\DATA\t1dat3.ndf', + SIZE = 5MB, + MAXSIZE = 100MB, + FILEGROWTH = 5MB +), +( + NAME = test1dat4, + FILENAME = 'C:\Program Files\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\DATA\t1dat4.ndf', + SIZE = 5MB, + MAXSIZE = 100MB, + FILEGROWTH = 5MB +) +TO FILEGROUP Test1FG1; +GO + +ALTER DATABASE AdventureWorks2012 +ADD LOG FILE +( + NAME = test1log2, + FILENAME = 'C:\Program Files\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\DATA\test2log.ldf', + SIZE = 5MB, + MAXSIZE = 100MB, + FILEGROWTH = 5MB +), +( + NAME = test1log3, + FILENAME = 'C:\Program Files\Microsoft SQL Server\MSSQL10_50.MSSQLSERVER\MSSQL\DATA\test3log.ldf', + SIZE = 5MB, + MAXSIZE = 100MB, + FILEGROWTH = 5MB +); +GO + +ALTER DATABASE AdventureWorks2012 +REMOVE FILE test1dat4; +GO + +ALTER DATABASE AdventureWorks2012 +MODIFY FILE (NAME = test1dat3, SIZE = 200MB); +GO + +ALTER DATABASE AdventureWorks2012 +MODIFY FILE +( + NAME = Test1dat2, + FILENAME = N'c:\t1dat2.ndf' +); +GO + +ALTER DATABASE AdventureWorks2012 +MODIFY FILEGROUP Test1FG1 DEFAULT; +GO + +ALTER DATABASE AdventureWorks2012 +MODIFY FILEGROUP [PRIMARY] DEFAULT; +GO + +ALTER DATABASE xtp_db +ADD FILEGROUP xtp_fg +CONTAINS MEMORY_OPTIMIZED_DATA; +GO + +--Add a file for storing memory optimized data to FILEGROUP +ALTER DATABASE xtp_db +ADD FILE +( + NAME='xtp_mod', + FILENAME='d:\data\xtp_mod' +) +TO FILEGROUP xtp_fg; +GO diff --git a/tsql/examples/ddl_create_database_audit_specification.sql b/tsql/examples/ddl_create_database_audit_specification.sql new file mode 100644 index 0000000..8f5fd74 --- /dev/null +++ b/tsql/examples/ddl_create_database_audit_specification.sql @@ -0,0 +1,6 @@ +CREATE DATABASE AUDIT SPECIFICATION Audit_Pay_Tables +FOR SERVER AUDIT Payrole_Security_Audit +ADD (SELECT , INSERT + ON HumanResources.EmployeePayHistory BY public ) +WITH (STATE = ON) ; +GO diff --git a/tsql/examples/ddl_create_drop_type.sql b/tsql/examples/ddl_create_drop_type.sql new file mode 100644 index 0000000..bf1f5e7 --- /dev/null +++ b/tsql/examples/ddl_create_drop_type.sql @@ -0,0 +1,12 @@ +IF EXISTS (SELECT * FROM sys.types st JOIN sys.schemas ss ON st.schema_id = ss.schema_id WHERE st.name = N'udt_pk' AND ss.name = N'dbo') +DROP TYPE [dbo].[udt_pk] +go + +CREATE TYPE [dbo].[udt_pk] FROM [uniqueidentifier] NULL +go + +-- Creating a user-defined table type +CREATE TYPE LocationTableType AS TABLE + ( LocationName VARCHAR(50) + , CostRate INT ); +GO diff --git a/tsql/examples/ddl_create_table.sql b/tsql/examples/ddl_create_table.sql new file mode 100644 index 0000000..f14fe19 --- /dev/null +++ b/tsql/examples/ddl_create_table.sql @@ -0,0 +1,63 @@ +-- create table with foreign key +CREATE TABLE dbo.Employee ( + EmployeeID int PRIMARY KEY CLUSTERED, + SalesPersonID int NULL REFERENCES SalesPerson(SalesPersonID) +); +GO; + +-- create table and with table constraint +CREATE TABLE dbo.Employee ( + EmployeeID int PRIMARY KEY CLUSTERED, + ProductID int, + SpecialOfferID int, + CONSTRAINT FK_SpecialOfferProduct_SalesOrderDetail FOREIGN KEY ( + ProductID, SpecialOfferID) + REFERENCES SpecialOfferProduct ( + ProductID, SpecialOfferID) +); +GO; + +-- create table with multiple column constratints +CREATE TABLE [#TestTable] ( + [ID] INT PRIMARY KEY NOT NULL +) WITH (DATA_COMPRESSION = PAGE); +GO; + +-- name these constratints +CREATE TABLE [#TestTable] ( + [ID] INT constraint pk PRIMARY KEY constraint notnull NOT NULL +) WITH (DATA_COMPRESSION = PAGE); +GO; + +-- create table with multiple columns and constraints +CREATE TABLE [#TestTable] ( + [ID] INT PRIMARY KEY NOT NULL, + [Name] NVARCHAR(64) NOT NULL +) WITH (DATA_COMPRESSION = PAGE); +GO; + +-- create table with materialized column +create table xyz ( + ccc char(1), + xxx numeric(18,0) NULL, + yyy numeric(10,2) NULL, + zzz as cast(round(xxx / yyy, 0) as numeric(18,0)) materialized, + constraint pk primary key clustered (ccc) +) +go + +-- non clustered index +create table #t ( + id varchar(50) not null index ix2 nonclustered, + other_id uniqueidentifier not null index ix1 clustered, + value float +) +go + +-- table with partition scheme +CREATE TABLE dbo.PartitionTable ( + process_date datetime PRIMARY KEY, + process_type char(10) +) +ON MyRangePS1 (process_date) +GO diff --git a/tsql/examples/ddl_create_view.sql b/tsql/examples/ddl_create_view.sql new file mode 100644 index 0000000..4dbe478 --- /dev/null +++ b/tsql/examples/ddl_create_view.sql @@ -0,0 +1,22 @@ +--https://learn.microsoft.com/en-US/sql/t-sql/statements/create-view-transact-sql?view=sql-server-2016 +CREATE OR ALTER VIEW xyz_view +AS +SELECT + ccc, + xxx, + yyy + zzz +FROM xyz +; +GO + +CREATE OR REPLACE VIEW xyz_view +AS +SELECT + ccc, + xxx, + yyy + zzz +FROM xyz +; +GO \ No newline at end of file diff --git a/tsql/examples/ddl_function.sql b/tsql/examples/ddl_function.sql new file mode 100644 index 0000000..f746793 --- /dev/null +++ b/tsql/examples/ddl_function.sql @@ -0,0 +1,51 @@ + +--create function return table , no BEGIN and END in this case +create function Test (@TZ int) +returns table +as +return +( + select 1 AS s FROM dbo.Table1 +) +GO + +--create function return date_type +Create Function dbo.FooBar( + @p1 nVarchar(4000) +) +Returns int +As +Begin + return 123; +END +GO + +--create function return @val table +CREATE OR ALTER FUNCTION [dbo].[Foo](@String nvarchar(4000)) +RETURNS @Bar TABLE (Col1 nvarchar(4000)) +AS + BEGIN + + RETURN +END +GO + +--Alter Function, should behave the same as create function, except the ALTER keyword +ALTER FUNCTION [dbo].[Foo](@String nvarchar(4000)) +RETURNS @Bar TABLE (Col1 nvarchar(4000)) +AS + BEGIN + + RETURN +END +GO + +CREATE FUNCTION [dbo].[functionName](@par [nvarchar](10)) +RETURNS [bit] WITH EXECUTE AS CALLER, RETURNS NULL ON NULL INPUT +AS +EXTERNAL NAME [assembly_name].[class_name].[method_name] +GO + +--drop Function, you can drop multiple at same time +Drop function Func1 +drop function Func1 , Func2 diff --git a/tsql/examples/ddl_index.sql b/tsql/examples/ddl_index.sql new file mode 100644 index 0000000..9649e60 --- /dev/null +++ b/tsql/examples/ddl_index.sql @@ -0,0 +1,193 @@ +-- Create a nonclustered index on a table or view +CREATE INDEX i1 ON t1 (col1); + +--Create a clustered index on a table and use a 3-part name for the table +CREATE CLUSTERED INDEX i1 ON d1.s1.t1 (col1); + +-- Create a nonclustered index with a unique constraint on 3 columns and specify the sort order for each column +CREATE UNIQUE INDEX i1 ON t1 (col1 DESC, col2 ASC, col3 DESC); + +-- Create a nonclustered index with a unique constraint on 3 columns and specify the sort order for each column +CREATE UNIQUE INDEX i1 ON t1 (col1 DESC, col2 ASC, col3 DESC); + +CREATE NONCLUSTERED INDEX IX_Address_PostalCode + ON Person.Address (PostalCode) + INCLUDE (AddressLine1, AddressLine2, City, StateProvinceID); + +-- filtered index +CREATE NONCLUSTERED INDEX IX_BillOfMaterials_ComponentID + ON Production.BillOfMaterials (ComponentID, StartDate) + WHERE EndDate IS NOT NULL ; + +-- this feature will be deprecated in future version of tsql +-- but need to support in case someone want to capture this and throw a warning +DROP INDEX tbl.idx_tbl_col; + +DROP INDEX IX_ProductVendor_BusinessEntityID + ON Purchasing.ProductVendor; +GO +CREATE CLUSTERED COLUMNSTORE INDEX [indexName] ON [dbo].[table] WITH (DROP_EXISTING = OFF) ON [filegroup_name] +GO +CREATE NONCLUSTERED INDEX [indexName] ON [dbo].[table] +( + [Column1] ASC +) +INCLUDE ([ColumnName2],[ColumnName3]) WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, FILLFACTOR = 95) ON [filegroup_name] +GO + +ALTER INDEX [indexname] ON [schema].[tableName] DISABLE +GO + +ALTER INDEX [indexName] ON [dbo].[tbl] REBUILD PARTITION = ALL +GO + +ALTER INDEX index1 ON table1 REBUILD; + +ALTER INDEX ALL ON table1 REBUILD; + +ALTER INDEX ALL ON dbo.table1 REBUILD; + +CREATE CLUSTERED COLUMNSTORE INDEX idxcci_cci_target ON cci_target; + +ALTER INDEX idxcci_cci_target ON cci_target REORGANIZE WITH (COMPRESS_ALL_ROW_GROUPS = ON); + +ALTER INDEX idxcci_cci_target ON cci_target REORGANIZE WITH (COMPRESS_ALL_ROW_GROUPS = ON); + +ALTER INDEX cci_FactInternetSales2 ON FactInternetSales2 REORGANIZE; + +-- REORGANIZE a specific partition +ALTER INDEX cci_FactInternetSales2 ON FactInternetSales2 REORGANIZE PARTITION = 0; + +ALTER INDEX cci_FactInternetSales2 ON FactInternetSales2 REORGANIZE WITH (COMPRESS_ALL_ROW_GROUPS = ON); + +ALTER INDEX cci_FactInternetSales2 ON FactInternetSales2 REORGANIZE PARTITION = 0 WITH (COMPRESS_ALL_ROW_GROUPS = ON); + +CREATE CLUSTERED COLUMNSTORE INDEX cci_FactInternetSales2 +ON dbo.FactInternetSales2; + +ALTER INDEX cci_FactInternetSales2 ON FactInternetSales2 REBUILD; + +ALTER INDEX cci_fact3 +ON fact3 +REBUILD PARTITION = 12; + +CREATE CLUSTERED INDEX cci_SimpleTable ON SimpleTable (ProductKey); + +CREATE CLUSTERED COLUMNSTORE INDEX cci_SimpleTable +ON SimpleTable +WITH (DROP_EXISTING = ON); + +--Compress the table further by using archival compression. +ALTER INDEX cci_SimpleTable ON SimpleTable +REBUILD +WITH (DATA_COMPRESSION = COLUMNSTORE_ARCHIVE); +GO + +ALTER INDEX cci_SimpleTable ON SimpleTable +REBUILD +WITH (DATA_COMPRESSION = COLUMNSTORE); +GO + +ALTER INDEX PK_Employee_EmployeeID ON HumanResources.Employee REBUILD; + +ALTER INDEX ALL ON Production.Product +REBUILD WITH (FILLFACTOR = 80, SORT_IN_TEMPDB = ON, STATISTICS_NORECOMPUTE = ON); + +ALTER INDEX ALL ON Production.Product +REBUILD WITH +( + FILLFACTOR = 80, + SORT_IN_TEMPDB = ON, + STATISTICS_NORECOMPUTE = ON, + ONLINE = ON ( WAIT_AT_LOW_PRIORITY ( MAX_DURATION = 4 MINUTES, ABORT_AFTER_WAIT = BLOCKERS ) ), + DATA_COMPRESSION = ROW +); + +ALTER INDEX PK_ProductPhoto_ProductPhotoID ON Production.ProductPhoto REORGANIZE WITH (LOB_COMPACTION = ON); + +ALTER INDEX AK_SalesOrderHeader_SalesOrderNumber ON + Sales.SalesOrderHeader +SET ( + STATISTICS_NORECOMPUTE = ON, + IGNORE_DUP_KEY = ON, + ALLOW_PAGE_LOCKS = ON + ) ; +GO + +ALTER INDEX IX_Employee_ManagerID ON HumanResources.Employee DISABLE; + +ALTER INDEX PK_Department_DepartmentID ON HumanResources.Department DISABLE; + +ALTER INDEX PK_Department_DepartmentID ON HumanResources.Department REBUILD; + +--Rebuild only partition 5. +ALTER INDEX IX_TransactionHistory_TransactionDate +ON Production.TransactionHistory +REBUILD Partition = 5 + WITH (ONLINE = ON (WAIT_AT_LOW_PRIORITY (MAX_DURATION = 10 minutes, ABORT_AFTER_WAIT = SELF))); +GO + +ALTER INDEX IX_INDEX1 +ON T1 +REBUILD +WITH (DATA_COMPRESSION = PAGE); +GO + +ALTER INDEX IX_INDEX1 +ON T1 +REBUILD +WITH (XML_COMPRESSION = ON); +GO + +ALTER INDEX test_idx on test_table REBUILD WITH (ONLINE = ON, MAXDOP = 1, RESUMABLE = ON) ; + +ALTER INDEX test_idx on test_table REBUILD WITH (ONLINE = ON, RESUMABLE = ON, MAX_DURATION = 240) ; + +ALTER INDEX test_idx on test_table PAUSE ; + +ALTER INDEX test_idx on test_table RESUME WITH (MAXDOP = 4) ; + +ALTER INDEX test_idx on test_table + RESUME WITH (MAXDOP = 2, MAX_DURATION = 240 MINUTES, + WAIT_AT_LOW_PRIORITY (MAX_DURATION = 10, ABORT_AFTER_WAIT = BLOCKERS)) ; + +ALTER INDEX test_idx on test_table ABORT ; + +-- Spatial Index Examples +-- Basic spatial indexes +CREATE SPATIAL INDEX IX_Spatial_Geometry ON SpatialTable (GeometryColumn) USING GEOMETRY_AUTO_GRID; +CREATE SPATIAL INDEX IX_Spatial_Geography ON SpatialTable (GeographyColumn) USING GEOGRAPHY_AUTO_GRID; + +-- Spatial indexes with options +CREATE SPATIAL INDEX IX_Spatial_BoundingBox ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (BOUNDING_BOX = (-180, -90, 180, 90)); + +CREATE SPATIAL INDEX IX_Spatial_GridLevels ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = MEDIUM, LEVEL_3 = LOW, LEVEL_4 = LOW)); + +CREATE SPATIAL INDEX IX_Spatial_CellsPerObject ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (CELLS_PER_OBJECT = 16); + +-- Complex spatial index with multiple options +CREATE SPATIAL INDEX IX_Spatial_Complex ON dbo.SpatialTable (LocationColumn) +USING GEOMETRY_GRID +WITH ( + BOUNDING_BOX = (0, 0, 1000, 1000), + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM, LEVEL_4 = LOW), + CELLS_PER_OBJECT = 64, + PAD_INDEX = ON, + FILLFACTOR = 90, + SORT_IN_TEMPDB = ON +) +ON [SPATIAL_DATA]; + +-- Geography spatial index with schema-qualified table +CREATE SPATIAL INDEX IX_Geographic_Locations ON [GIS].[WorldLocations] ([Coordinates]) +USING GEOGRAPHY_GRID +WITH ( + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM), + CELLS_PER_OBJECT = 128 +); diff --git a/tsql/examples/ddl_procedures.sql b/tsql/examples/ddl_procedures.sql new file mode 100644 index 0000000..e684488 --- /dev/null +++ b/tsql/examples/ddl_procedures.sql @@ -0,0 +1,62 @@ +create procedure a as begin + select 1 +end +go +create procedure b as begin + select 2 +end +go + +-- call stored procedure, name in local var +IF EXISTS (SELECT * FROM sys.objects WHERE type = 'P' AND name = 'TestSproc') + DROP PROCEDURE dbo.TestSproc +GO + +CREATE PROCEDURE dbo.TestSproc @Name nvarchar(30) AS SELECT @Name RETURN +GO + +DECLARE @SprocName nvarchar(64) = 'TestSproc'; +DECLARE @TestName nvarchar(64) = 'Foo' +DECLARE @Result nvarchar(64) +EXEC @Result = @SprocName @Name = @TestName; +SELECT @Result +GO + + +CREATE OR ALTER PROC What_DB_is_this +AS +SELECT DB_NAME() AS ThisDB; +GO + +CREATE procedure [schema].[stp] + @id int = 0 +AS +BEGIN + +SELECT * FROM ( + SELECT id + FROM table1 + + UNION ALL + + SELECT id + FROM table2 + + UNION ALL + + SELECT id + FROM table3 +) AS RESULT +END +GO + +CREATE PROCEDURE [DBO].[EXECUTEOLAP] @MY_PARAM NVARCHAR(MAX) +WITH EXECUTE AS OWNER +AS EXTERNAL NAME [MY_ASSEMBLY_NAME].[MY_NAMESPACE.MY_CLASS].[MY_METHOD] +go + +create or replace procedure dbo.a_procedure +as +select * from a_table t +go + diff --git a/tsql/examples/ddl_table.sql b/tsql/examples/ddl_table.sql new file mode 100644 index 0000000..4a03c1e --- /dev/null +++ b/tsql/examples/ddl_table.sql @@ -0,0 +1,236 @@ +-- Create Table With Index Option +CREATE TABLE dbo.TestTable ( + TableID uniqueidentifier NOT NULL, + Value nvarchar(64) NOT NULL + CONSTRAINT PK_TestTable_ID PRIMARY KEY (TableID) WITH (DATA_COMPRESSION = PAGE)) +GO + +-- Create Table With Index Option and Table Option +CREATE TABLE dbo.TestTable ( + TableID uniqueidentifier NOT NULL, + Value nvarchar(64) NOT NULL, + Name nvarchar(64) NOT NULL, + ModifiedDateUTC SMALLDATETIME, + CONSTRAINT UQ_TestTable_ID UNIQUE (Value) WITH (DATA_COMPRESSION = PAGE), + CONSTRAINT PK_TestTable_ID PRIMARY KEY (TableID, Name)) + WITH (DATA_COMPRESSION = PAGE) +GO + +-- Alter table drop constraint in transaction +IF NOT EXISTS (SELECT * FROM sys.columns cols + JOIN sys.types AS types ON cols.user_type_id = types.user_type_id +WHERE object_id = OBJECT_ID('dbo.TestTable') + AND cols.name = 'ModifiedDateUTC' + AND types.name = 'datetime') +BEGIN + BEGIN TRAN + ALTER TABLE dbo.TestTable DROP CONSTRAINT DF_ModifiedDate; + COMMIT TRAN +END +GO + +-- Alter table drop multiple constraints in transaction +IF NOT EXISTS (SELECT * FROM sys.columns cols + JOIN sys.types AS types ON cols.user_type_id = types.user_type_id +WHERE object_id = OBJECT_ID('dbo.TestTable') + AND cols.name = 'ModifiedDateUTC' + AND types.name = 'datetime') +BEGIN + BEGIN TRAN + ALTER TABLE dbo.TestTable DROP CONSTRAINT DF_ModifiedDate; + ALTER TABLE dbo.TestTable DROP CONSTRAINT UQ_TestTable_ID; + COMMIT TRAN +END +GO + +-- Alter table Add Constraint with Default +ALTER TABLE dbo.TestTable ADD CONSTRAINT DF_ModifiedDateUTC DEFAULT(GETUTCDATE()) FOR ModifiedDateUTC; +GO + +-- Alter table Alter Column +ALTER TABLE dbo.TestTable ALTER COLUMN ModifiedDateUTC DATETIME +GO + +-- Alter table Rebuild with Table Options +ALTER TABLE TestTable REBUILD WITH (DATA_COMPRESSION = PAGE, ONLINE=ON); +GO + +-- Make column row GUID column +ALTER TABLE TestTable ALTER COLUMN ModifiedDateUTC ADD ROWGUIDCOL; + +-- Make column not row GUID column +ALTER TABLE TestTable ALTER COLUMN ModifiedDateUTC DROP ROWGUIDCOL; + +-- Mark column persisted +ALTER TABLE TestTable ALTER COLUMN ModifiedDateUTC ADD PERSISTED; + +-- Mark column not persisted +ALTER TABLE TestTable ALTER COLUMN ModifiedDateUTC DROP PERSISTED; + +-- Mark column as not for replication +ALTER TABLE TestTable ALTER COLUMN ModifiedDateUTC ADD NOT FOR REPLICATION; + +-- Mark column as for replication +ALTER TABLE TestTable ALTER COLUMN ModifiedDateUTC DROP NOT FOR REPLICATION; + +-- Mark column sparse +ALTER TABLE TestTable ALTER COLUMN ModifiedDateUTC ADD SPARSE; + +-- Mark column non-sparse +ALTER TABLE TestTable ALTER COLUMN ModifiedDateUTC DROP SPARSE; + +-- Mark column hidden +ALTER TABLE TestTable ALTER COLUMN ModifiedDateUTC ADD HIDDEN; + +-- Mark column not hidden +ALTER TABLE TestTable ALTER COLUMN ModifiedDateUTC DROP HIDDEN; + +-- Mark column masked +ALTER TABLE TestTable ALTER COLUMN ModifiedDateUTC ADD MASKED; + +-- Mark column not masked +ALTER TABLE TestTable ALTER COLUMN ModifiedDateUTC DROP MASKED; + +-- Mark column masked with function +ALTER TABLE TestTable ALTER COLUMN ModifiedDateUTC ADD MASKED WITH (FUNCTION = 'default()'); + +-- Create Table with Specified Order in Constraint +CREATE TABLE [dbo].[TestTable] ( + TableID UNIQUEIDENTIFIER NOT NULL, + Value NVARCHAR(64) NOT NULL, + Name NVARCHAR(64) NOT NULL, + CONSTRAINT [PK_TestTable_Value] PRIMARY KEY CLUSTERED ( + [TableID] ASC, + [Value] ASC)) +GO + +-- Create Table with NOT NULL and DEFAULT Constraint +CREATE TABLE [dbo].[TestTable] ( + TableID UNIQUEIDENTIFIER NOT NULL, + Name NVARCHAR(64) NOT NULL, + Value BIT CONSTRAINT DF_TestTable_Value NOT NULL DEFAULT (0)) + WITH (DATA_COMPRESSION = PAGE) +GO + +-- Create Table with indices +CREATE TABLE [dbo].[TestTable] ( + Name NVARCHAR(64) NOT NULL, + K NVARCHAR(64) NOT NULL, + Value NVARCHAR(64) NOT NULL, + Guid NVARCHAR(64) NOT NULL, + index ix_name UNIQUE CLUSTERED (Name), + INDEX ix_k UNIQUE NONCLUSTERED (K), + INDEX ix_value NONCLUSTERED (Value), + INDEX ix_guid UNIQUE (Guid)) +GO + +-- Create Table with column store index +CREATE TABLE [dbo].[TestTable] ( + Name NVARCHAR(64) NOT NULL, + Value NVARCHAR(64) NOT NULL, + Guid NVARCHAR(64) NOT NULL, + index ix_store CLUSTERED COLUMNSTORE, + index ix_value_guid COLUMNSTORE (Value, Guid), + index ix_value_name NONCLUSTERED (Value, Name) +) + +-- Drop Column +IF EXISTS(SELECT * FROM sys.columns WHERE NAME = N'Name' AND Object_ID = Object_ID(N'dbo.TestTable')) +BEGIN + ALTER TABLE dbo.TestTable + DROP COLUMN Name +END +GO + +-- Drop Columns +ALTER TABLE dbo.TestTable + DROP COLUMN Name, Value +GO + +-- Drop Index Using Fully Qualified Name +DROP INDEX dbo.TestTable.UIX_TestTable_Name_Value +GO + +-- Alter Table Add Column With Default Constraint First +ALTER TABLE TestTable + ADD Value BIT + CONSTRAINT DF_TestTable_Value DEFAULT(0) NOT NULL +GO + +-- Alter Table Add Column With Null Constraint First +ALTER TABLE TestTable + ADD Value BIT + CONSTRAINT DF_TestTable_Value NOT NULL DEFAULT(0) +GO + +-- Alter Table Add Constraint To Column +ALTER TABLE dbo.TestTable + ADD CONSTRAINT DF_TestTable_Value DEFAULT(0) + FOR Value +GO + +-- Alter Table Add Constraint To Column +ALTER TABLE dbo.TestTable + ADD CONSTRAINT DF_TestTable_Value DEFAULT(0) + FOR Value + WITH VALUES +GO + +-- Alter Table Add Constraint To Column with extra parentheses +ALTER TABLE dbo.TestTable + ADD CONSTRAINT DF_TestTable_Value DEFAULT((0)) + FOR Value +GO +ALTER TABLE dbo.TestTable + ADD CONSTRAINT DF_TestTable_Value DEFAULT(((((0))))) + FOR Value +GO + +-- Alter Table Add Constraint With String Concatenation +ALTER TABLE dbo.TestTable + ADD CONSTRAINT DF_Name + DEFAULT('NONE_' + CONVERT(NVARCHAR(40),NEWID())) + FOR Name +GO + +ALTER TABLE dbo.TestTable WITH NOCHECK ADD CONSTRAINT [FK_NAME] FOREIGN KEY([StateId]) +REFERENCES dbo.TableState (ID) +ON UPDATE CASCADE +ON DELETE CASCADE +GO + +ALTER TABLE [dbo].[TestTable] WITH CHECK ADD FOREIGN KEY([StateId]) +REFERENCES [dbo].[TableState] ([Id]) +GO + +ALTER TABLE [dbo].[TestTable] ADD CONSTRAINT [constraintName] DEFAULT (NEXT VALUE FOR [dbo].[sequence]) FOR [ID] +GO + +ALTER TABLE [dbo].[TestTable] WITH CHECK ADD CONSTRAINT [constraintName] CHECK ([StartDate] < [EndDate]) +GO + +ALTER TABLE [dbo].[TestTable] NOCHECK CONSTRAINT [constraintName] +GO + +-- Alter Table Switch Partition +ALTER TABLE Source SWITCH PARTITION 1 TO Target PARTITION 1 +GO +ALTER TABLE Source SWITCH TO Target PARTITION 1 +GO +ALTER TABLE Source SWITCH PARTITION 1 TO Target WITH WAIT_AT_LOW_PRIORITY ( MAX_DURATION = 0 minutes, ABORT_AFTER_WAIT = NONE) +GO +ALTER TABLE Source SWITCH TO Target PARTITION $PARTITION.PF_TEST_DT( '20121201' ) +GO +-- Constraints +ALTER TABLE #t ADD CONSTRAINT PL_t PRIMARY KEY CLUSTERED (IDCol) + WITH ( + ALLOW_PAGE_LOCKS = ON, + ALLOW_ROW_LOCKS = ON) + ON "default" +GO +ALTER TABLE #t ADD CONSTRAINT [PK_#t] PRIMARY KEY CLUSTERED +( + Col1 asc, + Col2 asc +) WITH FILLFACTOR = 90 ON [PRIMARY] +GO diff --git a/tsql/examples/dml_delete.sql b/tsql/examples/dml_delete.sql new file mode 100644 index 0000000..8cd7339 --- /dev/null +++ b/tsql/examples/dml_delete.sql @@ -0,0 +1,181 @@ +----------------------------------------------------------------------- +-- DELETE https://msdn.microsoft.com/en-us/library/ms189835.aspx +-- [ WITH [ ,...n ] ] +-- DELETE + -- [ TOP ( expression ) [ PERCENT ] ] + -- [ FROM ] + -- { { table_alias + -- | + -- | rowset_function_limited + -- [ WITH ( table_hint_limited [ ...n ] ) ] } + -- | @table_variable + -- } + -- [ ] + -- [ FROM table_source [ ,...n ] ] + -- [ WHERE { + -- | { [ CURRENT OF + -- { { [ GLOBAL ] cursor_name } + -- | cursor_variable_name + -- } + -- ] + -- } + -- } + -- ] + -- [ OPTION ( [ ,...n ] ) ] +-- [; ] + +-- ::= +-- { + -- [ server_name.database_name.schema_name. + -- | database_name. [ schema_name ] . + -- | schema_name. + -- ] + -- table_or_view_name +-- } + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using DELETE with no WHERE clause + +DELETE FROM Sales.SalesPersonQuotaHistory; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the WHERE clause to delete a set of rows + +DELETE FROM Production.ProductCostHistory +WHERE StandardCost > 1000.00; +GO + +DELETE Production.ProductCostHistory +WHERE StandardCost BETWEEN 12.00 AND 14.00 + AND EndDate IS NULL; +PRINT 'Number of rows deleted is ' + CAST(@@ROWCOUNT as char(3)); + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using a cursor to determine the row to delete + +DECLARE complex_cursor CURSOR FOR + SELECT a.BusinessEntityID + FROM HumanResources.EmployeePayHistory AS a + WHERE RateChangeDate <> + (SELECT MAX(RateChangeDate) + FROM HumanResources.EmployeePayHistory AS b + WHERE a.BusinessEntityID = b.BusinessEntityID) ; +OPEN complex_cursor; +FETCH FROM complex_cursor; +DELETE FROM HumanResources.EmployeePayHistory +WHERE CURRENT OF complex_cursor; +CLOSE complex_cursor; +DEALLOCATE complex_cursor; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using joins and subqueries to data in one table to delete rows in another table + +DELETE FROM Sales.SalesPersonQuotaHistory +WHERE BusinessEntityID IN + (SELECT BusinessEntityID + FROM Sales.SalesPerson + WHERE SalesYTD > 2500000.00); +GO + +DELETE FROM Sales.SalesPersonQuotaHistory +FROM Sales.SalesPersonQuotaHistory AS spqh +INNER JOIN Sales.SalesPerson AS sp +ON spqh.BusinessEntityID = sp.BusinessEntityID +WHERE sp.SalesYTD > 2500000.00; +GO + +DELETE spqh + FROM + Sales.SalesPersonQuotaHistory AS spqh + INNER JOIN Sales.SalesPerson AS sp ON spqh.BusinessEntityID = sp.BusinessEntityID + WHERE + sp.SalesYTD > 2500000.00; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using TOP to limit the number of rows deleted + +DELETE TOP (20) +FROM Purchasing.PurchaseOrderDetail +WHERE DueDate < '20020701'; +GO + +DELETE FROM Purchasing.PurchaseOrderDetail +WHERE PurchaseOrderDetailID IN + (SELECT TOP 10 PurchaseOrderDetailID + FROM Purchasing.PurchaseOrderDetail + ORDER BY DueDate ASC); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Deleting data from a remote table by using a linked server + +USE master; +GO +-- Create a link to the remote data source. +-- Specify a valid server name for @datasrc as 'server_name' or 'server_name\instance_name'. + +EXEC sp_addlinkedserver @server = N'MyLinkServer', + @srvproduct = N' ', + @provider = N'SQLNCLI', + @datasrc = N'server_name', + @catalog = N'AdventureWorks2012'; +GO + +DELETE MyLinkServer.AdventureWorks2012.HumanResources.Department WHERE DepartmentID > 16; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Deleting data from a remote table by using the OPENQUERY function + +DELETE OPENQUERY (MyLinkServer, 'SELECT Name, GroupName FROM AdventureWorks2012.HumanResources.Department +WHERE DepartmentID = 18'); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Deleting data from a remote table by using the OPENDATASOURCE function + +DELETE FROM OPENDATASOURCE('SQLNCLI', + 'Data Source= ; Integrated Security=SSPI') + .AdventureWorks2012.HumanResources.Department +WHERE DepartmentID = 17; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using DELETE with the OUTPUT clause + +DELETE Sales.ShoppingCartItem +OUTPUT DELETED.* +WHERE ShoppingCartID = 20621; + +--Verify the rows in the table matching the WHERE clause have been deleted. +SELECT COUNT(*) AS [Rows in Table] FROM Sales.ShoppingCartItem WHERE ShoppingCartID = 20621; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using OUTPUT with in a DELETE statement + +DECLARE @MyTableVar table ( + ProductID int NOT NULL, + ProductName nvarchar(50)NOT NULL, + ProductModelID int NOT NULL, + PhotoID int NOT NULL); + +DELETE Production.ProductProductPhoto +OUTPUT DELETED.ProductID, + p.Name, + p.ProductModelID, + DELETED.ProductPhotoID + INTO @MyTableVar +FROM Production.ProductProductPhoto AS ph +JOIN Production.Product as p + ON ph.ProductID = p.ProductID + WHERE p.ProductModelID BETWEEN 120 and 130; + +--Display the results of the table variable. +SELECT ProductID, ProductName, ProductModelID, PhotoID +FROM @MyTableVar +ORDER BY ProductModelID; +GO + + diff --git a/tsql/examples/dml_insert.sql b/tsql/examples/dml_insert.sql new file mode 100644 index 0000000..94a43b6 --- /dev/null +++ b/tsql/examples/dml_insert.sql @@ -0,0 +1,481 @@ +----------------------------------------------------------------------- +-- INSERT https://msdn.microsoft.com/en-us/library/ms174335(v=sql.120).aspx +-- [ WITH [ ,...n ] ] +-- INSERT +-- { + -- [ TOP ( expression ) [ PERCENT ] ] + -- [ INTO ] + -- { | rowset_function_limited + -- [ WITH ( [ ...n ] ) ] + -- } + -- { + -- [ ( column_list ) ] + -- [ ] + -- { VALUES ( { DEFAULT | NULL | expression } [ ,...n ] ) [ ,...n ] + -- | derived_table + -- | execute_statement + -- | + -- | DEFAULT VALUES + -- } + -- } +-- } +-- [;] + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Inserting a single row of data + +INSERT INTO Production.UnitMeasure +VALUES (N'FT', N'Feet', '20080414'); + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Inserting multiple rows of data + +INSERT INTO Production.UnitMeasure +VALUES (N'FT2', N'Square Feet ', '20080923'), (N'Y', N'Yards', '20080923'), (N'Y3', N'Cubic Yards', '20080923'); + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Inserting data that is not in the same order as the table columns + +INSERT INTO Production.UnitMeasure (Name, UnitMeasureCode, ModifiedDate) +VALUES (N'Square Yards', N'Y2', GETDATE()); + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Inserting data into a table with columns that have default values + +IF OBJECT_ID ('dbo.T1', 'U') IS NOT NULL + DROP TABLE dbo.T1; +GO +CREATE TABLE dbo.T1 +( + column_1 AS 'Computed column ' + column_2, + column_2 varchar(30) + CONSTRAINT default_name DEFAULT ('my column default'), + column_3 rowversion, + column_4 varchar(40) NULL +); +GO +INSERT INTO dbo.T1 (column_4) + VALUES ('Explicit value'); +INSERT INTO dbo.T1 (column_2, column_4) + VALUES ('Explicit value', 'Explicit value'); +INSERT INTO dbo.T1 (column_2) + VALUES ('Explicit value'); +INSERT INTO T1 DEFAULT VALUES; +GO +SELECT column_1, column_2, column_3, column_4 +FROM dbo.T1; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Inserting data into a table with an identity column + +IF OBJECT_ID ('dbo.T1', 'U') IS NOT NULL + DROP TABLE dbo.T1; +GO +CREATE TABLE dbo.T1 ( column_1 int IDENTITY, column_2 VARCHAR(30)); +GO +INSERT T1 VALUES ('Row #1'); +INSERT T1 (column_2) VALUES ('Row #2'); +GO +SET IDENTITY_INSERT T1 ON; +GO +INSERT INTO T1 (column_1,column_2) + VALUES (-99, 'Explicit identity value'); +GO +SELECT column_1, column_2 +FROM T1; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Inserting data into a uniqueidentifier column by using NEWID() + +IF OBJECT_ID ('dbo.T1', 'U') IS NOT NULL + DROP TABLE dbo.T1; +GO +CREATE TABLE dbo.T1 +( + column_1 int IDENTITY, + column_2 uniqueidentifier, +); +GO +INSERT INTO dbo.T1 (column_2) + VALUES (NEWID()); +INSERT INTO T1 DEFAULT VALUES; +GO +SELECT column_1, column_2 +FROM dbo.T1; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Inserting data into user-defined type columns + +INSERT INTO dbo.Points (PointValue) VALUES (CONVERT(Point, '3,4')); +INSERT INTO dbo.Points (PointValue) VALUES (CONVERT(Point, '1,5')); +INSERT INTO dbo.Points (PointValue) VALUES (CAST ('1,99' AS Point)); + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the SELECT and EXECUTE options to insert data from other tables + +IF OBJECT_ID ('dbo.EmployeeSales', 'U') IS NOT NULL + DROP TABLE dbo.EmployeeSales; +GO +IF OBJECT_ID ('dbo.uspGetEmployeeSales', 'P') IS NOT NULL + DROP PROCEDURE uspGetEmployeeSales; +GO +CREATE TABLE dbo.EmployeeSales +( DataSource varchar(20) NOT NULL, + BusinessEntityID varchar(11) NOT NULL, + LastName varchar(40) NOT NULL, + SalesDollars money NOT NULL +); +GO +CREATE PROCEDURE dbo.uspGetEmployeeSales +AS + SET NOCOUNT ON; + SELECT 'PROCEDURE', sp.BusinessEntityID, c.LastName, + sp.SalesYTD + FROM Sales.SalesPerson AS sp + INNER JOIN Person.Person AS c + ON sp.BusinessEntityID = c.BusinessEntityID + WHERE sp.BusinessEntityID LIKE '2%' + ORDER BY sp.BusinessEntityID, c.LastName; +GO +--INSERT...SELECT example +INSERT INTO dbo.EmployeeSales + SELECT 'SELECT', sp.BusinessEntityID, c.LastName, sp.SalesYTD + FROM Sales.SalesPerson AS sp + INNER JOIN Person.Person AS c + ON sp.BusinessEntityID = c.BusinessEntityID + WHERE sp.BusinessEntityID LIKE '2%' + ORDER BY sp.BusinessEntityID, c.LastName; +GO +--INSERT...EXECUTE procedure example +INSERT INTO dbo.EmployeeSales +EXECUTE dbo.uspGetEmployeeSales; +GO +--INSERT...EXECUTE('string') example +INSERT INTO dbo.EmployeeSales +EXECUTE +(' +SELECT ''EXEC STRING'', sp.BusinessEntityID, c.LastName, + sp.SalesYTD + FROM Sales.SalesPerson AS sp + INNER JOIN Person.Person AS c + ON sp.BusinessEntityID = c.BusinessEntityID + WHERE sp.BusinessEntityID LIKE ''2%'' + ORDER BY sp.BusinessEntityID, c.LastName +'); +GO +--Show results. +SELECT DataSource,BusinessEntityID,LastName,SalesDollars +FROM dbo.EmployeeSales; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using WITH common table expression to define the data inserted + +IF OBJECT_ID (N'HumanResources.NewEmployee', N'U') IS NOT NULL + DROP TABLE HumanResources.NewEmployee; +GO +CREATE TABLE HumanResources.NewEmployee +( + EmployeeID int NOT NULL, + LastName nvarchar(50) NOT NULL, + FirstName nvarchar(50) NOT NULL, + PhoneNumber Phone NULL, + AddressLine1 nvarchar(60) NOT NULL, + City nvarchar(30) NOT NULL, + State nchar(3) NOT NULL, + PostalCode nvarchar(15) NOT NULL, + CurrentFlag Flag +); +GO +WITH EmployeeTemp (EmpID, LastName, FirstName, Phone, + Address, City, StateProvince, + PostalCode, CurrentFlag) +AS (SELECT + e.BusinessEntityID, c.LastName, c.FirstName, pp.PhoneNumber, + a.AddressLine1, a.City, sp.StateProvinceCode, + a.PostalCode, e.CurrentFlag + FROM HumanResources.Employee e + INNER JOIN Person.BusinessEntityAddress AS bea + ON e.BusinessEntityID = bea.BusinessEntityID + INNER JOIN Person.Address AS a + ON bea.AddressID = a.AddressID + INNER JOIN Person.PersonPhone AS pp + ON e.BusinessEntityID = pp.BusinessEntityID + INNER JOIN Person.StateProvince AS sp + ON a.StateProvinceID = sp.StateProvinceID + INNER JOIN Person.Person as c + ON e.BusinessEntityID = c.BusinessEntityID + ) +INSERT INTO HumanResources.NewEmployee + SELECT EmpID, LastName, FirstName, Phone, + Address, City, StateProvince, PostalCode, CurrentFlag + FROM EmployeeTemp; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using TOP to limit the data inserted from the source table + +IF OBJECT_ID ('dbo.EmployeeSales', 'U') IS NOT NULL + DROP TABLE dbo.EmployeeSales; +GO +CREATE TABLE dbo.EmployeeSales +( EmployeeID nvarchar(11) NOT NULL, + LastName nvarchar(20) NOT NULL, + FirstName nvarchar(20) NOT NULL, + YearlySales money NOT NULL + ); +GO +INSERT TOP(5)INTO dbo.EmployeeSales + OUTPUT inserted.EmployeeID, inserted.FirstName, inserted.LastName, inserted.YearlySales + SELECT sp.BusinessEntityID, c.LastName, c.FirstName, sp.SalesYTD + FROM Sales.SalesPerson AS sp + INNER JOIN Person.Person AS c + ON sp.BusinessEntityID = c.BusinessEntityID + WHERE sp.SalesYTD > 250000--.00 + ORDER BY sp.SalesYTD DESC; + +INSERT INTO dbo.EmployeeSales + OUTPUT inserted.EmployeeID, inserted.FirstName, inserted.LastName, inserted.YearlySales + SELECT TOP (5) sp.BusinessEntityID, c.LastName, c.FirstName, sp.SalesYTD + FROM Sales.SalesPerson AS sp + INNER JOIN Person.Person AS c + ON sp.BusinessEntityID = c.BusinessEntityID + WHERE sp.SalesYTD > 250000.00 + ORDER BY sp.SalesYTD DESC; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Inserting data by specifying a view + +IF OBJECT_ID ('dbo.T1', 'U') IS NOT NULL + DROP TABLE dbo.T1; +GO +IF OBJECT_ID ('dbo.V1', 'V') IS NOT NULL + DROP VIEW dbo.V1; +GO +CREATE TABLE T1 ( column_1 int, column_2 varchar(30)); +GO +CREATE VIEW V1 AS +SELECT column_2, column_1 +FROM T1; +GO +INSERT INTO V1 + VALUES ('Row 1',1); +GO +SELECT column_1, column_2 +FROM T1; +GO +SELECT column_1, column_2 +FROM V1; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Inserting data into a table variable + +-- Create the table variable. +DECLARE @MyTableVar table( + LocationID int NOT NULL, + CostRate smallmoney NOT NULL, + NewCostRate AS CostRate * 1.5, + ModifiedDate datetime); + +-- Insert values into the table variable. +INSERT INTO @MyTableVar (LocationID, CostRate, ModifiedDate) + SELECT LocationID, CostRate, GETDATE() FROM Production.Location + WHERE CostRate > 0; + +-- View the table variable result set. +SELECT * FROM @MyTableVar; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Inserting data into a remote table by using a linked server + +USE master; +GO +-- Create a link to the remote data source. +-- Specify a valid server name for @datasrc as 'server_name' or 'server_name\instance_name'. + +EXEC sp_addlinkedserver @server = N'MyLinkServer', + @srvproduct = N' ', + @provider = N'SQLNCLI', + @datasrc = N'server_name', + @catalog = N'AdventureWorks2012'; +GO + +-- Specify the remote data source in the FROM clause using a four-part name +-- in the form linked_server.catalog.schema.object. + +INSERT INTO MyLinkServer.AdventureWorks2012.HumanResources.Department (Name, GroupName) +VALUES (N'Public Relations', N'Executive General and Administration'); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Inserting data into a remote table by using the OPENQUERY function + +INSERT OPENQUERY (MyLinkServer, 'SELECT Name, GroupName FROM AdventureWorks2012.HumanResources.Department') +VALUES ('Environmental Impact', 'Engineering'); +GO + +INSERT INTO OPENDATASOURCE('SQLNCLI', + 'Data Source= ; Integrated Security=SSPI') + .AdventureWorks2012.HumanResources.Department (Name, GroupName) + VALUES (N'Standards and Methods', 'Quality Assurance'); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Inserting data into a heap with minimal logging + +-- Create the target heap. +CREATE TABLE Sales.SalesHistory( + SalesOrderID int NOT NULL, + SalesOrderDetailID int NOT NULL, + CarrierTrackingNumber nvarchar(25) NULL, + OrderQty smallint NOT NULL, + ProductID int NOT NULL, + SpecialOfferID int NOT NULL, + UnitPrice money NOT NULL, + UnitPriceDiscount money NOT NULL, + LineTotal money NOT NULL, + rowguid uniqueidentifier /*ROWGUIDCOL*/ NOT NULL, + ModifiedDate datetime NOT NULL ); +GO +-- Temporarily set the recovery model to BULK_LOGGED. +ALTER DATABASE AdventureWorks2012 +SET RECOVERY BULK_LOGGED; +GO +-- Transfer data from Sales.SalesOrderDetail to Sales.SalesHistory +INSERT INTO Sales.SalesHistory WITH (TABLOCK) + (SalesOrderID, + SalesOrderDetailID, + CarrierTrackingNumber, + OrderQty, + ProductID, + SpecialOfferID, + UnitPrice, + UnitPriceDiscount, + LineTotal, + rowguid, + ModifiedDate) +SELECT * FROM Sales.SalesOrderDetail; +GO +-- Reset the recovery model. +ALTER DATABASE AdventureWorks2012 +SET RECOVERY FULL; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the OPENROWSET function with BULK to bulk load data into a table + +-- Use the OPENROWSET function to specify the data source and specifies the IGNORE_TRIGGERS table hint. +INSERT INTO HumanResources.Department WITH (IGNORE_TRIGGERS) (Name, GroupName) +SELECT b.Name, b.GroupName +FROM OPENROWSET ( + BULK 'C:\SQLFiles\DepartmentData.txt', + FORMATFILE = 'C:\SQLFiles\BulkloadFormatFile.xml', + ROWS_PER_BATCH = 15000)AS b ; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the TABLOCK hint to specify a locking method + +INSERT INTO Production.Location WITH (XLOCK) +(Name, CostRate, Availability) +VALUES ( N'Final Inventory', 15.00, 80.00); + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- A Using OUTPUT with an INSERT statement + +DECLARE @MyTableVar table( NewScrapReasonID smallint, + Name varchar(50), + ModifiedDate datetime); +INSERT Production.ScrapReason + OUTPUT INSERTED.ScrapReasonID, INSERTED.Name, INSERTED.ModifiedDate + INTO @MyTableVar +VALUES (N'Operator error', GETDATE()); + +--Display the result set of the table variable. +SELECT NewScrapReasonID, Name, ModifiedDate FROM @MyTableVar; +--Display the result set of the table. +SELECT ScrapReasonID, Name, ModifiedDate +FROM Production.ScrapReason; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using OUTPUT with identity and computed columns + +IF OBJECT_ID ('dbo.EmployeeSales', 'U') IS NOT NULL + DROP TABLE dbo.EmployeeSales; +GO +CREATE TABLE dbo.EmployeeSales +( EmployeeID int IDENTITY (1,5)NOT NULL, + LastName nvarchar(20) NOT NULL, + FirstName nvarchar(20) NOT NULL, + CurrentSales money NOT NULL, + ProjectedSales AS CurrentSales * 1.10 +); +GO +DECLARE @MyTableVar table( + LastName nvarchar(20) NOT NULL, + FirstName nvarchar(20) NOT NULL, + CurrentSales money NOT NULL + ); + +INSERT INTO dbo.EmployeeSales (LastName, FirstName, CurrentSales) + OUTPUT INSERTED.LastName, + INSERTED.FirstName, + INSERTED.CurrentSales + INTO @MyTableVar + SELECT c.LastName, c.FirstName, sp.SalesYTD + FROM Sales.SalesPerson AS sp + INNER JOIN Person.Person AS c + ON sp.BusinessEntityID = c.BusinessEntityID + WHERE sp.BusinessEntityID LIKE '2%' + ORDER BY c.LastName, c.FirstName; + +SELECT LastName, FirstName, CurrentSales +FROM @MyTableVar; +GO +SELECT EmployeeID, LastName, FirstName, CurrentSales, ProjectedSales +FROM dbo.EmployeeSales; +GO + +INSERT INTO @Result + SELECT ID FROM [schema].[tbl] + UNION + SELECT ID FROM [schema].[tbl1] + UNION + SELECT ID FROM [schema].[tbl2] + UNION + SELECT ID FROM [schema].[tbl3 +GO] +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Inserting data returned from an OUTPUT clause +-- TODO: uncomment when merge_statement will be implemented. + +-- IF OBJECT_ID(N'Production.ZeroInventory', N'U') IS NOT NULL + -- DROP TABLE Production.ZeroInventory; +-- GO +-- --Create ZeroInventory table. +-- CREATE TABLE Production.ZeroInventory (DeletedProductID int, RemovedOnDate DateTime); +-- GO + +-- INSERT INTO Production.ZeroInventory (DeletedProductID, RemovedOnDate) +-- SELECT ProductID, GETDATE() +-- FROM +-- ( MERGE Production.ProductInventory AS pi + -- USING (SELECT ProductID, SUM(OrderQty) FROM Sales.SalesOrderDetail AS sod + -- JOIN Sales.SalesOrderHeader AS soh + -- ON sod.SalesOrderID = soh.SalesOrderID + -- AND soh.OrderDate = '20070401' + -- GROUP BY ProductID) AS src (ProductID, OrderQty) + -- ON (pi.ProductID = src.ProductID) + -- WHEN MATCHED AND pi.Quantity - src.OrderQty <= 0 + -- THEN DELETE + -- WHEN MATCHED + -- THEN UPDATE SET pi.Quantity = pi.Quantity - src.OrderQty + -- OUTPUT $action, deleted.ProductID) AS Changes (Action, ProductID) +-- WHERE Action = 'DELETE'; +-- IF @@ROWCOUNT = 0 +-- PRINT 'Warning: No rows were inserted'; +-- GO +-- SELECT DeletedProductID, RemovedOnDate FROM Production.ZeroInventory; + diff --git a/tsql/examples/dml_merge.sql b/tsql/examples/dml_merge.sql new file mode 100644 index 0000000..7cfbb25 --- /dev/null +++ b/tsql/examples/dml_merge.sql @@ -0,0 +1,18 @@ + +--https://docs.microsoft.com/en-us/sql/t-sql/statements/merge-transact-sql + +MERGE Production.UnitMeasure AS target +USING (SELECT @UnitMeasureCode, @Name) AS src (UnitMeasureCode, Name) +ON (target.UnitMeasureCode = src.UnitMeasureCode) +WHEN MATCHED THEN + UPDATE SET Name = src.Name +WHEN NOT MATCHED THEN +INSERT (UnitMeasureCode, Name) +VALUES (src.UnitMeasureCode, src.Name) +OUTPUT deleted.*, + $action, + inserted.*, + CASE WHEN $action = 'INSERT' THEN 1 ELSE 0 END, + IIF($action = 'DELETE', 1, 0), + inserted.UnitMeasureCode +INTO #MyTempTable; \ No newline at end of file diff --git a/tsql/examples/dml_openrowset.sql b/tsql/examples/dml_openrowset.sql new file mode 100644 index 0000000..0f5f1d2 --- /dev/null +++ b/tsql/examples/dml_openrowset.sql @@ -0,0 +1,2 @@ +SELECT * FROM OPENROWSET('SQLOLEDB', 'Server=.\SQLEXPRESS;Trusted_Connection=yes;', 'SET FMTONLY OFF;SET NOCOUNT ON;exec(''RESTORE headeronly FROM DISK = N''''C:\Temp\Dev\SQL2012Backup.bak'''''')') +GO diff --git a/tsql/examples/dml_select.sql b/tsql/examples/dml_select.sql new file mode 100644 index 0000000..44c7888 --- /dev/null +++ b/tsql/examples/dml_select.sql @@ -0,0 +1,808 @@ +----------------------------------------------------------------------- +-- SELECT https://msdn.microsoft.com/en-us/library/ms187731.aspx + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using SELECT to retrieve rows and columns + +USE AdventureWorks2012; +GO +SELECT * +FROM Production.Product +ORDER BY Name ASC; +-- Alternate way. +USE AdventureWorks2012; +GO +SELECT p.* +FROM Production.Product AS p +ORDER BY Name ASC; +GO + +USE AdventureWorks2012; +GO +SELECT Name, ProductNumber, ListPrice AS Price +FROM Production.Product +ORDER BY Name ASC; +GO + +USE AdventureWorks2012; +GO +SELECT Name, ProductNumber, ListPrice AS Price +FROM Production.Product +WHERE ProductLine = 'R' +AND DaysToManufacture < 4 +ORDER BY Name ASC; +GO + +-- Select with Multiple Batch Separators +USE AdventureWorks2012; +GO +SELECT * +FROM Production.Product +ORDER BY Name ASC; +GO +GO + +USE AdventureWorks2012; +GO +SELECT + [Production].[Product].[ProductID], + [Production].[Product].[Name] +FROM [Production].[Product] +GO + +USE AdventureWorks2012; +GO +SELECT *, *, * -- yes, syntax is valid +FROM [Production].[Product] +GO + +USE AdventureWorks2012; +GO +SELECT + some_type::static_method (@arg1, @arg2, @arg3), + another_type::method ('some value'), + still_one_type.non_static_method (@but, @with, @params) +FROM [Production].[Product] +GO + +-- Superfluous parentheses. +-- Not 100% this matches Microsoft's grammar, but SQL Server 2019 parses it /shrug. +SELECT * FROM ((A INNER JOIN B ON 1 = 1)) +SELECT * FROM (A INNER JOIN B ON 1 = 1) LEFT JOIN C ON 1 = 1 +SELECT * FROM ((A INNER JOIN B ON 1 = 1) LEFT JOIN C ON 1 = 1) + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using SELECT with column headings and calculations + +USE AdventureWorks2012; +GO +SELECT p.Name AS ProductName, +NonDiscountSales = (OrderQty * UnitPrice), +Discounts = ((OrderQty * UnitPrice) * UnitPriceDiscount) +FROM Production.Product AS p +INNER JOIN Sales.SalesOrderDetail AS sod +ON p.ProductID = sod.ProductID +ORDER BY ProductName DESC; +GO + +USE AdventureWorks2012; +GO +SELECT 'Total income is', ((OrderQty * UnitPrice) * (1.0 - UnitPriceDiscount)), ' for ', +p.Name AS ProductName +FROM Production.Product AS p +INNER JOIN Sales.SalesOrderDetail AS sod +ON p.ProductID = sod.ProductID +ORDER BY ProductName ASC; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using DISTINCT with SELECT + +USE AdventureWorks2012; +GO +SELECT DISTINCT JobTitle +FROM HumanResources.Employee +ORDER BY JobTitle; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Creating tables with SELECT INTO + +USE tempdb; +GO +IF OBJECT_ID (N'#Bicycles',N'U') IS NOT NULL +DROP TABLE #Bicycles; +GO +SELECT * +INTO #Bicycles +FROM AdventureWorks2012.Production.Product +WHERE ProductNumber LIKE 'BK%'; +GO + +USE AdventureWorks2012; +GO +IF OBJECT_ID('dbo.NewProducts', 'U') IS NOT NULL + DROP TABLE dbo.NewProducts; +GO +ALTER DATABASE AdventureWorks2012 SET RECOVERY BULK_LOGGED; +GO + +SELECT * INTO dbo.NewProducts +FROM Production.Product +WHERE ListPrice > $25 +AND ListPrice < $100; +GO +ALTER DATABASE AdventureWorks2012 SET RECOVERY FULL; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using correlated subqueries + +USE AdventureWorks2012; +GO +SELECT DISTINCT Name +FROM Production.Product AS p +WHERE EXISTS + (SELECT * + FROM Production.ProductModel AS pm + WHERE p.ProductModelID = pm.ProductModelID + AND pm.Name LIKE 'Long-Sleeve Logo Jersey%'); +GO + +-- OR + +USE AdventureWorks2012; +GO +SELECT DISTINCT Name +FROM Production.Product +WHERE ProductModelID IN + (SELECT ProductModelID + FROM Production.ProductModel + WHERE Name LIKE 'Long-Sleeve Logo Jersey%'); +GO + +USE AdventureWorks2012; +GO +SELECT DISTINCT p.LastName, p.FirstName +FROM Person.Person AS p +JOIN HumanResources.Employee AS e + ON e.BusinessEntityID = p.BusinessEntityID WHERE 5000.00 IN + (SELECT Bonus + FROM Sales.SalesPerson AS sp + WHERE e.BusinessEntityID = sp.BusinessEntityID); +GO + +USE AdventureWorks2012; +GO +SELECT p1.ProductModelID +FROM Production.Product AS p1 +GROUP BY p1.ProductModelID +HAVING MAX(p1.ListPrice) >= ALL + (SELECT AVG(p2.ListPrice) + FROM Production.Product AS p2 + WHERE p1.ProductModelID = p2.ProductModelID); +GO + +USE AdventureWorks2012; +GO +SELECT DISTINCT pp.LastName, pp.FirstName +FROM Person.Person pp JOIN HumanResources.Employee e +ON e.BusinessEntityID = pp.BusinessEntityID WHERE pp.BusinessEntityID IN +(SELECT SalesPersonID +FROM Sales.SalesOrderHeader +WHERE SalesOrderID IN +(SELECT SalesOrderID +FROM Sales.SalesOrderDetail +WHERE ProductID IN +(SELECT ProductID +FROM Production.Product p +WHERE ProductNumber = 'BK-M68B-42'))); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using GROUP BY + +USE AdventureWorks2012; +GO +SELECT SalesOrderID, SUM(LineTotal) AS SubTotal +FROM Sales.SalesOrderDetail +GROUP BY SalesOrderID +ORDER BY SalesOrderID; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using GROUP BY with multiple groups + +USE AdventureWorks2012; +GO +SELECT ProductID, SpecialOfferID, AVG(UnitPrice) AS [Average Price], + SUM(LineTotal) AS SubTotal +FROM Sales.SalesOrderDetail +GROUP BY ProductID, SpecialOfferID +ORDER BY ProductID; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using GROUP BY and WHERE + +USE AdventureWorks2012; +GO +SELECT ProductModelID, AVG(ListPrice) AS [Average List Price] +FROM Production.Product +WHERE ListPrice > $1000 +GROUP BY ProductModelID +ORDER BY ProductModelID; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using GROUP BY with an expression + +USE AdventureWorks2012; +GO +SELECT AVG(OrderQty) AS [Average Quantity], +NonDiscountSales = (OrderQty * UnitPrice) +FROM Sales.SalesOrderDetail +GROUP BY (OrderQty * UnitPrice) +ORDER BY (OrderQty * UnitPrice) DESC; +GO + + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using GROUP BY with ORDER BY + +USE AdventureWorks2012; +GO +SELECT ProductID, AVG(UnitPrice) AS [Average Price] +FROM Sales.SalesOrderDetail +WHERE OrderQty > 10 +GROUP BY ProductID +ORDER BY AVG(UnitPrice); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the HAVING clause + +USE AdventureWorks2012; +GO +SELECT ProductID +FROM Sales.SalesOrderDetail +GROUP BY ProductID +HAVING AVG(OrderQty) > 5 +ORDER BY ProductID; +GO + +USE AdventureWorks2012 ; +GO +SELECT SalesOrderID, CarrierTrackingNumber +FROM Sales.SalesOrderDetail +GROUP BY SalesOrderID, CarrierTrackingNumber +HAVING CarrierTrackingNumber LIKE '4BD%' +ORDER BY SalesOrderID ; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using HAVING and GROUP BY + +USE AdventureWorks2012; +GO +SELECT ProductID +FROM Sales.SalesOrderDetail +WHERE UnitPrice < 25.00 +GROUP BY ProductID +HAVING AVG(OrderQty) > 5 +ORDER BY ProductID; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using HAVING with SUM and AVG + +USE AdventureWorks2012; +GO +SELECT ProductID, AVG(OrderQty) AS AverageQuantity, SUM(LineTotal) AS Total +FROM Sales.SalesOrderDetail +GROUP BY ProductID +HAVING SUM(LineTotal) > $1000000.00 +AND AVG(OrderQty) < 3; +GO + +USE AdventureWorks2012; +GO +SELECT ProductID, Total = SUM(LineTotal) +FROM Sales.SalesOrderDetail +GROUP BY ProductID +HAVING SUM(LineTotal) > $2000000.00; +GO + +USE AdventureWorks2012; +GO +SELECT ProductID, SUM(LineTotal) AS Total +FROM Sales.SalesOrderDetail +GROUP BY ProductID +HAVING COUNT(*) > 1500; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the INDEX optimizer hint + +USE AdventureWorks2012; +GO +SELECT pp.FirstName, pp.LastName, e.NationalIDNumber +FROM HumanResources.Employee AS e WITH (INDEX(AK_Employee_NationalIDNumber)) +JOIN Person.Person AS pp on e.BusinessEntityID = pp.BusinessEntityID +WHERE LastName = 'Johnson'; +GO + +-- Force a table scan by using INDEX = 0. +USE AdventureWorks2012; +GO +SELECT pp.LastName, pp.FirstName, e.JobTitle +FROM HumanResources.Employee AS e WITH (INDEX = 0) JOIN Person.Person AS pp +ON e.BusinessEntityID = pp.BusinessEntityID +WHERE LastName = 'Johnson'; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using OPTION and the GROUP hints + +USE AdventureWorks2012; +GO +SELECT ProductID, OrderQty, SUM(LineTotal) AS Total +FROM Sales.SalesOrderDetail +WHERE UnitPrice < $5.00 +GROUP BY ProductID, OrderQty +ORDER BY ProductID, OrderQty +OPTION (HASH GROUP, FAST 10); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the UNION query hint + +USE AdventureWorks2012; +GO +SELECT BusinessEntityID, JobTitle, HireDate, VacationHours, SickLeaveHours +FROM HumanResources.Employee AS e1 +UNION +SELECT BusinessEntityID, JobTitle, HireDate, VacationHours, SickLeaveHours +FROM HumanResources.Employee AS e2 +OPTION (MERGE UNION); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using a simple UNION + +USE AdventureWorks2012; +GO +IF OBJECT_ID ('dbo.Gloves', 'U') IS NOT NULL +DROP TABLE dbo.Gloves; +GO +-- Create Gloves table. +SELECT ProductModelID, Name +INTO dbo.Gloves +FROM Production.ProductModel +WHERE ProductModelID IN (3, 4); +GO + +-- Here is the simple union. +USE AdventureWorks2012; +GO +SELECT ProductModelID, Name +FROM Production.ProductModel +WHERE ProductModelID NOT IN (3, 4) +UNION +SELECT ProductModelID, Name +FROM dbo.Gloves +ORDER BY Name; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using SELECT INTO with UNION + +USE AdventureWorks2012; +GO +IF OBJECT_ID ('dbo.ProductResults', 'U') IS NOT NULL +DROP TABLE dbo.ProductResults; +GO +IF OBJECT_ID ('dbo.Gloves', 'U') IS NOT NULL +DROP TABLE dbo.Gloves; +GO +-- Create Gloves table. +SELECT ProductModelID, Name +INTO dbo.Gloves +FROM Production.ProductModel +WHERE ProductModelID IN (3, 4); +GO + +USE AdventureWorks2012; +GO +SELECT ProductModelID, Name +INTO dbo.ProductResults +FROM Production.ProductModel +WHERE ProductModelID NOT IN (3, 4) +UNION +SELECT ProductModelID, Name +FROM dbo.Gloves; +GO + +SELECT ProductModelID, Name +FROM dbo.ProductResults; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using UNION of two SELECT statements with ORDER BY + +USE AdventureWorks2012; +GO +IF OBJECT_ID ('dbo.Gloves', 'U') IS NOT NULL +DROP TABLE dbo.Gloves; +GO +-- Create Gloves table. +SELECT ProductModelID, Name +INTO dbo.Gloves +FROM Production.ProductModel +WHERE ProductModelID IN (3, 4); +GO + +/* CORRECT */ +USE AdventureWorks2012; +GO +SELECT ProductModelID, Name +FROM Production.ProductModel +WHERE ProductModelID NOT IN (3, 4) +UNION +SELECT ProductModelID, Name +FROM dbo.Gloves +ORDER BY Name; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using UNION of three SELECT statements to show the effects of ALL and parentheses + +USE AdventureWorks2012; +GO +IF OBJECT_ID ('dbo.EmployeeOne', 'U') IS NOT NULL +DROP TABLE dbo.EmployeeOne; +GO +IF OBJECT_ID ('dbo.EmployeeTwo', 'U') IS NOT NULL +DROP TABLE dbo.EmployeeTwo; +GO +IF OBJECT_ID ('dbo.EmployeeThree', 'U') IS NOT NULL +DROP TABLE dbo.EmployeeThree; +GO + +SELECT pp.LastName, pp.FirstName, e.JobTitle +INTO dbo.EmployeeOne +FROM Person.Person AS pp JOIN HumanResources.Employee AS e +ON e.BusinessEntityID = pp.BusinessEntityID +WHERE LastName = 'Johnson'; +GO +SELECT pp.LastName, pp.FirstName, e.JobTitle +INTO dbo.EmployeeTwo +FROM Person.Person AS pp JOIN HumanResources.Employee AS e +ON e.BusinessEntityID = pp.BusinessEntityID +WHERE LastName = 'Johnson'; +GO +SELECT pp.LastName, pp.FirstName, e.JobTitle +INTO dbo.EmployeeThree +FROM Person.Person AS pp JOIN HumanResources.Employee AS e +ON e.BusinessEntityID = pp.BusinessEntityID +WHERE LastName = 'Johnson'; +GO +-- Union ALL +SELECT LastName, FirstName, JobTitle +FROM dbo.EmployeeOne +UNION ALL +SELECT LastName, FirstName ,JobTitle +FROM dbo.EmployeeTwo +UNION ALL +SELECT LastName, FirstName,JobTitle +FROM dbo.EmployeeThree; +GO + +SELECT LastName, FirstName,JobTitle +FROM dbo.EmployeeOne +UNION +SELECT LastName, FirstName, JobTitle +FROM dbo.EmployeeTwo +UNION +SELECT LastName, FirstName, JobTitle +FROM dbo.EmployeeThree; +GO + +SELECT LastName, FirstName,JobTitle +FROM dbo.EmployeeOne +UNION ALL +( +SELECT LastName, FirstName, JobTitle +FROM dbo.EmployeeTwo +UNION +SELECT LastName, FirstName, JobTitle +FROM dbo.EmployeeThree +); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using SELECT with TOP clause + +USE AdventureWorks2012; +GO +SELECT TOP 10 * +FROM Production.Product +ORDER BY Name ASC; +-- Alternate way. +USE AdventureWorks2012; +GO +SELECT TOP (10) * +FROM Production.Product +ORDER BY Name ASC; +-- Alternate way. +USE AdventureWorks2012; +GO +SELECT TOP (@localvar) * +FROM Production.Product +ORDER BY Name ASC; + +-- TOP with percentage. +USE AdventureWorks2012; +GO +SELECT TOP 10.5 PERCENT * +FROM Production.Product +ORDER BY Name ASC; +-- Alternate way. +USE AdventureWorks2012; +GO +SELECT TOP (10.5) PERCENT * +FROM Production.Product +ORDER BY Name ASC; +-- Alternate way. +USE AdventureWorks2012; +GO +SELECT TOP (@localvar) PERCENT * +FROM Production.Product +ORDER BY Name ASC; + +-- TOP with ties. +USE AdventureWorks2012; +GO +SELECT TOP 10 WITH TIES * +FROM Production.Product +ORDER BY Name ASC; +-- Alternate way. +USE AdventureWorks2012; +GO +SELECT TOP 10.5 PERCENT WITH TIES * +FROM Production.Product +ORDER BY Name ASC; +-- Alternate way. +USE AdventureWorks2012; +GO +SELECT TOP (@localvar) WITH TIES * +FROM Production.Product +ORDER BY Name ASC; +-- Alternate way. +USE AdventureWorks2012; +GO +SELECT TOP (@localvar) PERCENT WITH TIES * +FROM Production.Product +ORDER BY Name ASC; + +-- Can apply any expression WITH parentheses. +-- If without parentheses, expression trails may be misunderstanding select_list. +-- ex: "SELECT TOP 1 + 2 * FROM HOGE" --> "+ 2" are matching in select_list. +USE AdventureWorks2012; +GO +SELECT TOP (NULL) * -- (But cause runtime error by SQL Server) +FROM Production.Product +ORDER BY Name ASC; +-- Alternate way. +USE AdventureWorks2012; +GO +SELECT TOP (1+2) * +FROM Production.Product +ORDER BY Name ASC; +-- Alternate way. +USE AdventureWorks2012; +GO +SELECT TOP (1+@localvar) * +FROM Production.Product +ORDER BY Name ASC; +-- Alternate way. +USE AdventureWorks2012; +GO +SELECT TOP (NULL) PERCENT * -- (But cause runtime error by SQL Server) +FROM Production.Product +ORDER BY Name ASC; +-- Alternate way. +USE AdventureWorks2012; +GO +SELECT TOP (1+2) PERCENT * +FROM Production.Product +ORDER BY Name ASC; +-- Alternate way. +USE AdventureWorks2012; +GO +SELECT TOP (1+@localvar) PERCENT * +FROM Production.Product +ORDER BY Name ASC; + +-- TRY_CAST & TRY_CONVERT +use AdventureWorks2012; +GO +SELECT TRY_CAST(SalesOrderID AS INT), + TRY_CONVERT(INT, SalesOrderID) +FROM Sales.SalesOrderDetail +WHERE SalesOrderDetailID = 1; +GO + +-- SET statement +SET ANSI_WARNINGS OFF; +SELECT id FROM tbl; +GO + +-- Select on sequence +SELECT @var = NEXT VALUE FOR [dbo].[sequenceName] +GO + +SELECT NEXT VALUE FOR [dbo].[sequenceName] as nextValueSequence +GO + +SELECT NEXT VALUE FOR [dbo].[sequenceName] +GO + +-- NEXT VALUE FOR OVER into variable +DECLARE @T BIGINT; + +SELECT @T = NEXT VALUE FOR dbo.sequenceName OVER (ORDER BY SOME_COLUMN ASC) +FROM (SELECT SOME_COLUMN = 1) AS T + +GO + +-- NEXT VALUE FOR OVER into variable +DECLARE @T BIGINT; + +SELECT @T = NEXT VALUE FOR dbo.sequenceName OVER (ORDER BY SOME_COLUMN, SOME_OTHER_COLUMN DESC) +FROM (SELECT SOME_COLUMN = 1) AS T + +GO + +-- NEXT VALUE FOR OVER without variable +SELECT NEXT VALUE FOR dbo.sequenceName OVER (ORDER BY SOME_COLUMN ASC) +FROM (SELECT SOME_COLUMN = 1) AS T +GO + +SELECT NEXT VALUE FOR dbo.sequenceName OVER (ORDER BY SOME_COLUMN, SOME_OTHER_COLUMN DESC) +FROM (SELECT SOME_COLUMN = 1) AS T +GO + +--Select with linked server +SELECT * FROM [linkedServerName]..[schema].[table] tbl +GO + +-- Select with full table name +SELECT * FROM ServerName.DBName.do.TestTable TestTable + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using SELECT from build in function +SELECT * FROM ::fn_helpcollations() + + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using PIVOT and UNPIVOT statements + +-- Pivot table with one row and five columns +SELECT 'AverageCost' AS Cost_Sorted_By_Production_Days, +[0], [1], [2], [3], [4] +FROM +(SELECT DaysToManufacture, StandardCost + FROM Production.Product) AS SourceTable +PIVOT +( +AVG(StandardCost) +FOR DaysToManufacture IN ([0], [1], [2], [3], [4]) +) AS PivotTable; + +--Create the table and insert values as portrayed in the previous example. +CREATE TABLE pvt (VendorID int, Emp1 int, Emp2 int, + Emp3 int, Emp4 int, Emp5 int); +GO +INSERT INTO pvt VALUES (1,4,3,5,4,4); +INSERT INTO pvt VALUES (2,4,1,5,5,5); +INSERT INTO pvt VALUES (3,4,3,5,4,4); +INSERT INTO pvt VALUES (4,4,2,5,5,4); +INSERT INTO pvt VALUES (5,5,1,5,5,5); +GO +--Unpivot the table. +SELECT VendorID, Employee, Orders +FROM + (SELECT VendorID, Emp1, Emp2, Emp3, Emp4, Emp5 + FROM pvt) p +UNPIVOT + (Orders FOR Employee IN + (Emp1, Emp2, Emp3, Emp4, Emp5) +)AS unpvt; +GO +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using table value constructor + +SELECT a, b FROM (VALUES (1, 2), (3, 4), (5, 6), (7, 8), (9, 10) ) AS MyTable(a, b); +GO +-- Used in an inner join to specify values to return. +SELECT ProductID, a.Name, Color +FROM Production.Product AS a +INNER JOIN (VALUES ('Blade'), ('Crown Race'), ('AWC Logo Cap')) AS b(Name) +ON a.Name = b.Name; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Open XML Statement + + +DECLARE @idoc int, @doc varchar(1000); +SET @doc =' + + + + + + + + + + + + +'; +--Create an internal representation of the XML document. +EXEC sp_xml_preparedocument @idoc OUTPUT, @doc; +-- Execute a SELECT statement that uses the OPENXML rowset provider. +SELECT * +FROM OPENXML (@idoc, '/ROOT/Customer',1) + WITH (CustomerID varchar(10), + ContactName varchar(20)); + + + DECLARE @idoc int, @doc varchar(1000); +SET @doc =' + + + + + + + +v + + + + +'; + +--Create an internal representation of the XML document. +EXEC sp_xml_preparedocument @idoc OUTPUT, @doc; + +-- SELECT stmt using OPENXML rowset provider +SELECT * +FROM OPENXML (@idoc, '/ROOT/Customer/Order/OrderDetail',2) + WITH (OrderID int '../@OrderID', + CustomerID varchar(10) '../@CustomerID', + OrderDate datetime '../@OrderDate', + ProdID int '@ProductID', + Qty int '@Quantity'); + + +select distinct t.a_field_1 f1, t.a_field_2 f2 from a_table t +where f2 = "" + +select distinct t.a_field_1 f1 from a_table t noholdlock +where t.a_field_2 = t.a_field_3 + +select t.a_field_1 f1 from a_table t, another_table t2 +where t.a_field_2 *= t2.field_we_do_a_left_outer_join_on + +select distinct t.a_field_1 f1 from a_table t +where t.a_field_2 <= current_date() + +with + t as (select 1 as x), + u as (select 1 as y), + v as (select 1 as z) +select x from t join u join v on u.y = v.z on t.x = v.z diff --git a/tsql/examples/dml_update.sql b/tsql/examples/dml_update.sql new file mode 100644 index 0000000..465779f --- /dev/null +++ b/tsql/examples/dml_update.sql @@ -0,0 +1,550 @@ +-- UPDATE https://msdn.microsoft.com/en-us/library/ms177523.aspx +-- https://msdn.microsoft.com/en-us/library/ms177523.aspx +-- [ WITH [...n] ] +-- UPDATE + -- [ TOP ( expression ) [ PERCENT ] ] + -- { { table_alias | | rowset_function_limited + -- [ WITH ( [ ...n ] ) ] + -- } + -- | @table_variable + -- } + -- SET + -- { column_name = { expression | DEFAULT | NULL } + -- | { udt_column_name.{ { property_name = expression + -- | field_name = expression } + -- | method_name ( argument [ ,...n ] ) + -- } + -- } + -- | column_name { .WRITE ( expression , @Offset , @Length ) } + -- | @variable = expression + -- | @variable = column = expression + -- | column_name { += | -= | *= | /= | %= | &= | ^= | |= } expression + -- | @variable { += | -= | *= | /= | %= | &= | ^= | |= } expression + -- | @variable = column { += | -= | *= | /= | %= | &= | ^= | |= } expression + -- } [ ,...n ] + + -- [ ] + -- [ FROM{ } [ ,...n ] ] + -- [ WHERE { + -- | { [ CURRENT OF + -- { { [ GLOBAL ] cursor_name } + -- | cursor_variable_name + -- } + -- ] + -- } + -- } + -- ] + -- [ OPTION ( [ ,...n ] ) ] +-- [ ; ] + +-- ::= +-- { + -- [ server_name . database_name . schema_name . + -- | database_name .[ schema_name ] . + -- | schema_name . + -- ] + -- table_or_view_name} + +USE AdventureWorks2012; +GO +IF OBJECT_ID ('dbo.Table1', 'U') IS NOT NULL + DROP TABLE dbo.Table1; +GO +IF OBJECT_ID ('dbo.Table2', 'U') IS NOT NULL + DROP TABLE dbo.Table2; +GO +CREATE TABLE dbo.Table1 + (ColA int NOT NULL, ColB decimal(10,3) NOT NULL); +GO +CREATE TABLE dbo.Table2 + (ColA int NOT NULL PRIMARY KEY, ColB decimal(10,3) NOT NULL); +GO +INSERT INTO dbo.Table1 VALUES(1, 10.0), (1, 20.0); +INSERT INTO dbo.Table2 VALUES(1, 0.0); +GO +UPDATE dbo.Table2 +SET dbo.Table2.ColB = dbo.Table2.ColB + dbo.Table1.ColB +FROM dbo.Table2 + INNER JOIN dbo.Table1 + ON (dbo.Table2.ColA = dbo.Table1.ColA); +GO +SELECT ColA, ColB +FROM dbo.Table2; + +USE tempdb; +GO +-- UPDATE statement with CTE references that are correctly matched. +DECLARE @x TABLE (ID int, Value int); +DECLARE @y TABLE (ID int, Value int); +INSERT @x VALUES (1, 10), (2, 20); +INSERT @y VALUES (1, 100),(2, 200); + +WITH cte AS (SELECT * FROM @x) +UPDATE x -- cte is referenced by the alias. +SET Value = y.Value +FROM cte AS x -- cte is assigned an alias. +INNER JOIN @y AS y ON y.ID = x.ID; +SELECT * FROM @x; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using a simple UPDATE statement + +USE AdventureWorks2012; +GO +UPDATE Person.Address +SET ModifiedDate = GETDATE(); + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Updating multiple columns + +USE AdventureWorks2012; +GO +UPDATE Sales.SalesPerson +SET Bonus = 6000, CommissionPct = .10, SalesQuota = NULL; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the WHERE clause + +USE AdventureWorks2012; +GO +UPDATE Production.Product +SET Color = N'Metallic Red' +WHERE Name LIKE N'Road-250%' AND Color = N'Red'; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the TOP clause + +USE AdventureWorks2012; +GO +UPDATE Production.Product +SET Color = N'Metallic Red' +WHERE Name LIKE N'Road-250%' AND Color = N'Red'; +GO + +UPDATE HumanResources.Employee +SET VacationHours = VacationHours + 8 +FROM (SELECT TOP 10 BusinessEntityID FROM HumanResources.Employee + ORDER BY HireDate ASC) AS th +WHERE HumanResources.Employee.BusinessEntityID = th.BusinessEntityID; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the WITH common_table_expression clause + +USE AdventureWorks2012; +GO +WITH Parts(AssemblyID, ComponentID, PerAssemblyQty, EndDate, ComponentLevel) AS +( + SELECT b.ProductAssemblyID, b.ComponentID, b.PerAssemblyQty, + b.EndDate, 0 AS ComponentLevel + FROM Production.BillOfMaterials AS b + WHERE b.ProductAssemblyID = 800 + AND b.EndDate IS NULL + UNION ALL + SELECT bom.ProductAssemblyID, bom.ComponentID, p.PerAssemblyQty, + bom.EndDate, ComponentLevel + 1 + FROM Production.BillOfMaterials AS bom + INNER JOIN Parts AS p + ON bom.ProductAssemblyID = p.ComponentID + AND bom.EndDate IS NULL +) +UPDATE Production.BillOfMaterials +SET PerAssemblyQty = c.PerAssemblyQty * 2 +FROM Production.BillOfMaterials AS c +JOIN Parts AS d ON c.ProductAssemblyID = d.AssemblyID +WHERE d.ComponentLevel = 0; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the WHERE CURRENT OF clause + +USE AdventureWorks2012; +GO +DECLARE complex_cursor CURSOR FOR + SELECT a.BusinessEntityID + FROM HumanResources.EmployeePayHistory AS a + WHERE RateChangeDate <> + (SELECT MAX(RateChangeDate) + FROM HumanResources.EmployeePayHistory AS b + WHERE a.BusinessEntityID = b.BusinessEntityID) ; +OPEN complex_cursor; +FETCH FROM complex_cursor; +UPDATE HumanResources.EmployeePayHistory +SET PayFrequency = 2 +WHERE CURRENT OF complex_cursor; +CLOSE complex_cursor; +DEALLOCATE complex_cursor; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Specifying a computed value + +USE AdventureWorks2012 ; +GO +UPDATE Production.Product +SET ListPrice = ListPrice * 2; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Specifying a compound operator + +USE AdventureWorks2012; +GO +DECLARE @NewPrice int = 10; +UPDATE Production.Product +SET ListPrice += @NewPrice +WHERE Color = N'Red'; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Specifying a subquery in the SET clause + +USE AdventureWorks2012; +GO +UPDATE Sales.SalesPerson +SET SalesYTD = SalesYTD + + (SELECT SUM(so.SubTotal) + FROM Sales.SalesOrderHeader AS so + WHERE so.OrderDate = (SELECT MAX(OrderDate) + FROM Sales.SalesOrderHeader AS so2 + WHERE so2.SalesPersonID = so.SalesPersonID) + AND Sales.SalesPerson.BusinessEntityID = so.SalesPersonID + GROUP BY so.SalesPersonID); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Updating rows using DEFAULT values + +USE AdventureWorks2012; +GO +UPDATE Production.Location +SET CostRate = DEFAULT +WHERE CostRate > 20.00; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Specifying a view as the target object + +USE AdventureWorks2012; +GO +UPDATE Person.vStateProvinceCountryRegion +SET CountryRegionName = 'United States of America' +WHERE CountryRegionName = 'United States'; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Specifying a table alias as the target object + +USE AdventureWorks2012; +GO +UPDATE sr +SET sr.Name += ' - tool malfunction' +FROM Production.ScrapReason AS sr +JOIN Production.WorkOrder AS wo + ON sr.ScrapReasonID = wo.ScrapReasonID + AND wo.ScrappedQty > 300; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Specifying a table variable as the target object + +USE AdventureWorks2012; +GO +-- Create the table variable. +DECLARE @MyTableVar table( + EmpID int NOT NULL, + NewVacationHours int, + ModifiedDate datetime); + +-- Populate the table variable with employee ID values from HumanResources.Employee. +INSERT INTO @MyTableVar (EmpID) + SELECT BusinessEntityID FROM HumanResources.Employee; + +-- Update columns in the table variable. +UPDATE @MyTableVar +SET NewVacationHours = e.VacationHours + 20, + ModifiedDate = GETDATE() +FROM HumanResources.Employee AS e +WHERE e.BusinessEntityID = EmpID; + +-- Display the results of the UPDATE statement. +SELECT EmpID, NewVacationHours, ModifiedDate FROM @MyTableVar +ORDER BY EmpID; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the UPDATE statement with information from another table + +USE AdventureWorks2012; +GO +UPDATE Sales.SalesPerson +SET SalesYTD = SalesYTD + SubTotal +FROM Sales.SalesPerson AS sp +JOIN Sales.SalesOrderHeader AS so + ON sp.BusinessEntityID = so.SalesPersonID + AND so.OrderDate = (SELECT MAX(OrderDate) + FROM Sales.SalesOrderHeader + WHERE SalesPersonID = sp.BusinessEntityID); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Updating data in a remote table by using a linked server + +USE master; +GO +-- Create a link to the remote data source. +-- Specify a valid server name for @datasrc as 'server_name' or 'server_name\instance_name'. + +EXEC sp_addlinkedserver @server = N'MyLinkServer', + @srvproduct = N' ', + @provider = N'SQLNCLI10', + @datasrc = N'', + @catalog = N'AdventureWorks2012'; +GO +USE AdventureWorks2012; +GO +-- Specify the remote data source using a four-part name +-- in the form linked_server.catalog.schema.object. + +UPDATE MyLinkServer.AdventureWorks2012.HumanResources.Department +SET GroupName = N'Public Relations' +WHERE DepartmentID = 4; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Updating data in a remote table by using the OPENQUERY function + +UPDATE OPENQUERY (MyLinkServer, 'SELECT GroupName FROM HumanResources.Department WHERE DepartmentID = 4') +SET GroupName = 'Sales and Marketing'; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Updating data in a remote table by using the OPENDATASOURCE function + +UPDATE OPENQUERY (MyLinkServer, 'SELECT GroupName FROM HumanResources.Department WHERE DepartmentID = 4') +SET GroupName = 'Sales and Marketing'; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using UPDATE with .WRITE to modify data in an nvarchar(max) column +-- TODO: .WRITE + +-- USE AdventureWorks2012; +-- GO +-- DECLARE @MyTableVar table ( + -- SummaryBefore nvarchar(max), + -- SummaryAfter nvarchar(max)); +-- UPDATE Production.Document +-- SET DocumentSummary .WRITE (N'features',28,10) +-- OUTPUT deleted.DocumentSummary, + -- inserted.DocumentSummary + -- INTO @MyTableVar +-- WHERE Title = N'Front Reflector Bracket Installation'; +-- SELECT SummaryBefore, SummaryAfter +-- FROM @MyTableVar; +-- GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using UPDATE with .WRITE to modify data in an nvarchar(max) column +-- TODO: .WRITE + +-- USE AdventureWorks2012; +-- GO +-- -- Replacing NULL value with temporary data. +-- UPDATE Production.Document +-- SET DocumentSummary = N'Replacing NULL value' +-- WHERE Title = N'Crank Arm and Tire Maintenance'; +-- GO +-- SELECT DocumentSummary +-- FROM Production.Document +-- WHERE Title = N'Crank Arm and Tire Maintenance'; +-- GO +-- -- Replacing temporary data with the correct data. Setting @Length to NULL +-- -- truncates all existing data from the @Offset position. +-- UPDATE Production.Document +-- SET DocumentSummary .WRITE(N'Carefully inspect and maintain the tires and crank arms.',0,NULL) +-- WHERE Title = N'Crank Arm and Tire Maintenance'; +-- GO +-- SELECT DocumentSummary +-- FROM Production.Document +-- WHERE Title = N'Crank Arm and Tire Maintenance'; +-- GO +-- -- Appending additional data to the end of the column by setting +-- -- @Offset to NULL. +-- UPDATE Production.Document +-- SET DocumentSummary .WRITE (N' Appending data to the end of the column.', NULL, 0) +-- WHERE Title = N'Crank Arm and Tire Maintenance'; +-- GO +-- SELECT DocumentSummary +-- FROM Production.Document +-- WHERE Title = N'Crank Arm and Tire Maintenance'; +-- GO +-- -- Removing all data from @Offset to the end of the existing value by +-- -- setting expression to NULL. +-- UPDATE Production.Document +-- SET DocumentSummary .WRITE (NULL, 56, 0) +-- WHERE Title = N'Crank Arm and Tire Maintenance'; +-- GO +-- SELECT DocumentSummary +-- FROM Production.Document +-- WHERE Title = N'Crank Arm and Tire Maintenance'; +-- GO +-- -- Removing partial data beginning at position 9 and ending at +-- -- position 21. +-- UPDATE Production.Document +-- SET DocumentSummary .WRITE ('',9, 12) +-- WHERE Title = N'Crank Arm and Tire Maintenance'; +-- GO +-- SELECT DocumentSummary +-- FROM Production.Document +-- WHERE Title = N'Crank Arm and Tire Maintenance'; +-- GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using UPDATE with OPENROWSET to modify a varbinary(max) column + +USE AdventureWorks2012; +GO +UPDATE Production.ProductPhoto +SET ThumbNailPhoto = ( + SELECT * + FROM OPENROWSET(BULK 'c:\Tires.jpg', SINGLE_BLOB) AS x ) +WHERE ProductPhotoID = 1; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using UPDATE to modify FILESTREAM data + +UPDATE Archive.dbo.Records +SET [Chart] = CAST('Xray 1' as varbinary(max)) +WHERE [SerialNumber] = 2; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using a system data type + +UPDATE dbo.Cities +SET Location = CONVERT(Point, '12.3:46.2') +WHERE Name = 'Anchorage'; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Invoking a method + +UPDATE dbo.Cities +SET Location.SetXY(23.5, 23.5) +WHERE Name = 'Anchorage'; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Modifying the value of a property or data member + +UPDATE dbo.Cities +SET Location.X = 23.5 +WHERE Name = 'Anchorage'; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Specifying a table hint + +USE AdventureWorks2012; +GO +UPDATE Production.Product +WITH (TABLOCK) +SET ListPrice = ListPrice * 1.10 +WHERE ProductNumber LIKE 'BK-%'; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Specifying a query hint + +USE AdventureWorks2012; +GO +CREATE PROCEDURE Production.uspProductUpdate +@Product nvarchar(25) +AS +SET NOCOUNT ON; +UPDATE Production.Product +SET ListPrice = ListPrice * 1.10 +WHERE ProductNumber LIKE @Product +OPTION (OPTIMIZE FOR (@Product = 'BK-%') ); +GO +-- Execute the stored procedure +EXEC Production.uspProductUpdate 'BK-%'; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using UPDATE with the OUTPUT clause + +USE AdventureWorks2012; +GO +DECLARE @MyTableVar table( + EmpID int NOT NULL, + OldVacationHours int, + NewVacationHours int, + ModifiedDate datetime); +UPDATE TOP (10) HumanResources.Employee +SET VacationHours = VacationHours * 1.25, + ModifiedDate = GETDATE() +OUTPUT inserted.BusinessEntityID, + deleted.VacationHours, + inserted.VacationHours, + inserted.ModifiedDate +INTO @MyTableVar; +--Display the result set of the table variable. +SELECT EmpID, OldVacationHours, NewVacationHours, ModifiedDate +FROM @MyTableVar; +GO +--Display the result set of the table. +SELECT TOP (10) BusinessEntityID, VacationHours, ModifiedDate +FROM HumanResources.Employee; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using UPDATE in a stored procedure + +USE AdventureWorks2012; +GO +CREATE PROCEDURE HumanResources.Update_VacationHours +@NewHours smallint +AS +SET NOCOUNT ON; +UPDATE HumanResources.Employee +SET VacationHours = + ( CASE + WHEN SalariedFlag = 0 THEN VacationHours + @NewHours + ELSE @NewHours + END + ) +WHERE CurrentFlag = 1; +GO + +EXEC HumanResources.Update_VacationHours 40; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using UPDATE in a TRY…CATCH Block + +USE AdventureWorks2012; +GO +BEGIN TRANSACTION; + +BEGIN TRY + -- Intentionally generate a constraint violation error. + UPDATE HumanResources.Department + SET Name = N'MyNewName' + WHERE DepartmentID BETWEEN 1 AND 2; +END TRY +BEGIN CATCH + SELECT + ERROR_NUMBER() AS ErrorNumber + ,ERROR_SEVERITY() AS ErrorSeverity + ,ERROR_STATE() AS ErrorState + ,ERROR_PROCEDURE() AS ErrorProcedure + ,ERROR_LINE() AS ErrorLine + ,ERROR_MESSAGE() AS ErrorMessage; + + IF @@TRANCOUNT > 0 + ROLLBACK TRANSACTION; +END CATCH; + +IF @@TRANCOUNT > 0 + COMMIT TRANSACTION; +GO + +-- ROWCOUNT +SET ROWCOUNT 4; +SELECT * +FROM Production.ProductInventory +WHERE Quantity < 300; +GO diff --git a/tsql/examples/drop.sql b/tsql/examples/drop.sql new file mode 100644 index 0000000..575425c --- /dev/null +++ b/tsql/examples/drop.sql @@ -0,0 +1,91 @@ +DROP AGGREGATE dbo.Concatenate; +DROP APPLICATION ROLE rolename +DROP ASSEMBLY Helloworld ; +DROP ASYMMETRIC KEY MirandaXAsymKey6; +DROP AVAILABILITY GROUP group_name +DROP BROKER PRIORITY InitiatorAToTargetPriority +DROP CERTIFICATE certificate_name +DROP COLUMN ENCRYPTION KEY MyCEK; +DROP COLUMN MASTER KEY MyCMK; +DROP CONTRACT + [//Adventure-Works.com/Expenses/ExpenseSubmission] ; +DROP CREDENTIAL Saddles; +DROP CRYPTOGRAPHIC PROVIDER provider_name +DROP CRYPTOGRAPHIC PROVIDER SecurityProvider; +DROP CRYPTOGRAPHIC PROVIDER SecurityProvider; +GO +DROP DATABASE Sales; +DROP DATABASE Sales, NewSales; +DROP DATABASE AUDIT SPECIFICATION HIPAA_Audit_DB_Specification; +DROP DATABASE ENCRYPTION KEY; +DROP DATABASE SCOPED CREDENTIAL AppCred; +DROP DEFAULT datedflt; +DROP DEFAULT IF EXISTS datedflt; +DROP ENDPOINT sql_endpoint; +DROP EXTERNAL DATA SOURCE mydatasource; +DROP EXTERNAL FILE FORMAT myfileformat; +DROP EXTERNAL LIBRARY ggplot2 AUTHORIZATION user_name; +DROP EXTERNAL RESOURCE POOL ex_pool; +GO +ALTER RESOURCE GOVERNOR RECONFIGURE; +GO +DROP EXTERNAL TABLE SalesPerson; +DROP EXTERNAL TABLE dbo.SalesPerson; +DROP EXTERNAL TABLE EasternDivision.dbo.SalesPerson; +DROP EXTERNAL TABLE EasternDivision.dbo.SalesPerson; +DROP EVENT NOTIFICATION NotifyALTER_T1 +ON DATABASE; +DROP EVENT SESSION evt_spin_lock_diagnosis +ON SERVER; +DROP FULLTEXT INDEX ON HumanResources.JobCandidate; +DROP FULLTEXT STOPLIST myStoplist; +DROP FUNCTION Sales.fn_SalesByStore; +DROP LOGIN WilliJo; +GO +DROP MASTER KEY; +DROP MESSAGE TYPE [//Adventure-Works.com/Expenses/SubmitExpense] ; +DROP PARTITION FUNCTION myRangePF; +DROP PARTITION SCHEME myRangePS1; +DROP PROCEDURE dbo.uspMyProc; +DROP QUEUE ExpenseQueue ; +DROP REMOTE SERVICE BINDING APBinding ; +DROP RESOURCE POOL big_pool; +GO +ALTER RESOURCE GOVERNOR RECONFIGURE; +GO +DROP ROLE purchasing; +GO +DROP ROUTE ExpenseRoute ; +DROP ROUTE ExpenseRoute ; +DROP SCHEMA schema_name +DROP SEARCH PROPERTY LIST JobCandidateProperties; +GO +DROP SECURITY POLICY secPolicy; +DROP SEQUENCE CountBy1 ; +DROP SERVER AUDIT HIPAA_Audit; +DROP SERVER AUDIT SPECIFICATION HIPAA_Audit_Specification; +DROP SERVER ROLE purchasing; +GO +DROP SERVICE [//Adventure-Works.com/Expenses] ; +DROP SIGNATURE FROM HumanResources.uspUpdateEmployeeLogin + BY CERTIFICATE HumanResourcesDP; +DROP STATISTICS Purchasing.Vendor.VendorCredit, Sales.SalesOrderHeader.CustomerTotal; +DROP SYMMETRIC KEY GailSammamishKey6; +DROP SYNONYM MyProduct; +DROP TABLE AdventureWorks2012.dbo.SalesPerson2 ; +DROP TABLE #temptable; +DROP TABLE IF EXISTS T1; +DROP TRIGGER employee_insupd; +DROP TYPE ssn ; +DROP USER AbolrousHazem; +GO +DROP VIEW dbo.Reorder ; +GO +DROP WORKLOAD GROUP adhoc; +GO +ALTER RESOURCE GOVERNOR RECONFIGURE; +GO +DROP XML SCHEMA COLLECTION ManuInstructionsSchemaCollection; +GO +DROP TABLE #t1, #t2; +GO diff --git a/tsql/examples/event_notification.sql b/tsql/examples/event_notification.sql new file mode 100644 index 0000000..a206d81 --- /dev/null +++ b/tsql/examples/event_notification.sql @@ -0,0 +1,11 @@ +CREATE EVENT NOTIFICATION log_ddl1 +ON SERVER +FOR Object_Created +TO SERVICE 'NotifyService', + '8140a771-3c4b-4479-8ac0-81008ab17984' ; +CREATE EVENT NOTIFICATION Notify_ALTER_T1 +ON DATABASE +FOR ALTER_TABLE +TO SERVICE 'NotifyService', + '8140a771-3c4b-4479-8ac0-81008ab17984'; + diff --git a/tsql/examples/event_session.sql b/tsql/examples/event_session.sql new file mode 100644 index 0000000..c430a12 --- /dev/null +++ b/tsql/examples/event_session.sql @@ -0,0 +1,152 @@ +ALTER EVENT SESSION test_session +ON SERVER +STATE = start; +GO +-- Add new events to the session +ALTER EVENT SESSION test_session ON SERVER +ADD EVENT sqlserver.database_transaction_begin, +ADD EVENT sqlserver.database_transaction_end; +GO +ALTER EVENT SESSION [TrackTempdbFileWrites] +ON SERVER +DROP EVENT sqlserver.file_write_completed, +DROP EVENT sqlserver.file_written +GO +ALTER EVENT SESSION [TrackTempdbFileWrites] + ON SERVER + WITH (EVENT_RETENTION_MODE = NO_EVENT_LOSS) + GO + +/* target change */ +ALTER EVENT SESSION [AlteredState] ON SERVER +ADD TARGET package0.event_file ( SET filename = N'AlteredState' +, max_file_size = ( 50 ) +, max_rollover_files = ( 6 ) ); + + +CREATE EVENT SESSION [BucketizerTargetDemoRecompiles] +ON SERVER +ADD EVENT sqlserver.sql_statement_starting +( ACTION (sqlserver.database_id) -- database_id to bucket on +), +ADD EVENT sqlserver.sp_statement_starting +( ACTION (sqlserver.database_id) -- database_id to bucket on +) +ADD TARGET package0.asynchronous_bucketizer +( SET source_type=1, -- specifies bucketing on Action + source='sqlserver.database_id' -- Action to bucket on +) +WITH (MAX_DISPATCH_LATENCY = 5 SECONDS) +GO + +CREATE EVENT SESSION counter_test ON SERVER +ADD EVENT sqlserver.sql_statement_completed + (ACTION (sqlserver.sql_text) + WHERE package0.counter = 2) +ADD TARGET package0.ring_buffer +WITH (MAX_DISPATCH_LATENCY = 1 SECONDS) + +-- http://www.sqlteam.com/article/advanced-sql-server-2008-extended-events-with-examples + +CREATE EVENT SESSION counter_test ON SERVER +ADD EVENT sqlserver.sql_statement_completed + (ACTION (sqlserver.sql_text) + WHERE package0.counter = 2) +ADD TARGET package0.ring_buffer +WITH (MAX_DISPATCH_LATENCY = 1 SECONDS) + +CREATE EVENT SESSION counter_test_25 ON SERVER +ADD EVENT sqlserver.sql_statement_completed + (ACTION (sqlserver.sql_text) + WHERE package0.divides_by_uint64(package0.counter,4)) +ADD TARGET package0.ring_buffer +WITH (MAX_DISPATCH_LATENCY = 1 SECONDS) +GO +CREATE EVENT SESSION RingBufferExampleSession ON SERVER + ADD EVENT sqlserver.sp_statement_completed + ( + ACTION (sqlserver.sql_text, sqlserver.tsql_stack, sqlserver.transaction_id, + sqlserver.database_id, sqlserver.username) + WHERE sqlserver.database_id = 8 + ) + ADD TARGET package0.ring_buffer + (SET max_memory = 4096) +WITH (max_dispatch_latency = 1 seconds) +CREATE EVENT SESSION RingBufferExampleSession ON SERVER + ADD EVENT sqlserver.sql_statement_completed + ( + ACTION (sqlserver.session_resource_pool_id, sqlserver.sql_text, + sqlserver.tsql_stack, sqlserver.username) + WHERE sqlserver.database_id = 8 + ) + ADD TARGET package0.ring_buffer + (SET max_memory = 4096) +WITH (max_dispatch_latency = 1 seconds) + +CREATE EVENT SESSION RingBufferExampleSession ON SERVER + ADD EVENT sqlserver.page_split + ( + ACTION (sqlserver.sql_text, sqlserver.tsql_stack, sqlserver.username) + WHERE sqlserver.database_id = 8 + ) + ADD TARGET package0.ring_buffer + (SET max_memory = 4096) +WITH (max_dispatch_latency = 1 seconds) + +CREATE EVENT SESSION RingBufferExampleSession ON SERVER + ADD EVENT sqlserver.error_reported + -- collect failed SQL statement, the SQL stack that led to the error, + -- the database id in which the error happened and the username that ran the statement + ( + ACTION (sqlserver.sql_text, sqlserver.tsql_stack, sqlserver.database_id, + sqlserver.username) + WHERE sqlserver.database_id = 8 + ) + ADD TARGET package0.ring_buffer + (SET max_memory = 4096) +WITH (max_dispatch_latency = 1 seconds) +CREATE EVENT SESSION RingBufferExampleSession +ON SERVER + ADD EVENT sqlserver.lock_deadlock + ( + ACTION (sqlserver.sql_text, sqlserver.tsql_stack, sqlserver.username, + sqlserver.session_id, sqlserver.request_id) + WHERE sqlserver.database_id = 8 + ) + -- this is an optional part if we want to also collect other lock events. + -- ADD EVENT sqlserver.locks_lock_timeouts + -- ( + -- ACTION (sqlserver.sql_text, sqlserver.tsql_stack, sqlserver.username, + -- sqlserver.session_id, sqlserver.request_id) + -- WHERE sqlserver.database_id = 8 + -- ), + -- ADD EVENT sqlserver.locks_lock_waits + -- ( + -- ACTION (sqlserver.sql_text, sqlserver.tsql_stack, sqlserver.username, + -- sqlserver.session_id, sqlserver.request_id) + -- WHERE sqlserver.database_id = 8 + -- ) + ADD TARGET package0.ring_buffer + (SET max_memory = 4096) +WITH (max_dispatch_latency = 1 seconds) +CREATE EVENT SESSION RingBufferExampleSession +ON SERVER + ADD EVENT sqlserver.sql_statement_completed + ( + ACTION (sqlserver.sql_text, sqlserver.tsql_stack, sqlserver.username) + WHERE sqlserver.database_id = 8 + AND sqlserver.sql_statement_completed.duration > 500000 + ) + ADD TARGET package0.ring_buffer + (SET max_memory = 4096) +WITH (max_dispatch_latency = 1 seconds) +CREATE EVENT SESSION RingBufferExampleSession ON SERVER + ADD EVENT sqlserver.long_io_detected + ( + ACTION (sqlserver.sql_text, sqlserver.tsql_stack, sqlserver.username) + WHERE sqlserver.database_id = 8 and package0.counter > 10 + ) + ADD TARGET package0.ring_buffer + (SET max_memory = 4096) +WITH (max_dispatch_latency = 1 seconds) + diff --git a/tsql/examples/exec_first_in_batch.sql b/tsql/examples/exec_first_in_batch.sql new file mode 100644 index 0000000..93da00a --- /dev/null +++ b/tsql/examples/exec_first_in_batch.sql @@ -0,0 +1,2 @@ +thisisaprocedurecall +select * from xyz diff --git a/tsql/examples/expressions.sql b/tsql/examples/expressions.sql new file mode 100644 index 0000000..0f3c16f --- /dev/null +++ b/tsql/examples/expressions.sql @@ -0,0 +1,486 @@ +----------------------------------------------------------------------- +-- ranking_windowed_function + +-- Simple CASE expression: +-- CASE input_expression + -- WHEN when_expression THEN result_expression [ ...n ] + -- [ ELSE else_result_expression ] +-- END +-- Searched CASE expression: +-- CASE + -- WHEN Boolean_expression THEN result_expression [ ...n ] + -- [ ELSE else_result_expression ] +-- END + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using a SELECT statement with a simple CASE expression + +USE AdventureWorks2012; +GO +SELECT ProductNumber, Category = + CASE ProductLine + WHEN 'R' THEN 'Road' + WHEN 'M' THEN 'Mountain' + WHEN 'T' THEN 'Touring' + WHEN 'S' THEN 'Other sale items' + ELSE 'Not for sale' + END, + Name +FROM Production.Product +ORDER BY ProductNumber; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using a SELECT statement with a searched CASE expression + +USE AdventureWorks2012; +GO +SELECT ProductNumber, Name, "Price Range" = + CASE + WHEN ListPrice = 0 THEN 'Mfg item - not for resale' + WHEN ListPrice < 50 THEN 'Under $50' + WHEN ListPrice > = 50 and ListPrice < 250 THEN 'Under $250' + WHEN ListPrice > = 250 and ListPrice < 1000 THEN 'Under $1000' + ELSE 'Over $1000' + END +FROM Production.Product +ORDER BY ProductNumber ; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using CASE in an ORDER BY clause + +SELECT BusinessEntityID, SalariedFlag +FROM HumanResources.Employee +ORDER BY CASE SalariedFlag WHEN 1 THEN BusinessEntityID END DESC + ,CASE WHEN SalariedFlag = 0 THEN BusinessEntityID END; +GO + +SELECT BusinessEntityID, LastName, TerritoryName, CountryRegionName +FROM Sales.vSalesPerson +WHERE TerritoryName IS NOT NULL +ORDER BY CASE CountryRegionName WHEN 'United States' THEN TerritoryName + ELSE CountryRegionName END; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using CASE in an UPDATE statement + +USE AdventureWorks2012; +GO +UPDATE HumanResources.Employee +SET VacationHours = + ( CASE + WHEN ((VacationHours - 10.00) < 0) THEN VacationHours + 40 + ELSE (VacationHours + 20.00) + END + ) +OUTPUT Deleted.BusinessEntityID, Deleted.VacationHours AS BeforeValue, + Inserted.VacationHours AS AfterValue +WHERE SalariedFlag = 0; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using CASE in a SET statement +-- TODO: uncomment when create_function will be implemented. + +-- USE AdventureWorks2012; +-- GO +-- CREATE FUNCTION dbo.GetContactInformation(@BusinessEntityID int) + -- RETURNS @retContactInformation TABLE +-- ( +-- BusinessEntityID int NOT NULL, +-- FirstName nvarchar(50) NULL, +-- LastName nvarchar(50) NULL, +-- ContactType nvarchar(50) NULL, + -- PRIMARY KEY CLUSTERED (BusinessEntityID ASC) +-- ) +-- AS +-- -- Returns the first name, last name and contact type for the specified contact. +-- BEGIN + -- DECLARE + -- @FirstName nvarchar(50), + -- @LastName nvarchar(50), + -- @ContactType nvarchar(50); + + -- -- Get common contact information + -- SELECT + -- @BusinessEntityID = BusinessEntityID, +-- @FirstName = FirstName, + -- @LastName = LastName + -- FROM Person.Person + -- WHERE BusinessEntityID = @BusinessEntityID; + + -- SET @ContactType = + -- CASE + -- -- Check for employee + -- WHEN EXISTS(SELECT * FROM HumanResources.Employee AS e + -- WHERE e.BusinessEntityID = @BusinessEntityID) + -- THEN 'Employee' + + -- -- Check for vendor + -- WHEN EXISTS(SELECT * FROM Person.BusinessEntityContact AS bec + -- WHERE bec.BusinessEntityID = @BusinessEntityID) + -- THEN 'Vendor' + + -- -- Check for store + -- WHEN EXISTS(SELECT * FROM Purchasing.Vendor AS v + -- WHERE v.BusinessEntityID = @BusinessEntityID) + -- THEN 'Store Contact' + + -- -- Check for individual consumer + -- WHEN EXISTS(SELECT * FROM Sales.Customer AS c + -- WHERE c.PersonID = @BusinessEntityID) + -- THEN 'Consumer' + -- END; + + -- -- Return the information to the caller + -- IF @BusinessEntityID IS NOT NULL + -- BEGIN + -- INSERT @retContactInformation + -- SELECT @BusinessEntityID, @FirstName, @LastName, @ContactType; + -- END; + + -- RETURN; +-- END; +-- GO + +-- SELECT BusinessEntityID, FirstName, LastName, ContactType +-- FROM dbo.GetContactInformation(2200); +-- GO +-- SELECT BusinessEntityID, FirstName, LastName, ContactType +-- FROM dbo.GetContactInformation(5); + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using CASE in a HAVING clause + +USE AdventureWorks2012; +GO +SELECT JobTitle, MAX(ph1.Rate)AS MaximumRate +FROM HumanResources.Employee AS e +JOIN HumanResources.EmployeePayHistory AS ph1 ON e.BusinessEntityID = ph1.BusinessEntityID +GROUP BY JobTitle +HAVING (MAX(CASE WHEN Gender = 'M' + THEN ph1.Rate + ELSE NULL END) > 40.00 + OR MAX(CASE WHEN Gender = 'F' + THEN ph1.Rate + ELSE NULL END) > 42.00) +ORDER BY MaximumRate DESC; + +----------------------------------------------------------------------- +-- RANK https://msdn.microsoft.com/en-us/library/ms176102.aspx +-- RANK ( ) OVER ( [ partition_by_clause ] order_by_clause ) + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Ranking rows within a partition + +USE AdventureWorks2012; +GO +SELECT i.ProductID, p.Name, i.LocationID, i.Quantity + ,RANK() OVER + (PARTITION BY i.LocationID ORDER BY i.Quantity DESC) AS Rank +FROM Production.ProductInventory AS i +INNER JOIN Production.Product AS p + ON i.ProductID = p.ProductID +WHERE i.LocationID BETWEEN 3 AND 4 +ORDER BY i.LocationID; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Ranking all rows in a result set + +USE AdventureWorks2012 +SELECT TOP(10) BusinessEntityID, Rate, + RANK() OVER (ORDER BY Rate DESC) AS RankBySalary +FROM HumanResources.EmployeePayHistory AS eph1 +WHERE RateChangeDate = (SELECT MAX(RateChangeDate) + FROM HumanResources.EmployeePayHistory AS eph2 + WHERE eph1.BusinessEntityID = eph2.BusinessEntityID) +ORDER BY BusinessEntityID; + +----------------------------------------------------------------------- +-- DENSE_RANK https://msdn.microsoft.com/en-us/library/ms173825.aspx +-- DENSE_RANK ( ) OVER ( [ ] < order_by_clause > ) + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Ranking rows within a partition + +USE AdventureWorks2012; +GO +SELECT i.ProductID, p.Name, i.LocationID, i.Quantity + ,DENSE_RANK() OVER + (PARTITION BY i.LocationID ORDER BY i.Quantity DESC) AS Rank +FROM Production.ProductInventory AS i +INNER JOIN Production.Product AS p + ON i.ProductID = p.ProductID +WHERE i.LocationID BETWEEN 3 AND 4 +ORDER BY i.LocationID; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Ranking all rows in a result set + +USE AdventureWorks2012; +GO +SELECT TOP(10) BusinessEntityID, Rate, + DENSE_RANK() OVER (ORDER BY Rate DESC) AS RankBySalary +FROM HumanResources.EmployeePayHistory; + +----------------------------------------------------------------------- +-- NTILE https://msdn.microsoft.com/en-us/library/ms173825.aspx +-- NTILE (integer_expression) OVER ( [ ] < order_by_clause > ) + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Dividing rows into groups + +USE AdventureWorks2012; +GO +SELECT p.FirstName, p.LastName + ,NTILE(4) OVER(ORDER BY SalesYTD DESC) AS Quartile + ,CONVERT(nvarchar(20),s.SalesYTD,1) AS SalesYTD + , a.PostalCode +FROM Sales.SalesPerson AS s +INNER JOIN Person.Person AS p + ON s.BusinessEntityID = p.BusinessEntityID +INNER JOIN Person.Address AS a + ON a.AddressID = p.BusinessEntityID +WHERE TerritoryID IS NOT NULL + AND SalesYTD <> 0; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Dividing the result set by using PARTITION BY + +USE AdventureWorks2012; +GO +DECLARE @NTILE_Var int = 4; + +SELECT p.FirstName, p.LastName + ,NTILE(@NTILE_Var) OVER(PARTITION BY PostalCode ORDER BY SalesYTD DESC) AS Quartile + ,CONVERT(nvarchar(20),s.SalesYTD,1) AS SalesYTD + ,a.PostalCode +FROM Sales.SalesPerson AS s +INNER JOIN Person.Person AS p + ON s.BusinessEntityID = p.BusinessEntityID +INNER JOIN Person.Address AS a + ON a.AddressID = p.BusinessEntityID +WHERE TerritoryID IS NOT NULL + AND SalesYTD <> 0; +GO + +----------------------------------------------------------------------- +-- ROW_NUMBER https://msdn.microsoft.com/en-us/library/ms186734.aspx +-- ROW_NUMBER ( ) OVER ( [ PARTITION BY value_expression , ... [ n ] ] order_by_clause ) + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Returning the row number for salespeople + +USE AdventureWorks2012; +GO +SELECT ROW_NUMBER() OVER(ORDER BY SalesYTD DESC) AS Row, + FirstName, LastName, ROUND(SalesYTD,2,1) AS "Sales YTD" +FROM Sales.vSalesPerson +WHERE TerritoryName IS NOT NULL AND SalesYTD <> 0; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Returning a subset of rows + +USE AdventureWorks2012; +GO +WITH OrderedOrders AS +( + SELECT SalesOrderID, OrderDate, + ROW_NUMBER() OVER (ORDER BY OrderDate) AS RowNumber + FROM Sales.SalesOrderHeader +) +SELECT SalesOrderID, OrderDate, RowNumber +FROM OrderedOrders +WHERE RowNumber BETWEEN 50 AND 60; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using ROW_NUMBER() with PARTITION + +USE AdventureWorks2012; +GO +SELECT FirstName, LastName, TerritoryName, ROUND(SalesYTD,2,1), +ROW_NUMBER() OVER(PARTITION BY TerritoryName ORDER BY SalesYTD DESC) AS Row +FROM Sales.vSalesPerson +WHERE TerritoryName IS NOT NULL AND SalesYTD <> 0 +ORDER BY TerritoryName; + +----------------------------------------------------------------------- +-- OVER Clause https://msdn.microsoft.com/en-us/library/ms189461.aspx +-- OVER ( + -- [ ] + -- [ ] + -- [ ] + -- ) ::= +-- PARTITION BY value_expression , ... [ n ] + +-- ::= +-- ORDER BY order_by_expression + -- [ COLLATE collation_name ] + -- [ ASC | DESC ] + -- [ ,...n ] + +-- ::= +-- { ROWS | RANGE } + +-- ::= +-- { + -- | +-- } +-- ::= + -- BETWEEN AND + +-- ::= +-- { + -- | +-- } + +-- ::= +-- { + -- UNBOUNDED PRECEDING + -- | PRECEDING + -- | CURRENT ROW +-- } + +-- ::= +-- { + -- UNBOUNDED FOLLOWING + -- | FOLLOWING + -- | CURRENT ROW +-- } + +-- ::= +-- { } + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the OVER clause with the ROW_NUMBER function + +USE AdventureWorks2012; +GO +SELECT ROW_NUMBER() OVER(PARTITION BY PostalCode ORDER BY SalesYTD DESC) AS "Row Number", + p.LastName, s.SalesYTD, a.PostalCode +FROM Sales.SalesPerson AS s + INNER JOIN Person.Person AS p + ON s.BusinessEntityID = p.BusinessEntityID + INNER JOIN Person.Address AS a + ON a.AddressID = p.BusinessEntityID +WHERE TerritoryID IS NOT NULL + AND SalesYTD <> 0 +ORDER BY PostalCode; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the OVER clause with aggregate functions + +USE AdventureWorks2012; +GO +SELECT SalesOrderID, ProductID, OrderQty + ,SUM(OrderQty) OVER(PARTITION BY SalesOrderID) AS Total + ,AVG(OrderQty) OVER(PARTITION BY SalesOrderID) AS "Avg" + ,COUNT(OrderQty) OVER(PARTITION BY SalesOrderID) AS "Count" + ,MIN(OrderQty) OVER(PARTITION BY SalesOrderID) AS "Min" + ,MAX(OrderQty) OVER(PARTITION BY SalesOrderID) AS "Max" +FROM Sales.SalesOrderDetail +WHERE SalesOrderID IN(43659,43664); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the OVER clause with aggregate functions + +USE AdventureWorks2012; +GO +SELECT SalesOrderID, ProductID, OrderQty + ,SUM(OrderQty) OVER(PARTITION BY SalesOrderID) AS Total + ,CAST(1. * OrderQty / SUM(OrderQty) OVER(PARTITION BY SalesOrderID) + *100 AS DECIMAL(5,2))AS "Percent by ProductID" +FROM Sales.SalesOrderDetail +WHERE SalesOrderID IN(43659,43664); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Producing a moving average and cumulative total + +USE AdventureWorks2012; +GO +SELECT BusinessEntityID, TerritoryID + ,DATEPART(yy,ModifiedDate) AS SalesYear + ,CONVERT(varchar(20),SalesYTD,1) AS SalesYTD + ,CONVERT(varchar(20),AVG(SalesYTD) OVER (PARTITION BY TerritoryID + ORDER BY DATEPART(yy,ModifiedDate) + ),1) AS MovingAvg + ,CONVERT(varchar(20),SUM(SalesYTD) OVER (PARTITION BY TerritoryID + ORDER BY DATEPART(yy,ModifiedDate) + ),1) AS CumulativeTotal +FROM Sales.SalesPerson +WHERE TerritoryID IS NULL OR TerritoryID < 5 +ORDER BY TerritoryID,SalesYear; + +SELECT BusinessEntityID, TerritoryID + ,DATEPART(yy,ModifiedDate) AS SalesYear + ,CONVERT(varchar(20),SalesYTD,1) AS SalesYTD + ,CONVERT(varchar(20),AVG(SalesYTD) OVER (ORDER BY DATEPART(yy,ModifiedDate) + ),1) AS MovingAvg + ,CONVERT(varchar(20),SUM(SalesYTD) OVER (ORDER BY DATEPART(yy,ModifiedDate) + ),1) AS CumulativeTotal +FROM Sales.SalesPerson +WHERE TerritoryID IS NULL OR TerritoryID < 5 +ORDER BY SalesYear; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Specifying the ROWS clause + +SELECT BusinessEntityID, TerritoryID + ,CONVERT(varchar(20),SalesYTD,1) AS SalesYTD + ,DATEPART(yy,ModifiedDate) AS SalesYear + ,CONVERT(varchar(20),SUM(SalesYTD) OVER (PARTITION BY TerritoryID + ORDER BY DATEPART(yy,ModifiedDate) + ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING ),1) AS CumulativeTotal +FROM Sales.SalesPerson +WHERE TerritoryID IS NULL OR TerritoryID < 5; + +SELECT BusinessEntityID, TerritoryID + ,CONVERT(varchar(20),SalesYTD,1) AS SalesYTD + ,DATEPART(yy,ModifiedDate) AS SalesYear + ,CONVERT(varchar(20),SUM(SalesYTD) OVER (PARTITION BY TerritoryID + ORDER BY DATEPART(yy,ModifiedDate) + ROWS UNBOUNDED PRECEDING),1) AS CumulativeTotal +FROM Sales.SalesPerson +WHERE TerritoryID IS NULL OR TerritoryID < 5; + +-- addition assignment operator +DECLARE @count int = 0; +SELECT @count += 1; +SELECT @count; +GO; + +-- subtraction assignment operator +DECLARE @count int = 0; +SELECT @count -= 1; +SELECT @count; +GO; + +-- division assignment operator +DECLARE @count int = 1; +SELECT @count /= 1; +SELECT @count; +GO; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Specifying the ISNULL function + +USE AdventureWorks2012; +GO +SELECT AVG(ISNULL(Weight, 50)) +FROM Production.Product; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Specifying the STUFF function +SELECT STUFF('abcdef', 2, 3, 'ijklmn'); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +--Function with default values +SELECT * FROM fn_builtin_permissions(default); diff --git a/tsql/examples/external_data_source.sql b/tsql/examples/external_data_source.sql new file mode 100644 index 0000000..c5936a0 --- /dev/null +++ b/tsql/examples/external_data_source.sql @@ -0,0 +1,13 @@ +ALTER EXTERNAL DATA SOURCE hadoop_eds SET + LOCATION = 'hdfs://10.10.10.10:8020', + RESOURCE_MANAGER_LOCATION = '10.10.10.10:8032' + ; +ALTER EXTERNAL DATA SOURCE hadoop_eds SET + CREDENTIAL = new_hadoop_user + ; +ALTER EXTERNAL DATA SOURCE MyAzureInvoices + WITH ( + TYPE = BLOB_STORAGE, + LOCATION = 'https://newinvoices.blob.core.windows.net', + CREDENTIAL = UploadInvoices + ); diff --git a/tsql/examples/external_library.sql b/tsql/examples/external_library.sql new file mode 100644 index 0000000..06b7b9d --- /dev/null +++ b/tsql/examples/external_library.sql @@ -0,0 +1,2 @@ +CREATE EXTERNAL LIBRARY ggplot2 +FROM 'C:\Program Files\Microsoft SQL Server\MSSQL13.MSSQLSERVER\ggplot2.zip' diff --git a/tsql/examples/freetext.sql b/tsql/examples/freetext.sql new file mode 100644 index 0000000..f27febf --- /dev/null +++ b/tsql/examples/freetext.sql @@ -0,0 +1 @@ +SELECT * FROM Articles WHERE FREETEXT(Content, 'It is SQL Server'); \ No newline at end of file diff --git a/tsql/examples/full_width_chars.sql b/tsql/examples/full_width_chars.sql new file mode 100644 index 0000000..3bbd04a --- /dev/null +++ b/tsql/examples/full_width_chars.sql @@ -0,0 +1,44 @@ +----------------------------------------------------------------------- +-- Full width chars + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Japanese chars + +USE 総合販売神田店; +GO +SELECT + 製品.製品名, + 製品.製品番号, + F略称(製品.製品名) AS 略称, + オーダー.注文番号, + オーダー.数量 * 製品.単価 AS 金額, + case when オーダー.状態 = 0 then '入金待ち' + when オーダー.状態 = 1 then '入金済' + when オーダー.状態 = 2 then '発送済' + when オーダー.状態 = 9 then 'キャンセル' + end 状態 +FROM 製品情報マスタ 製品 + JOIN オーダー ON オーダー.製品番号 = 製品.製品番号 +WHERE オーダー.注文日付 >= '20160801' +; + + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Chinese chars +USE 综合量贩贩卖郑州店; +GO +SELECT + 产品.产品名, + 产品.产品编号, + F简称(产品.产品名) AS 简称, + 订单.订单号, + 订单.数量 * 产品.单价 AS 金额, + case when 订单.状态 = 0 then '等待付款' + when 订单.状态 = 1 then '已收款' + when 订单.状态 = 2 then '已发送' + when 订单.状态 = 9 then '取消' + end 状态 +FROM 产品信息 产品 + JOIN 订单 ON 订单.产品编号 = 产品.产品编号 +WHERE 订单.订购日期 >= '20160801' +; diff --git a/tsql/examples/fulltext_catalog.sql b/tsql/examples/fulltext_catalog.sql new file mode 100644 index 0000000..2ab55b9 --- /dev/null +++ b/tsql/examples/fulltext_catalog.sql @@ -0,0 +1,7 @@ +USE AdventureWorks2012; +GO +ALTER FULLTEXT CATALOG ftCatalog +REBUILD WITH ACCENT_SENSITIVITY=OFF; +GO + +CREATE FULLTEXT CATALOG ftCatalog AS DEFAULT; diff --git a/tsql/examples/gogo.sql b/tsql/examples/gogo.sql new file mode 100644 index 0000000..07dc1c5 --- /dev/null +++ b/tsql/examples/gogo.sql @@ -0,0 +1,18 @@ +GO +GO + +sp_with_some_name +;;;;;; +GO +GO +GO + +sp_with_params test + +GO + +exec sp;;;;;;;; + +GO +GO + diff --git a/tsql/examples/hierarchyid.sql b/tsql/examples/hierarchyid.sql new file mode 100644 index 0000000..f9cafb2 --- /dev/null +++ b/tsql/examples/hierarchyid.sql @@ -0,0 +1,167 @@ +DECLARE @CurrentEmployee hierarchyid +SELECT @CurrentEmployee = OrgNode FROM HumanResources.EmployeeDemo +WHERE LoginID = 'adventure-works\david0' + +SELECT OrgNode.ToString() AS Text_OrgNode, * +FROM HumanResources.EmployeeDemo +WHERE OrgNode.GetAncestor(1) = @CurrentEmployee ; + +DECLARE @CurrentEmployee hierarchyid +SELECT @CurrentEmployee = OrgNode FROM HumanResources.EmployeeDemo +WHERE LoginID = 'adventure-works\ken0' + +SELECT OrgNode.ToString() AS Text_OrgNode, * +FROM HumanResources.EmployeeDemo +WHERE OrgNode.GetAncestor(2) = @CurrentEmployee ; + +DECLARE @CurrentEmployee hierarchyid +SELECT @CurrentEmployee = OrgNode FROM HumanResources.EmployeeDemo +WHERE LoginID = 'adventure-works\david0' + +SELECT OrgNode.ToString() AS Text_OrgNode, * +FROM HumanResources.EmployeeDemo +WHERE OrgNode.GetAncestor(0) = @CurrentEmployee ; + +DECLARE @CurrentEmployee hierarchyid ; +DECLARE @TargetEmployee hierarchyid ; +SELECT @CurrentEmployee = '/2/3/1.2/5/3/' ; +SELECT @TargetEmployee = @CurrentEmployee.GetAncestor(2) ; +SELECT @TargetEmployee.ToString(), @TargetEmployee ; + +DECLARE @Manager hierarchyid; +SET @Manager = CAST('/3/1/' AS hierarchyid); + +INSERT HumanResources.EmployeeDemo (OrgNode, LoginID, Title, HireDate) +VALUES +(@Manager.GetDescendant(NULL, NULL), +'adventure-works\FirstNewEmployee', 'Application Intern', '3/11/07') ; + +DECLARE @Manager hierarchyid, @Child1 hierarchyid; + +SET @Manager = CAST('/3/1/' AS hierarchyid); +SET @Child1 = CAST('/3/1/1/' AS hierarchyid); + +INSERT HumanResources.EmployeeDemo (OrgNode, LoginID, Title, HireDate) +VALUES +(@Manager.GetDescendant(@Child1, NULL), +'adventure-works\SecondNewEmployee', 'Application Intern', '3/11/07') ; + +DECLARE @Manager hierarchyid, @Child1 hierarchyid, @Child2 hierarchyid; + +SET @Manager = CAST('/3/1/' AS hierarchyid); +SET @Child1 = CAST('/3/1/1/' AS hierarchyid); +SET @Child2 = CAST('/3/1/2/' AS hierarchyid); + +INSERT HumanResources.EmployeeDemo (OrgNode, LoginID, Title, HireDate) +VALUES +(@Manager.GetDescendant(@Child1, @Child2), +'adventure-works\ThirdNewEmployee', 'Application Intern', '3/11/07') ; + +DECLARE @h hierarchyid = hierarchyid::GetRoot(); +DECLARE @c hierarchyid = @h.GetDescendant(NULL, NULL); +SELECT @c.ToString(); +DECLARE @c2 hierarchyid = @h.GetDescendant(@c, NULL); +SELECT @c2.ToString(); +SET @c2 = @h.GetDescendant(@c, @c2); +SELECT @c2.ToString(); +SET @c = @h.GetDescendant(@c, @c2); +SELECT @c.ToString(); +SET @c2 = @h.GetDescendant(@c, @c2); +SELECT @c2.ToString(); + +SELECT OrgNode.ToString() AS Text_OrgNode, +OrgNode.GetLevel() AS EmpLevel, * +FROM HumanResources.EmployeeDemo; + +SELECT OrgNode.ToString() AS Text_OrgNode, +OrgNode.GetLevel() AS EmpLevel, * +FROM HumanResources.EmployeeDemo +WHERE OrgNode.GetLevel() = 2; + +SELECT OrgNode.ToString() AS Text_OrgNode, +OrgNode.GetLevel() AS EmpLevel, * +FROM HumanResources.EmployeeDemo +WHERE OrgNode.GetLevel() = 0; + +SELECT OrgNode.ToString() AS Text_OrgNode, * +FROM HumanResources.EmployeeDemo +WHERE OrgNode = hierarchyid::GetRoot() + +DECLARE @Manager hierarchyid +SELECT @Manager = OrgNode FROM HumanResources.EmployeeDemo + WHERE LoginID = 'adventure-works\dylan0' + +SELECT * FROM HumanResources.EmployeeDemo +WHERE OrgNode.IsDescendantOf(@Manager) = 1 + +DECLARE @Manager hierarchyid, @Employee hierarchyid, @LoginID nvarchar(256) +SELECT @Manager = OrgNode FROM HumanResources.EmployeeDemo +WHERE LoginID = 'adventure-works\terri0' ; + +SELECT @Employee = OrgNode, @LoginID = LoginID FROM HumanResources.EmployeeDemo + WHERE LoginID = 'adventure-works\rob0' + +IF @Employee.IsDescendantOf(@Manager) = 1 + BEGIN + PRINT 'LoginID ' + @LoginID + ' is a subordinate of the selected Manager.' + END +ELSE + BEGIN + PRINT 'LoginID ' + @LoginID + ' is not a subordinate of the selected Manager.' ; + END + +DECLARE @StringValue AS NVARCHAR(4000), @hierarchyidValue AS hierarchyid +SET @StringValue = '/1/1/3/' +SET @hierarchyidValue = 0x5ADE + +SELECT hierarchyid::Parse(@StringValue) AS hierarchyidRepresentation, +@hierarchyidValue.ToString() AS StringRepresentation ; +GO + +DECLARE @SubjectEmployee hierarchyid , @OldParent hierarchyid, @NewParent hierarchyid +SELECT @SubjectEmployee = OrgNode FROM HumanResources.EmployeeDemo + WHERE LoginID = 'adventure-works\gail0' ; +SELECT @OldParent = OrgNode FROM HumanResources.EmployeeDemo + WHERE LoginID = 'adventure-works\roberto0' ; -- who is /1/1/ +SELECT @NewParent = OrgNode FROM HumanResources.EmployeeDemo + WHERE LoginID = 'adventure-works\wanida0' ; -- who is /2/3/ + +SELECT OrgNode.ToString() AS Current_OrgNode_AS_Text, +(@SubjectEmployee. GetReparentedValue(@OldParent, @NewParent) ).ToString() AS Proposed_OrgNode_AS_Text, +OrgNode AS Current_OrgNode, +@SubjectEmployee. GetReparentedValue(@OldParent, @NewParent) AS Proposed_OrgNode, +* +FROM HumanResources.EmployeeDemo +WHERE OrgNode = @SubjectEmployee ; +GO + +DECLARE @SubjectEmployee hierarchyid , @OldParent hierarchyid, @NewParent hierarchyid +SELECT @SubjectEmployee = OrgNode FROM HumanResources.EmployeeDemo + WHERE LoginID = 'adventure-works\gail0' ; -- Node /1/1/2/ +SELECT @OldParent = OrgNode FROM HumanResources.EmployeeDemo + WHERE LoginID = 'adventure-works\roberto0' ; -- Node /1/1/ +SELECT @NewParent = OrgNode FROM HumanResources.EmployeeDemo + WHERE LoginID = 'adventure-works\wanida0' ; -- Node /2/3/ + +UPDATE HumanResources.EmployeeDemo +SET OrgNode = @SubjectEmployee. GetReparentedValue(@OldParent, @NewParent) +WHERE OrgNode = @SubjectEmployee ; + +SELECT OrgNode.ToString() AS Current_OrgNode_AS_Text, +* +FROM HumanResources.EmployeeDemo +WHERE LoginID = 'adventure-works\gail0' ; -- Now node /2/3/2/ + +SELECT OrgNode, +OrgNode.ToString() AS Node +FROM HumanResources.EmployeeDemo +ORDER BY OrgNode ; +GO + +DECLARE @StringValue AS nvarchar(4000), @hierarchyidValue AS hierarchyid +SET @StringValue = '/1/1/3/' +SET @hierarchyidValue = 0x5ADE + +SELECT hierarchyid::Parse(@StringValue) AS hierarchyidRepresentation, +@hierarchyidValue.ToString() AS StringRepresentation ; +GO diff --git a/tsql/examples/hints.sql b/tsql/examples/hints.sql new file mode 100644 index 0000000..4218ee8 --- /dev/null +++ b/tsql/examples/hints.sql @@ -0,0 +1,65 @@ +UPDATE [dbo].[FactResellerSalesXL_CCI] WITH (ROWLOCK) +SET UnitPrice = 50 +WHERE ProductKey = 150; + +SELECT * +FROM dbo.Customers AS c WITH (SNAPSHOT) +LEFT JOIN dbo.[Order History] AS oh + ON c.customer_id=oh.customer_id; + +IF EXISTS (SELECT name FROM sys.indexes + WHERE name = N'FIBillOfMaterialsWithComponentID' + AND object_id = OBJECT_ID(N'Production.BillOfMaterials')) +DROP INDEX FIBillOfMaterialsWithComponentID + ON Production.BillOfMaterials; +GO +CREATE NONCLUSTERED INDEX "FIBillOfMaterialsWithComponentID" + ON Production.BillOfMaterials (ComponentID, StartDate, EndDate) + WHERE ComponentID IN (533, 324, 753); +GO +SELECT StartDate, ComponentID FROM Production.BillOfMaterials + WITH( INDEX (FIBillOfMaterialsWithComponentID) ) + WHERE ComponentID in (533, 324, 753, 855, 924); +GO + +UPDATE Production.Product +WITH (TABLOCK) +SET ListPrice = ListPrice * 1.10 +WHERE ProductNumber LIKE 'BK-%'; +GO + +SELECT * +FROM Sales.SalesOrderHeader AS h +INNER JOIN Sales.SalesOrderDetail AS d WITH (FORCESEEK) + ON h.SalesOrderID = d.SalesOrderID +WHERE h.TotalDue > 100 +AND (d.OrderQty > 5 OR d.LineTotal < 1000.00); +GO + +SELECT h.SalesOrderID, h.TotalDue, d.OrderQty +FROM Sales.SalesOrderHeader AS h + INNER JOIN Sales.SalesOrderDetail AS d + WITH (FORCESEEK (PK_SalesOrderDetail_SalesOrderID_SalesOrderDetailID (SalesOrderID))) + ON h.SalesOrderID = d.SalesOrderID +WHERE h.TotalDue > 100 +AND (d.OrderQty > 5 OR d.LineTotal < 1000.00); +GO + +SELECT h.SalesOrderID, h.TotalDue, d.OrderQty +FROM Sales.SalesOrderHeader AS h + INNER JOIN Sales.SalesOrderDetail AS d + WITH (FORCESCAN) + ON h.SalesOrderID = d.SalesOrderID +WHERE h.TotalDue > 100 +AND (d.OrderQty > 5 OR d.LineTotal < 1000.00); + +-- + +-- This is no hint but an alias +update alias set x = 1 from t alias + +-- These are hints on tables, not function calls +select * from dbo.t (nolock) t join dbo.u (nolock) on t.x = u.x +select * from dbo.t (nolock) ta join dbo.u (nolock) ua on t.x = ua.x +select * from t (nolock) ta +select * from t ta (nolock) diff --git a/tsql/examples/issue978.sql b/tsql/examples/issue978.sql new file mode 100644 index 0000000..ef2c194 --- /dev/null +++ b/tsql/examples/issue978.sql @@ -0,0 +1,4 @@ +UPDATE #TEMP_DG_RIPO +SET UEBERGEORDNETE_HANDELSSTELLE_NAME = H.BEZEICHNUNG_DE +FROM #TEMP_DG_RIPO R + LEFT JOIN DM.VW_DM_PR_HANDELSSTELLE H WITH (NOLOCK) ON H.HANDELSSTELLE = R.UEBERGEORDNETE_HANDELSSTELLE_NUMMER diff --git a/tsql/examples/issue_2282.sql b/tsql/examples/issue_2282.sql new file mode 100644 index 0000000..956d176 --- /dev/null +++ b/tsql/examples/issue_2282.sql @@ -0,0 +1,3 @@ +CREATE TABLE [dbo].[myTable] ( + [Description] [varchar](max) NULL +) diff --git a/tsql/examples/issue_3300.sql b/tsql/examples/issue_3300.sql new file mode 100644 index 0000000..c6f517e --- /dev/null +++ b/tsql/examples/issue_3300.sql @@ -0,0 +1,7 @@ +CREATE SCHEMA raw; + +CREATE TABLE raw.test_tbl ( + foo INT +); + +SELECT * FROM raw.test_tbl; \ No newline at end of file diff --git a/tsql/examples/issue_924_925.sql b/tsql/examples/issue_924_925.sql new file mode 100644 index 0000000..71ab16d --- /dev/null +++ b/tsql/examples/issue_924_925.sql @@ -0,0 +1,27 @@ +CREATE FUNCTION [Report].[DataSet] + ( + @Monat TINYINT , + @Jahr SMALLINT + ) +RETURNS @xxx TABLE + ( + [AUSLASTUNGSBETRAG_STICHTAG] DECIMAL(28, 4) , + [AUSLASTUNGSBETRAG_VERGLEICHSSTICHTAG] DECIMAL(28, 4) , + RATINGNOTE INT + ) +AS + BEGIN + INSERT INTO @xxx + ( AUSLASTUNGSBETRAG_STICHTAG , + AUSLASTUNGSBETRAG_VERGLEICHSSTICHTAG , + RATINGNOTE + ) + SELECT [AUSLASTUNGSBETRAG_STICHTAG] = SUM(Stichtage.[Auslastungsbetrag zum Stichtag]) , + [AUSLASTUNGSBETRAG_VERGLEICHSSTICHTAG] = SUM(Stichtage.[Auslastungsbetrag zum Vergleichsstichtag]) , + RATINGNOTE = ISNULL(CAST(RATING.RATINGNOTE_KURZ AS INT), + -1) + FROM aaa.bbb; + RETURN; + END; + + diff --git a/tsql/examples/issue_927.sql b/tsql/examples/issue_927.sql new file mode 100644 index 0000000..e698bc6 --- /dev/null +++ b/tsql/examples/issue_927.sql @@ -0,0 +1,12 @@ +CREATE FUNCTION heiko.[Abc] + ( + @Stichtag_Version_DM_SID INT + ) + RETURNS TABLE AS RETURN + ( + WITH Cde AS + ( + SELECT 1 B + ) + SELECT 2 A + ) \ No newline at end of file diff --git a/tsql/examples/json_data_type.sql b/tsql/examples/json_data_type.sql new file mode 100644 index 0000000..2f12575 --- /dev/null +++ b/tsql/examples/json_data_type.sql @@ -0,0 +1,22 @@ +SELECT F +FROM (SELECT 1 AS F) AS T +FOR JSON AUTO, WITHOUT_ARRAY_WRAPPER, INCLUDE_NULL_VALUES; +GO; + +-- With another order of options +SELECT F +FROM (SELECT 1 AS F) AS T +FOR JSON AUTO, INCLUDE_NULL_VALUES, WITHOUT_ARRAY_WRAPPER; +GO; + +-- Without additional options +SELECT F +FROM (SELECT 1 AS F) AS T +FOR JSON AUTO; +GO; + +-- With ROOT +SELECT F +FROM (SELECT 1 AS F) AS T +FOR JSON AUTO, INCLUDE_NULL_VALUES, ROOT('r'); +GO; \ No newline at end of file diff --git a/tsql/examples/keywords_as_id.sql b/tsql/examples/keywords_as_id.sql new file mode 100644 index 0000000..ab8bd0e --- /dev/null +++ b/tsql/examples/keywords_as_id.sql @@ -0,0 +1,877 @@ +select ABORT from (select 1 as ABORT) t; +select ABSOLUTE from (select 1 as ABSOLUTE) t; +select ACCENT_SENSITIVITY from (select 1 as ACCENT_SENSITIVITY) t; +select ACCESS from (select 1 as ACCESS) t; +select ACTION from (select 1 as ACTION) t; +select ACTIVATION from (select 1 as ACTIVATION) t; +select ACTIVE from (select 1 as ACTIVE) t; +select ADDRESS from (select 1 as ADDRESS) t; +select AES_128 from (select 1 as AES_128) t; +select AES_192 from (select 1 as AES_192) t; +select AES_256 from (select 1 as AES_256) t; +select AFFINITY from (select 1 as AFFINITY) t; +select AFTER from (select 1 as AFTER) t; +select AGGREGATE from (select 1 as AGGREGATE) t; +select ALGORITHM from (select 1 as ALGORITHM) t; +select ALL_CONSTRAINTS from (select 1 as ALL_CONSTRAINTS) t; +select ALL_ERRORMSGS from (select 1 as ALL_ERRORMSGS) t; +select ALL_INDEXES from (select 1 as ALL_INDEXES) t; +select ALL_LEVELS from (select 1 as ALL_LEVELS) t; +select ALLOW_ENCRYPTED_VALUE_MODIFICATIONS from (select 1 as ALLOW_ENCRYPTED_VALUE_MODIFICATIONS) t; +select ALLOW_PAGE_LOCKS from (select 1 as ALLOW_PAGE_LOCKS) t; +select ALLOW_ROW_LOCKS from (select 1 as ALLOW_ROW_LOCKS) t; +select ALLOW_SNAPSHOT_ISOLATION from (select 1 as ALLOW_SNAPSHOT_ISOLATION) t; +select ALLOWED from (select 1 as ALLOWED) t; +select ALWAYS from (select 1 as ALWAYS) t; +select ANSI_NULL_DEFAULT from (select 1 as ANSI_NULL_DEFAULT) t; +select ANSI_NULLS from (select 1 as ANSI_NULLS) t; +select ANSI_PADDING from (select 1 as ANSI_PADDING) t; +select ANSI_WARNINGS from (select 1 as ANSI_WARNINGS) t; +select APP_NAME from (select 1 as APP_NAME) t; +select APPLICATION_LOG from (select 1 as APPLICATION_LOG) t; +select APPLOCK_MODE from (select 1 as APPLOCK_MODE) t; +select APPLOCK_TEST from (select 1 as APPLOCK_TEST) t; +select APPLY from (select 1 as APPLY) t; +select ARITHABORT from (select 1 as ARITHABORT) t; +select ASCII from (select 1 as ASCII) t; +select ASSEMBLY from (select 1 as ASSEMBLY) t; +select ASSEMBLYPROPERTY from (select 1 as ASSEMBLYPROPERTY) t; +select AT from (select 1 as AT) t; +select AUDIT from (select 1 as AUDIT) t; +select AUDIT_GUID from (select 1 as AUDIT_GUID) t; +select AUTO from (select 1 as AUTO) t; +select AUTO_CLEANUP from (select 1 as AUTO_CLEANUP) t; +select AUTO_CLOSE from (select 1 as AUTO_CLOSE) t; +select AUTO_CREATE_STATISTICS from (select 1 as AUTO_CREATE_STATISTICS) t; +select AUTO_DROP from (select 1 as AUTO_DROP) t; +select AUTO_SHRINK from (select 1 as AUTO_SHRINK) t; +select AUTO_UPDATE_STATISTICS from (select 1 as AUTO_UPDATE_STATISTICS) t; +select AUTO_UPDATE_STATISTICS_ASYNC from (select 1 as AUTO_UPDATE_STATISTICS_ASYNC) t; +select AUTOGROW_ALL_FILES from (select 1 as AUTOGROW_ALL_FILES) t; +select AUTOGROW_SINGLE_FILE from (select 1 as AUTOGROW_SINGLE_FILE) t; +select AVAILABILITY from (select 1 as AVAILABILITY) t; +select AVG from (select 1 as AVG) t; +select BACKUP_CLONEDB from (select 1 as BACKUP_CLONEDB) t; +select BACKUP_PRIORITY from (select 1 as BACKUP_PRIORITY) t; +select BASE64 from (select 1 as BASE64) t; +select BEGIN_DIALOG from (select 1 as BEGIN_DIALOG) t; +select BIGINT from (select 1 as BIGINT) t; +select BINARY from (select 1 as BINARY) t; +select BINARY_CHECKSUM from (select 1 as BINARY_CHECKSUM) t; +select BINDING from (select 1 as BINDING) t; +select BLOB_STORAGE from (select 1 as BLOB_STORAGE) t; +select BROKER from (select 1 as BROKER) t; +select BROKER_INSTANCE from (select 1 as BROKER_INSTANCE) t; +select BULK_LOGGED from (select 1 as BULK_LOGGED) t; +select CALLER from (select 1 as CALLER) t; +select CAP_CPU_PERCENT from (select 1 as CAP_CPU_PERCENT) t; +select CAST from (select 1 as CAST) t; +select TRY_CAST from (select 1 as TRY_CAST) t; +select CATALOG from (select 1 as CATALOG) t; +select CATCH from (select 1 as CATCH) t; +select CHANGE from (select 1 as CHANGE) t; +select CHANGE_RETENTION from (select 1 as CHANGE_RETENTION) t; +select CHANGE_TRACKING from (select 1 as CHANGE_TRACKING) t; +select CHAR from (select 1 as CHAR) t; +select CHARINDEX from (select 1 as CHARINDEX) t; +select CHECKALLOC from (select 1 as CHECKALLOC) t; +select CHECKCATALOG from (select 1 as CHECKCATALOG) t; +select CHECKCONSTRAINTS from (select 1 as CHECKCONSTRAINTS) t; +select CHECKDB from (select 1 as CHECKDB) t; +select CHECKFILEGROUP from (select 1 as CHECKFILEGROUP) t; +select CHECKSUM from (select 1 as CHECKSUM) t; +select CHECKSUM_AGG from (select 1 as CHECKSUM_AGG) t; +select CHECKTABLE from (select 1 as CHECKTABLE) t; +select CLEANTABLE from (select 1 as CLEANTABLE) t; +select CLEANUP from (select 1 as CLEANUP) t; +select CLONEDATABASE from (select 1 as CLONEDATABASE) t; +select COL_LENGTH from (select 1 as COL_LENGTH) t; +select COL_NAME from (select 1 as COL_NAME) t; +select COLLECTION from (select 1 as COLLECTION) t; +select COLUMN_ENCRYPTION_KEY from (select 1 as COLUMN_ENCRYPTION_KEY) t; +select COLUMN_MASTER_KEY from (select 1 as COLUMN_MASTER_KEY) t; +select COLUMNPROPERTY from (select 1 as COLUMNPROPERTY) t; +select COLUMNS from (select 1 as COLUMNS) t; +select COLUMNSTORE from (select 1 as COLUMNSTORE) t; +select COLUMNSTORE_ARCHIVE from (select 1 as COLUMNSTORE_ARCHIVE) t; +select COMMITTED from (select 1 as COMMITTED) t; +select COMPATIBILITY_LEVEL from (select 1 as COMPATIBILITY_LEVEL) t; +select COMPRESS_ALL_ROW_GROUPS from (select 1 as COMPRESS_ALL_ROW_GROUPS) t; +select COMPRESSION_DELAY from (select 1 as COMPRESSION_DELAY) t; +select CONCAT from (select 1 as CONCAT) t; +select CONCAT_WS from (select 1 as CONCAT_WS) t; +select CONCAT_NULL_YIELDS_NULL from (select 1 as CONCAT_NULL_YIELDS_NULL) t; +select CONTENT from (select 1 as CONTENT) t; +select CONTROL from (select 1 as CONTROL) t; +select COOKIE from (select 1 as COOKIE) t; +select COUNT from (select 1 as COUNT) t; +select COUNT_BIG from (select 1 as COUNT_BIG) t; +select COUNTER from (select 1 as COUNTER) t; +select CPU from (select 1 as CPU) t; +select CREATE_NEW from (select 1 as CREATE_NEW) t; +select CREATION_DISPOSITION from (select 1 as CREATION_DISPOSITION) t; +select CREDENTIAL from (select 1 as CREDENTIAL) t; +select CRYPTOGRAPHIC from (select 1 as CRYPTOGRAPHIC) t; +select CUME_DIST from (select 1 as CUME_DIST) t; +select CURSOR_CLOSE_ON_COMMIT from (select 1 as CURSOR_CLOSE_ON_COMMIT) t; +select CURSOR_DEFAULT from (select 1 as CURSOR_DEFAULT) t; +select CURSOR_STATUS from (select 1 as CURSOR_STATUS) t; +select DATA from (select 1 as DATA) t; +select DATA_PURITY from (select 1 as DATA_PURITY) t; +select DATABASE_PRINCIPAL_ID from (select 1 as DATABASE_PRINCIPAL_ID) t; +select DATABASEPROPERTYEX from (select 1 as DATABASEPROPERTYEX) t; +select DATALENGTH from (select 1 as DATALENGTH) t; +select DATE_CORRELATION_OPTIMIZATION from (select 1 as DATE_CORRELATION_OPTIMIZATION) t; +select DATEADD from (select 1 as DATEADD) t; +select DATEDIFF from (select 1 as DATEDIFF) t; +select DATENAME from (select 1 as DATENAME) t; +select DATEPART from (select 1 as DATEPART) t; +select DAYS from (select 1 as DAYS) t; +select DB_CHAINING from (select 1 as DB_CHAINING) t; +select DB_FAILOVER from (select 1 as DB_FAILOVER) t; +select DB_ID from (select 1 as DB_ID) t; +select DB_NAME from (select 1 as DB_NAME) t; +select DBREINDEX from (select 1 as DBREINDEX) t; +select DECRYPTION from (select 1 as DECRYPTION) t; +select "DEFAULT" from (select 1 as "DEFAULT") t; +select DEFAULT_FULLTEXT_LANGUAGE from (select 1 as DEFAULT_FULLTEXT_LANGUAGE) t; +select DEFAULT_LANGUAGE from (select 1 as DEFAULT_LANGUAGE) t; +select DEFINITION from (select 1 as DEFINITION) t; +select DELAY from (select 1 as DELAY) t; +select DELAYED_DURABILITY from (select 1 as DELAYED_DURABILITY) t; +select DELETED from (select 1 as DELETED) t; +select DENSE_RANK from (select 1 as DENSE_RANK) t; +select DEPENDENTS from (select 1 as DEPENDENTS) t; +select DES from (select 1 as DES) t; +select DESCRIPTION from (select 1 as DESCRIPTION) t; +select DESX from (select 1 as DESX) t; +select DETERMINISTIC from (select 1 as DETERMINISTIC) t; +select DHCP from (select 1 as DHCP) t; +select DIALOG from (select 1 as DIALOG) t; +select DIFFERENCE from (select 1 as DIFFERENCE) t; +select DIRECTORY_NAME from (select 1 as DIRECTORY_NAME) t; +select DISABLE from (select 1 as DISABLE) t; +select DISABLE_BROKER from (select 1 as DISABLE_BROKER) t; +select DISABLED from (select 1 as DISABLED) t; +select DOCUMENT from (select 1 as DOCUMENT) t; +select DROP_EXISTING from (select 1 as DROP_EXISTING) t; +select DROPCLEANBUFFERS from (select 1 as DROPCLEANBUFFERS) t; +select DYNAMIC from (select 1 as DYNAMIC) t; +select ELEMENTS from (select 1 as ELEMENTS) t; +select EMERGENCY from (select 1 as EMERGENCY) t; +select EMPTY from (select 1 as EMPTY) t; +select ENABLE from (select 1 as ENABLE) t; +select ENABLE_BROKER from (select 1 as ENABLE_BROKER) t; +select ENCRYPTED from (select 1 as ENCRYPTED) t; +select ENCRYPTED_VALUE from (select 1 as ENCRYPTED_VALUE) t; +select ENCRYPTION from (select 1 as ENCRYPTION) t; +select ENCRYPTION_TYPE from (select 1 as ENCRYPTION_TYPE) t; +select ENDPOINT_URL from (select 1 as ENDPOINT_URL) t; +select ERROR_BROKER_CONVERSATIONS from (select 1 as ERROR_BROKER_CONVERSATIONS) t; +select ESTIMATEONLY from (select 1 as ESTIMATEONLY) t; +select EXCLUSIVE from (select 1 as EXCLUSIVE) t; +select EXECUTABLE from (select 1 as EXECUTABLE) t; +select EXIST from (select 1 as EXIST) t; +select [EXIST] from (select 1 as [EXIST]) t; +select EXPAND from (select 1 as EXPAND) t; +select EXPIRY_DATE from (select 1 as EXPIRY_DATE) t; +select EXPLICIT from (select 1 as EXPLICIT) t; +select EXTENDED_LOGICAL_CHECKS from (select 1 as EXTENDED_LOGICAL_CHECKS) t; +select FAIL_OPERATION from (select 1 as FAIL_OPERATION) t; +select FAILOVER_MODE from (select 1 as FAILOVER_MODE) t; +select FAILURE from (select 1 as FAILURE) t; +select FAILURE_CONDITION_LEVEL from (select 1 as FAILURE_CONDITION_LEVEL) t; +select FAST from (select 1 as FAST) t; +select FAST_FORWARD from (select 1 as FAST_FORWARD) t; +select FILE_ID from (select 1 as FILE_ID) t; +select FILE_IDEX from (select 1 as FILE_IDEX) t; +select FILE_NAME from (select 1 as FILE_NAME) t; +select FILEGROUP from (select 1 as FILEGROUP) t; +select FILEGROUP_ID from (select 1 as FILEGROUP_ID) t; +select FILEGROUP_NAME from (select 1 as FILEGROUP_NAME) t; +select FILEGROUPPROPERTY from (select 1 as FILEGROUPPROPERTY) t; +select FILEGROWTH from (select 1 as FILEGROWTH) t; +select FILENAME from (select 1 as FILENAME) t; +select FILEPATH from (select 1 as FILEPATH) t; +select FILEPROPERTY from (select 1 as FILEPROPERTY) t; +select FILEPROPERTYEX from (select 1 as FILEPROPERTYEX) t; +select FILESTREAM from (select 1 as FILESTREAM) t; +select FILTER from (select 1 as FILTER) t; +select FIRST from (select 1 as FIRST) t; +select FIRST_VALUE from (select 1 as FIRST_VALUE) t; +select FOLLOWING from (select 1 as FOLLOWING) t; +select FORCE from (select 1 as FORCE) t; +select FORCE_FAILOVER_ALLOW_DATA_LOSS from (select 1 as FORCE_FAILOVER_ALLOW_DATA_LOSS) t; +select FORCED from (select 1 as FORCED) t; +select FORCESCAN from (select 1 as FORCESCAN) t; +select FORMAT from (select 1 as FORMAT) t; +select FORWARD_ONLY from (select 1 as FORWARD_ONLY) t; +select FREE from (select 1 as FREE) t; +select FULLSCAN from (select 1 as FULLSCAN) t; +select FULLTEXT from (select 1 as FULLTEXT) t; +select FULLTEXTCATALOGPROPERTY from (select 1 as FULLTEXTCATALOGPROPERTY) t; +select FULLTEXTSERVICEPROPERTY from (select 1 as FULLTEXTSERVICEPROPERTY) t; +select GB from (select 1 as GB) t; +select GENERATED from (select 1 as GENERATED) t; +select GETDATE from (select 1 as GETDATE) t; +select GETUTCDATE from (select 1 as GETUTCDATE) t; +select GLOBAL from (select 1 as GLOBAL) t; +select GO from (select 1 as GO) t; +select GREATEST from (select 1 as GREATEST) t; +select GROUP_MAX_REQUESTS from (select 1 as GROUP_MAX_REQUESTS) t; +select GROUPING from (select 1 as GROUPING) t; +select GROUPING_ID from (select 1 as GROUPING_ID) t; +select HADR from (select 1 as HADR) t; +select HASH from (select 1 as HASH) t; +select HEALTH_CHECK_TIMEOUT from (select 1 as HEALTH_CHECK_TIMEOUT) t; +select HIDDEN from (select 1 as HIDDEN) t; +select HIGH from (select 1 as HIGH) t; +select HONOR_BROKER_PRIORITY from (select 1 as HONOR_BROKER_PRIORITY) t; +select HOURS from (select 1 as HOURS) t; +select IDENT_CURRENT from (select 1 as IDENT_CURRENT) t; +select IDENT_INCR from (select 1 as IDENT_INCR) t; +select IDENT_SEED from (select 1 as IDENT_SEED) t; +select IDENTITY_VALUE from (select 1 as IDENTITY_VALUE) t; +select IGNORE_CONSTRAINTS from (select 1 as IGNORE_CONSTRAINTS) t; +select IGNORE_DUP_KEY from (select 1 as IGNORE_DUP_KEY) t; +select IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX from (select 1 as IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX) t; +select IGNORE_REPLICATED_TABLE_CACHE from (select 1 as IGNORE_REPLICATED_TABLE_CACHE) t; +select IGNORE_TRIGGERS from (select 1 as IGNORE_TRIGGERS) t; +select IMMEDIATE from (select 1 as IMMEDIATE) t; +select IMPERSONATE from (select 1 as IMPERSONATE) t; +select IMPORTANCE from (select 1 as IMPORTANCE) t; +select INCLUDE_NULL_VALUES from (select 1 as INCLUDE_NULL_VALUES) t; +select INCREMENTAL from (select 1 as INCREMENTAL) t; +select INDEX_COL from (select 1 as INDEX_COL) t; +select INDEXKEY_PROPERTY from (select 1 as INDEXKEY_PROPERTY) t; +select INDEXPROPERTY from (select 1 as INDEXPROPERTY) t; +select INITIATOR from (select 1 as INITIATOR) t; +select INPUT from (select 1 as INPUT) t; +select INSENSITIVE from (select 1 as INSENSITIVE) t; +select INSERTED from (select 1 as INSERTED) t; +select INT from (select 1 as INT) t; +select IP from (select 1 as IP) t; +select ISJSON from (select 1 as ISJSON) t; +select ISOLATION from (select 1 as ISOLATION) t; +select JOB from (select 1 as JOB) t; +select JSON from (select 1 as JSON) t; +select JSON_OBJECT from (select 1 as JSON_OBJECT) t; +select JSON_ARRAY from (select 1 as JSON_ARRAY) t; +select JSON_VALUE from (select 1 as JSON_VALUE) t; +select JSON_QUERY from (select 1 as JSON_QUERY) t; +select JSON_MODIFY from (select 1 as JSON_MODIFY) t; +select JSON_PATH_EXISTS from (select 1 as JSON_PATH_EXISTS) t; +select KB from (select 1 as KB) t; +select KEEP from (select 1 as KEEP) t; +select KEEPDEFAULTS from (select 1 as KEEPDEFAULTS) t; +select KEEPFIXED from (select 1 as KEEPFIXED) t; +select KEEPIDENTITY from (select 1 as KEEPIDENTITY) t; +select KEY_SOURCE from (select 1 as KEY_SOURCE) t; +select KEYS from (select 1 as KEYS) t; +select KEYSET from (select 1 as KEYSET) t; +select LAG from (select 1 as LAG) t; +select LAST from (select 1 as LAST) t; +select LAST_VALUE from (select 1 as LAST_VALUE) t; +select LEAD from (select 1 as LEAD) t; +select LEAST from (select 1 as LEAST) t; +select LEN from (select 1 as LEN) t; +select LEVEL from (select 1 as LEVEL) t; +select LIST from (select 1 as LIST) t; +select LISTENER from (select 1 as LISTENER) t; +select LISTENER_URL from (select 1 as LISTENER_URL) t; +select LOB_COMPACTION from (select 1 as LOB_COMPACTION) t; +select LOCAL from (select 1 as LOCAL) t; +select LOCATION from (select 1 as LOCATION) t; +select LOCK from (select 1 as LOCK) t; +select LOCK_ESCALATION from (select 1 as LOCK_ESCALATION) t; +select LOGIN from (select 1 as LOGIN) t; +select LOOP from (select 1 as LOOP) t; +select LOW from (select 1 as LOW) t; +select LOWER from (select 1 as LOWER) t; +select LTRIM from (select 1 as LTRIM) t; +select MANUAL from (select 1 as MANUAL) t; +select MARK from (select 1 as MARK) t; +select MASKED from (select 1 as MASKED) t; +select MATERIALIZED from (select 1 as MATERIALIZED) t; +select MAX from (select 1 as MAX) t; +select MAX_CPU_PERCENT from (select 1 as MAX_CPU_PERCENT) t; +select MAX_DOP from (select 1 as MAX_DOP) t; +select MAX_FILES from (select 1 as MAX_FILES) t; +select MAX_IOPS_PER_VOLUME from (select 1 as MAX_IOPS_PER_VOLUME) t; +select MAX_MEMORY_PERCENT from (select 1 as MAX_MEMORY_PERCENT) t; +select MAX_PROCESSES from (select 1 as MAX_PROCESSES) t; +select MAX_QUEUE_READERS from (select 1 as MAX_QUEUE_READERS) t; +select MAX_ROLLOVER_FILES from (select 1 as MAX_ROLLOVER_FILES) t; +select MAXDOP from (select 1 as MAXDOP) t; +select MAXRECURSION from (select 1 as MAXRECURSION) t; +select MAXSIZE from (select 1 as MAXSIZE) t; +select MB from (select 1 as MB) t; +select MEDIUM from (select 1 as MEDIUM) t; +select MEMORY_OPTIMIZED_DATA from (select 1 as MEMORY_OPTIMIZED_DATA) t; +select MESSAGE from (select 1 as MESSAGE) t; +select MIN from (select 1 as MIN) t; +select MIN_ACTIVE_ROWVERSION from (select 1 as MIN_ACTIVE_ROWVERSION) t; +select MIN_CPU_PERCENT from (select 1 as MIN_CPU_PERCENT) t; +select MIN_IOPS_PER_VOLUME from (select 1 as MIN_IOPS_PER_VOLUME) t; +select MIN_MEMORY_PERCENT from (select 1 as MIN_MEMORY_PERCENT) t; +select MINUTES from (select 1 as MINUTES) t; +select MIRROR_ADDRESS from (select 1 as MIRROR_ADDRESS) t; +select MIXED_PAGE_ALLOCATION from (select 1 as MIXED_PAGE_ALLOCATION) t; +select MODE from (select 1 as MODE) t; +select MODIFY from (select 1 as MODIFY) t; +select [MODIFY] from (select 1 as [MODIFY]) t; +select MOVE from (select 1 as MOVE) t; +select MULTI_USER from (select 1 as MULTI_USER) t; +select NAME from (select 1 as NAME) t; +select NCHAR from (select 1 as NCHAR) t; +select NESTED_TRIGGERS from (select 1 as NESTED_TRIGGERS) t; +select NEW_ACCOUNT from (select 1 as NEW_ACCOUNT) t; +select NEW_BROKER from (select 1 as NEW_BROKER) t; +select NEW_PASSWORD from (select 1 as NEW_PASSWORD) t; +select NEWNAME from (select 1 as NEWNAME) t; +select NEXT from (select 1 as NEXT) t; +select NO from (select 1 as NO) t; +select NO_INFOMSGS from (select 1 as NO_INFOMSGS) t; +select NO_QUERYSTORE from (select 1 as NO_QUERYSTORE) t; +select NO_STATISTICS from (select 1 as NO_STATISTICS) t; +select NO_TRUNCATE from (select 1 as NO_TRUNCATE) t; +select NO_WAIT from (select 1 as NO_WAIT) t; +select NOCOUNT from (select 1 as NOCOUNT) t; +select NODES from (select 1 as NODES) t; +select NOEXPAND from (select 1 as NOEXPAND) t; +select NOINDEX from (select 1 as NOINDEX) t; +select NOLOCK from (select 1 as NOLOCK) t; +select NON_TRANSACTED_ACCESS from (select 1 as NON_TRANSACTED_ACCESS) t; +select NORECOMPUTE from (select 1 as NORECOMPUTE) t; +select NORECOVERY from (select 1 as NORECOVERY) t; +select NOTIFICATIONS from (select 1 as NOTIFICATIONS) t; +select NOWAIT from (select 1 as NOWAIT) t; +select NTILE from (select 1 as NTILE) t; +select "NULL" from (select 1 as "NULL") t; +select NUMANODE from (select 1 as NUMANODE) t; +select NUMBER from (select 1 as NUMBER) t; +select NUMERIC_ROUNDABORT from (select 1 as NUMERIC_ROUNDABORT) t; +select OBJECT from (select 1 as OBJECT) t; +select OBJECT_DEFINITION from (select 1 as OBJECT_DEFINITION) t; +select OBJECT_ID from (select 1 as OBJECT_ID) t; +select OBJECT_NAME from (select 1 as OBJECT_NAME) t; +select OBJECT_SCHEMA_NAME from (select 1 as OBJECT_SCHEMA_NAME) t; +select OBJECTPROPERTY from (select 1 as OBJECTPROPERTY) t; +select OBJECTPROPERTYEX from (select 1 as OBJECTPROPERTYEX) t; +select OFFLINE from (select 1 as OFFLINE) t; +select OFFSET from (select 1 as OFFSET) t; +select OLD_ACCOUNT from (select 1 as OLD_ACCOUNT) t; +select ONLINE from (select 1 as ONLINE) t; +select ONLY from (select 1 as ONLY) t; +select OPEN_EXISTING from (select 1 as OPEN_EXISTING) t; +select OPENJSON from (select 1 as OPENJSON) t; +select OPTIMISTIC from (select 1 as OPTIMISTIC) t; +select OPTIMIZE from (select 1 as OPTIMIZE) t; +select OPTIMIZE_FOR_SEQUENTIAL_KEY from (select 1 as OPTIMIZE_FOR_SEQUENTIAL_KEY) t; +select ORIGINAL_DB_NAME from (select 1 as ORIGINAL_DB_NAME) t; +select OUT from (select 1 as OUT) t; +select OUTPUT from (select 1 as OUTPUT) t; +select OVERRIDE from (select 1 as OVERRIDE) t; +select OWNER from (select 1 as OWNER) t; +select OWNERSHIP from (select 1 as OWNERSHIP) t; +select PAD_INDEX from (select 1 as PAD_INDEX) t; +select PAGE_VERIFY from (select 1 as PAGE_VERIFY) t; +select PAGECOUNT from (select 1 as PAGECOUNT) t; +select PAGLOCK from (select 1 as PAGLOCK) t; +select PARAMETERIZATION from (select 1 as PARAMETERIZATION) t; +select PARSENAME from (select 1 as PARSENAME) t; +select PARTITION from (select 1 as PARTITION) t; +select PARTITIONS from (select 1 as PARTITIONS) t; +select PARTNER from (select 1 as PARTNER) t; +select PATH from (select 1 as PATH) t; +select PATINDEX from (select 1 as PATINDEX) t; +select PAUSE from (select 1 as PAUSE) t; +select PDW_SHOWSPACEUSED from (select 1 as PDW_SHOWSPACEUSED) t; +select PERCENT_RANK from (select 1 as PERCENT_RANK) t; +select PERCENTILE_CONT from (select 1 as PERCENTILE_CONT) t; +select PERCENTILE_DISC from (select 1 as PERCENTILE_DISC) t; +select PERSIST_SAMPLE_PERCENT from (select 1 as PERSIST_SAMPLE_PERCENT) t; +select PHYSICAL_ONLY from (select 1 as PHYSICAL_ONLY) t; +select POISON_MESSAGE_HANDLING from (select 1 as POISON_MESSAGE_HANDLING) t; +select POOL from (select 1 as POOL) t; +select PORT from (select 1 as PORT) t; +select PRECEDING from (select 1 as PRECEDING) t; +select PRIMARY_ROLE from (select 1 as PRIMARY_ROLE) t; +select PRIOR from (select 1 as PRIOR) t; +select PRIORITY from (select 1 as PRIORITY) t; +select PRIORITY_LEVEL from (select 1 as PRIORITY_LEVEL) t; +select PRIVATE from (select 1 as PRIVATE) t; +select PRIVATE_KEY from (select 1 as PRIVATE_KEY) t; +select PRIVILEGES from (select 1 as PRIVILEGES) t; +select PROCCACHE from (select 1 as PROCCACHE) t; +select PROCEDURE_NAME from (select 1 as PROCEDURE_NAME) t; +select PROPERTY from (select 1 as PROPERTY) t; +select PROVIDER from (select 1 as PROVIDER) t; +select PROVIDER_KEY_NAME from (select 1 as PROVIDER_KEY_NAME) t; +select QUERY from (select 1 as QUERY) t; +select [QUERY] from (select 1 as [QUERY]) t; +select QUEUE from (select 1 as QUEUE) t; +select QUEUE_DELAY from (select 1 as QUEUE_DELAY) t; +select QUOTED_IDENTIFIER from (select 1 as QUOTED_IDENTIFIER) t; +select QUOTENAME from (select 1 as QUOTENAME) t; +select RANDOMIZED from (select 1 as RANDOMIZED) t; +select RANGE from (select 1 as RANGE) t; +select RANK from (select 1 as RANK) t; +select RC2 from (select 1 as RC2) t; +select RC4 from (select 1 as RC4) t; +select RC4_128 from (select 1 as RC4_128) t; +select READ_COMMITTED_SNAPSHOT from (select 1 as READ_COMMITTED_SNAPSHOT) t; +select READ_ONLY from (select 1 as READ_ONLY) t; +select READ_ONLY_ROUTING_LIST from (select 1 as READ_ONLY_ROUTING_LIST) t; +select READ_WRITE from (select 1 as READ_WRITE) t; +select READCOMMITTED from (select 1 as READCOMMITTED) t; +select READCOMMITTEDLOCK from (select 1 as READCOMMITTEDLOCK) t; +select READONLY from (select 1 as READONLY) t; +select READPAST from (select 1 as READPAST) t; +select READUNCOMMITTED from (select 1 as READUNCOMMITTED) t; +select READWRITE from (select 1 as READWRITE) t; +select REBUILD from (select 1 as REBUILD) t; +select RECEIVE from (select 1 as RECEIVE) t; +select RECOMPILE from (select 1 as RECOMPILE) t; +select RECOVERY from (select 1 as RECOVERY) t; +select RECURSIVE_TRIGGERS from (select 1 as RECURSIVE_TRIGGERS) t; +select RELATIVE from (select 1 as RELATIVE) t; +select REMOTE from (select 1 as REMOTE) t; +select REMOTE_SERVICE_NAME from (select 1 as REMOTE_SERVICE_NAME) t; +select REMOVE from (select 1 as REMOVE) t; +select REORGANIZE from (select 1 as REORGANIZE) t; +select REPAIR_ALLOW_DATA_LOSS from (select 1 as REPAIR_ALLOW_DATA_LOSS) t; +select REPAIR_FAST from (select 1 as REPAIR_FAST) t; +select REPAIR_REBUILD from (select 1 as REPAIR_REBUILD) t; +select REPEATABLE from (select 1 as REPEATABLE) t; +select REPEATABLEREAD from (select 1 as REPEATABLEREAD) t; +select REPLACE from (select 1 as REPLACE) t; +select REPLICA from (select 1 as REPLICA) t; +select REPLICATE from (select 1 as REPLICATE) t; +select REQUEST_MAX_CPU_TIME_SEC from (select 1 as REQUEST_MAX_CPU_TIME_SEC) t; +select REQUEST_MAX_MEMORY_GRANT_PERCENT from (select 1 as REQUEST_MAX_MEMORY_GRANT_PERCENT) t; +select REQUEST_MEMORY_GRANT_TIMEOUT_SEC from (select 1 as REQUEST_MEMORY_GRANT_TIMEOUT_SEC) t; +select REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT from (select 1 as REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT) t; +select RESAMPLE from (select 1 as RESAMPLE) t; +select RESERVE_DISK_SPACE from (select 1 as RESERVE_DISK_SPACE) t; +select RESOURCE from (select 1 as RESOURCE) t; +select RESOURCE_MANAGER_LOCATION from (select 1 as RESOURCE_MANAGER_LOCATION) t; +select RESTRICTED_USER from (select 1 as RESTRICTED_USER) t; +select RESUMABLE from (select 1 as RESUMABLE) t; +select RETENTION from (select 1 as RETENTION) t; +select REVERSE from (select 1 as REVERSE) t; +select ROBUST from (select 1 as ROBUST) t; +select ROOT from (select 1 as ROOT) t; +select ROUTE from (select 1 as ROUTE) t; +select ROW from (select 1 as ROW) t; +select ROW_NUMBER from (select 1 as ROW_NUMBER) t; +select ROWGUID from (select 1 as ROWGUID) t; +select ROWLOCK from (select 1 as ROWLOCK) t; +select ROWS from (select 1 as ROWS) t; +select RTRIM from (select 1 as RTRIM) t; +select SAMPLE from (select 1 as SAMPLE) t; +select SCHEMA_ID from (select 1 as SCHEMA_ID) t; +select SCHEMA_NAME from (select 1 as SCHEMA_NAME) t; +select SCHEMABINDING from (select 1 as SCHEMABINDING) t; +select SCOPE_IDENTITY from (select 1 as SCOPE_IDENTITY) t; +select SCOPED from (select 1 as SCOPED) t; +select SCROLL from (select 1 as SCROLL) t; +select SCROLL_LOCKS from (select 1 as SCROLL_LOCKS) t; +select SEARCH from (select 1 as SEARCH) t; +select SECONDARY from (select 1 as SECONDARY) t; +select SECONDARY_ONLY from (select 1 as SECONDARY_ONLY) t; +select SECONDARY_ROLE from (select 1 as SECONDARY_ROLE) t; +select SECONDS from (select 1 as SECONDS) t; +select SECRET from (select 1 as SECRET) t; +select SECURABLES from (select 1 as SECURABLES) t; +select SECURITY from (select 1 as SECURITY) t; +select SECURITY_LOG from (select 1 as SECURITY_LOG) t; +select SEEDING_MODE from (select 1 as SEEDING_MODE) t; +select SELF from (select 1 as SELF) t; +select SEMI_SENSITIVE from (select 1 as SEMI_SENSITIVE) t; +select SEND from (select 1 as SEND) t; +select SENT from (select 1 as SENT) t; +select SEQUENCE from (select 1 as SEQUENCE) t; +select SEQUENCE_NUMBER from (select 1 as SEQUENCE_NUMBER) t; +select SERIALIZABLE from (select 1 as SERIALIZABLE) t; +select SERVERPROPERTY from (select 1 as SERVERPROPERTY) t; +select SERVICEBROKER from (select 1 as SERVICEBROKER) t; +select SESSION_TIMEOUT from (select 1 as SESSION_TIMEOUT) t; +select SETERROR from (select 1 as SETERROR) t; +select SHARE from (select 1 as SHARE) t; +select SHARED from (select 1 as SHARED) t; +select SHOWCONTIG from (select 1 as SHOWCONTIG) t; +select SHOWPLAN from (select 1 as SHOWPLAN) t; +select SIGNATURE from (select 1 as SIGNATURE) t; +select SIMPLE from (select 1 as SIMPLE) t; +select SINGLE_USER from (select 1 as SINGLE_USER) t; +select SIZE from (select 1 as SIZE) t; +select SMALLINT from (select 1 as SMALLINT) t; +select SNAPSHOT from (select 1 as SNAPSHOT) t; +select SORT_IN_TEMPDB from (select 1 as SORT_IN_TEMPDB) t; +select SOUNDEX from (select 1 as SOUNDEX) t; +select SPACE from (select 1 as SPACE) t; +select SPARSE from (select 1 as SPARSE) t; +select SPATIAL_WINDOW_MAX_CELLS from (select 1 as SPATIAL_WINDOW_MAX_CELLS) t; +select SQL_VARIANT_PROPERTY from (select 1 as SQL_VARIANT_PROPERTY) t; +select STANDBY from (select 1 as STANDBY) t; +select START_DATE from (select 1 as START_DATE) t; +select STATIC from (select 1 as STATIC) t; +select STATISTICS_INCREMENTAL from (select 1 as STATISTICS_INCREMENTAL) t; +select STATISTICS_NORECOMPUTE from (select 1 as STATISTICS_NORECOMPUTE) t; +select STATS_DATE from (select 1 as STATS_DATE) t; +select STATS_STREAM from (select 1 as STATS_STREAM) t; +select STATUS from (select 1 as STATUS) t; +select STATUSONLY from (select 1 as STATUSONLY) t; +select STDEV from (select 1 as STDEV) t; +select STDEVP from (select 1 as STDEVP) t; +select STOPLIST from (select 1 as STOPLIST) t; +select STR from (select 1 as STR) t; +select STRING_AGG from (select 1 as STRING_AGG) t; +select STRING_ESCAPE from (select 1 as STRING_ESCAPE) t; +select STUFF from (select 1 as STUFF) t; +select SUBJECT from (select 1 as SUBJECT) t; +select SUBSCRIBE from (select 1 as SUBSCRIBE) t; +select SUBSCRIPTION from (select 1 as SUBSCRIPTION) t; +select SUBSTRING from (select 1 as SUBSTRING) t; +select SUM from (select 1 as SUM) t; +select SUSPEND from (select 1 as SUSPEND) t; +select SYMMETRIC from (select 1 as SYMMETRIC) t; +select SYNCHRONOUS_COMMIT from (select 1 as SYNCHRONOUS_COMMIT) t; +select SYNONYM from (select 1 as SYNONYM) t; +select SYSTEM from (select 1 as SYSTEM) t; +select TABLERESULTS from (select 1 as TABLERESULTS) t; +select TABLOCK from (select 1 as TABLOCK) t; +select TABLOCKX from (select 1 as TABLOCKX) t; +select TAKE from (select 1 as TAKE) t; +select TARGET_RECOVERY_TIME from (select 1 as TARGET_RECOVERY_TIME) t; +select TB from (select 1 as TB) t; +select TEXTIMAGE_ON from (select 1 as TEXTIMAGE_ON) t; +select THROW from (select 1 as THROW) t; +select TIES from (select 1 as TIES) t; +select TIME from (select 1 as TIME) t; +select TIMEOUT from (select 1 as TIMEOUT) t; +select TIMER from (select 1 as TIMER) t; +select TINYINT from (select 1 as TINYINT) t; +select TORN_PAGE_DETECTION from (select 1 as TORN_PAGE_DETECTION) t; +select TRACKING from (select 1 as TRACKING) t; +select TRANSACTION_ID from (select 1 as TRANSACTION_ID) t; +select TRANSFORM_NOISE_WORDS from (select 1 as TRANSFORM_NOISE_WORDS) t; +select TRANSLATE from (select 1 as TRANSLATE) t; +select TRIM from (select 1 as TRIM) t; +select TRIPLE_DES from (select 1 as TRIPLE_DES) t; +select TRIPLE_DES_3KEY from (select 1 as TRIPLE_DES_3KEY) t; +select TRUSTWORTHY from (select 1 as TRUSTWORTHY) t; +select TRY from (select 1 as TRY) t; +select TSQL from (select 1 as TSQL) t; +select TWO_DIGIT_YEAR_CUTOFF from (select 1 as TWO_DIGIT_YEAR_CUTOFF) t; +select TYPE from (select 1 as TYPE) t; +select TYPE_ID from (select 1 as TYPE_ID) t; +select TYPE_NAME from (select 1 as TYPE_NAME) t; +select TYPE_WARNING from (select 1 as TYPE_WARNING) t; +select TYPEPROPERTY from (select 1 as TYPEPROPERTY) t; +select UNBOUNDED from (select 1 as UNBOUNDED) t; +select UNCOMMITTED from (select 1 as UNCOMMITTED) t; +select UNICODE from (select 1 as UNICODE) t; +select UNKNOWN from (select 1 as UNKNOWN) t; +select UNLIMITED from (select 1 as UNLIMITED) t; +select UNMASK from (select 1 as UNMASK) t; +select UOW from (select 1 as UOW) t; +select UPDLOCK from (select 1 as UPDLOCK) t; +select UPPER from (select 1 as UPPER) t; +select USING from (select 1 as USING) t; +select VALID_XML from (select 1 as VALID_XML) t; +select VALIDATION from (select 1 as VALIDATION) t; +select VALUE from (select 1 as VALUE) t; +select [VALUE] from (select 1 as [VALUE]) t; +select VAR from (select 1 as VAR) t; +select VARBINARY from (select 1 as VARBINARY) t; +select VARP from (select 1 as VARP) t; +select VERIFY_CLONEDB from (select 1 as VERIFY_CLONEDB) t; +select VERSION from (select 1 as VERSION) t; +select VIEW_METADATA from (select 1 as VIEW_METADATA) t; +select VIEWS from (select 1 as VIEWS) t; +select WAIT from (select 1 as WAIT) t; +select WELL_FORMED_XML from (select 1 as WELL_FORMED_XML) t; +select WITHOUT_ARRAY_WRAPPER from (select 1 as WITHOUT_ARRAY_WRAPPER) t; +select WORK from (select 1 as WORK) t; +select WORKLOAD from (select 1 as WORKLOAD) t; +select XLOCK from (select 1 as XLOCK) t; +select XML from (select 1 as XML) t; +select XML_COMPRESSION from (select 1 as XML_COMPRESSION) t; +select XMLDATA from (select 1 as XMLDATA) t; +select XMLNAMESPACES from (select 1 as XMLNAMESPACES) t; +select XMLSCHEMA from (select 1 as XMLSCHEMA) t; +select XSINIL from (select 1 as XSINIL) t; +select ZONE from (select 1 as ZONE) t; +select ABORT_AFTER_WAIT from (select 1 as ABORT_AFTER_WAIT) t; +select ABSENT from (select 1 as ABSENT) t; +select ADMINISTER from (select 1 as ADMINISTER) t; +select AES from (select 1 as AES) t; +select ALLOW_CONNECTIONS from (select 1 as ALLOW_CONNECTIONS) t; +select ALLOW_MULTIPLE_EVENT_LOSS from (select 1 as ALLOW_MULTIPLE_EVENT_LOSS) t; +select ALLOW_SINGLE_EVENT_LOSS from (select 1 as ALLOW_SINGLE_EVENT_LOSS) t; +select ANONYMOUS from (select 1 as ANONYMOUS) t; +select APPEND from (select 1 as APPEND) t; +select APPLICATION from (select 1 as APPLICATION) t; +select ASYMMETRIC from (select 1 as ASYMMETRIC) t; +select ASYNCHRONOUS_COMMIT from (select 1 as ASYNCHRONOUS_COMMIT) t; +select AUTHENTICATE from (select 1 as AUTHENTICATE) t; +select AUTHENTICATION from (select 1 as AUTHENTICATION) t; +select AUTOMATED_BACKUP_PREFERENCE from (select 1 as AUTOMATED_BACKUP_PREFERENCE) t; +select AUTOMATIC from (select 1 as AUTOMATIC) t; +select AVAILABILITY_MODE from (select 1 as AVAILABILITY_MODE) t; +select BEFORE from (select 1 as BEFORE) t; +select BLOCK from (select 1 as BLOCK) t; +select BLOCKERS from (select 1 as BLOCKERS) t; +select BLOCKSIZE from (select 1 as BLOCKSIZE) t; +select BLOCKING_HIERARCHY from (select 1 as BLOCKING_HIERARCHY) t; +select BUFFER from (select 1 as BUFFER) t; +select BUFFERCOUNT from (select 1 as BUFFERCOUNT) t; +select CACHE from (select 1 as CACHE) t; +select CALLED from (select 1 as CALLED) t; +select CERT_ID from (select 1 as CERT_ID) t; +select CERTENCODED from (select 1 as CERTENCODED) t; +select CERTIFICATE from (select 1 as CERTIFICATE) t; +select CERTPRIVATEKEY from (select 1 as CERTPRIVATEKEY) t; +select CHANGETABLE from (select 1 as CHANGETABLE) t; +select CHANGES from (select 1 as CHANGES) t; +select CHECK_POLICY from (select 1 as CHECK_POLICY) t; +select CHECK_EXPIRATION from (select 1 as CHECK_EXPIRATION) t; +select CLASSIFIER_FUNCTION from (select 1 as CLASSIFIER_FUNCTION) t; +select CLUSTER from (select 1 as CLUSTER) t; +select COMPRESS from (select 1 as COMPRESS) t; +select COMPRESSION from (select 1 as COMPRESSION) t; +select CONNECT from (select 1 as CONNECT) t; +select CONNECTION from (select 1 as CONNECTION) t; +select CONFIGURATION from (select 1 as CONFIGURATION) t; +select CONNECTIONPROPERTY from (select 1 as CONNECTIONPROPERTY) t; +select CONTAINMENT from (select 1 as CONTAINMENT) t; +select CONTEXT from (select 1 as CONTEXT) t; +select CONTEXT_INFO from (select 1 as CONTEXT_INFO) t; +select CONTINUE_AFTER_ERROR from (select 1 as CONTINUE_AFTER_ERROR) t; +select CONTRACT from (select 1 as CONTRACT) t; +select CONTRACT_NAME from (select 1 as CONTRACT_NAME) t; +select CONVERSATION from (select 1 as CONVERSATION) t; +select COPY_ONLY from (select 1 as COPY_ONLY) t; +select CURRENT_REQUEST_ID from (select 1 as CURRENT_REQUEST_ID) t; +select CURRENT_TRANSACTION_ID from (select 1 as CURRENT_TRANSACTION_ID) t; +select CYCLE from (select 1 as CYCLE) t; +select DATA_COMPRESSION from (select 1 as DATA_COMPRESSION) t; +select DATA_SOURCE from (select 1 as DATA_SOURCE) t; +select DATABASE_MIRRORING from (select 1 as DATABASE_MIRRORING) t; +select DATABASE_PRINCIPAL_ID from (select 1 as DATABASE_PRINCIPAL_ID) t; +select DATASPACE from (select 1 as DATASPACE) t; +select DDL from (select 1 as DDL) t; +select DECOMPRESS from (select 1 as DECOMPRESS) t; +select DEFAULT_DATABASE from (select 1 as DEFAULT_DATABASE) t; +select DEFAULT_SCHEMA from (select 1 as DEFAULT_SCHEMA) t; +select DIAGNOSTICS from (select 1 as DIAGNOSTICS) t; +select DIFFERENTIAL from (select 1 as DIFFERENTIAL) t; +select DISTRIBUTION from (select 1 as DISTRIBUTION) t; +select DTC_SUPPORT from (select 1 as DTC_SUPPORT) t; +select ENABLED from (select 1 as ENABLED) t; +select ENDPOINT from (select 1 as ENDPOINT) t; +select ERROR from (select 1 as ERROR) t; +select ERROR_LINE from (select 1 as ERROR_LINE) t; +select ERROR_MESSAGE from (select 1 as ERROR_MESSAGE) t; +select ERROR_NUMBER from (select 1 as ERROR_NUMBER) t; +select ERROR_PROCEDURE from (select 1 as ERROR_PROCEDURE) t; +select ERROR_SEVERITY from (select 1 as ERROR_SEVERITY) t; +select ERROR_STATE from (select 1 as ERROR_STATE) t; +select EVENT from (select 1 as EVENT) t; +select EVENTDATA from (select 1 as EVENTDATA) t; +select EVENT_RETENTION_MODE from (select 1 as EVENT_RETENTION_MODE) t; +select EXECUTABLE_FILE from (select 1 as EXECUTABLE_FILE) t; +select EXPIREDATE from (select 1 as EXPIREDATE) t; +select EXTENSION from (select 1 as EXTENSION) t; +select EXTERNAL_ACCESS from (select 1 as EXTERNAL_ACCESS) t; +select FAILOVER from (select 1 as FAILOVER) t; +select FAILURECONDITIONLEVEL from (select 1 as FAILURECONDITIONLEVEL) t; +select FAN_IN from (select 1 as FAN_IN) t; +select FILE_SNAPSHOT from (select 1 as FILE_SNAPSHOT) t; +select FORCESEEK from (select 1 as FORCESEEK) t; +select FORCE_SERVICE_ALLOW_DATA_LOSS from (select 1 as FORCE_SERVICE_ALLOW_DATA_LOSS) t; +select FORMATMESSAGE from (select 1 as FORMATMESSAGE) t; +select GET from (select 1 as GET) t; +select GET_FILESTREAM_TRANSACTION_CONTEXT from (select 1 as GET_FILESTREAM_TRANSACTION_CONTEXT) t; +select GETANCESTOR from (select 1 as GETANCESTOR) t; +select GETANSINULL from (select 1 as GETANSINULL) t; +select GETDESCENDANT from (select 1 as GETDESCENDANT) t; +select GETLEVEL from (select 1 as GETLEVEL) t; +select GETREPARENTEDVALUE from (select 1 as GETREPARENTEDVALUE) t; +select GETROOT from (select 1 as GETROOT) t; +select GOVERNOR from (select 1 as GOVERNOR) t; +select HAS_DBACCESS from (select 1 as HAS_DBACCESS) t; +select HAS_PERMS_BY_NAME from (select 1 as HAS_PERMS_BY_NAME) t; +select HASHED from (select 1 as HASHED) t; +select HEALTHCHECKTIMEOUT from (select 1 as HEALTHCHECKTIMEOUT) t; +select HEAP from (select 1 as HEAP) t; +select HIERARCHYID from (select 1 as HIERARCHYID) t; +select HOST_ID from (select 1 as HOST_ID) t; +select HOST_NAME from (select 1 as HOST_NAME) t; +select IIF from (select 1 as IIF) t; +select IO from (select 1 as IO) t; +select INCLUDE from (select 1 as INCLUDE) t; +select INCREMENT from (select 1 as INCREMENT) t; +select INFINITE from (select 1 as INFINITE) t; +select INIT from (select 1 as INIT) t; +select INSTEAD from (select 1 as INSTEAD) t; +select IS_MEMBER from (select 1 as IS_MEMBER) t; +select IS_ROLEMEMBER from (select 1 as IS_ROLEMEMBER) t; +select IS_SRVROLEMEMBER from (select 1 as IS_SRVROLEMEMBER) t; +select ISDESCENDANTOF from (select 1 as ISDESCENDANTOF) t; +select ISNULL from (select 1 as ISNULL) t; +select ISNUMERIC from (select 1 as ISNUMERIC) t; +select KERBEROS from (select 1 as KERBEROS) t; +select KEY_PATH from (select 1 as KEY_PATH) t; +select KEY_STORE_PROVIDER_NAME from (select 1 as KEY_STORE_PROVIDER_NAME) t; +select LANGUAGE from (select 1 as LANGUAGE) t; +select LIBRARY from (select 1 as LIBRARY) t; +select LIFETIME from (select 1 as LIFETIME) t; +select LINKED from (select 1 as LINKED) t; +select LINUX from (select 1 as LINUX) t; +select LISTENER_IP from (select 1 as LISTENER_IP) t; +select LISTENER_PORT from (select 1 as LISTENER_PORT) t; +select LOCAL_SERVICE_NAME from (select 1 as LOCAL_SERVICE_NAME) t; +select LOG from (select 1 as LOG) t; +select LOGINPROPERTY from (select 1 as LOGINPROPERTY) t; +select MASK from (select 1 as MASK) t; +select MATCHED from (select 1 as MATCHED) t; +select MASTER from (select 1 as MASTER) t; +select MAX_MEMORY from (select 1 as MAX_MEMORY) t; +select MAXTRANSFER from (select 1 as MAXTRANSFER) t; +select MAXVALUE from (select 1 as MAXVALUE) t; +select MAX_DISPATCH_LATENCY from (select 1 as MAX_DISPATCH_LATENCY) t; +select MAX_DURATION from (select 1 as MAX_DURATION) t; +select MAX_EVENT_SIZE from (select 1 as MAX_EVENT_SIZE) t; +select MAX_SIZE from (select 1 as MAX_SIZE) t; +select MAX_OUTSTANDING_IO_PER_VOLUME from (select 1 as MAX_OUTSTANDING_IO_PER_VOLUME) t; +select MEDIADESCRIPTION from (select 1 as MEDIADESCRIPTION) t; +select MEDIANAME from (select 1 as MEDIANAME) t; +select MEMBER from (select 1 as MEMBER) t; +select MEMORY_PARTITION_MODE from (select 1 as MEMORY_PARTITION_MODE) t; +select MESSAGE_FORWARDING from (select 1 as MESSAGE_FORWARDING) t; +select MESSAGE_FORWARD_SIZE from (select 1 as MESSAGE_FORWARD_SIZE) t; +select MINVALUE from (select 1 as MINVALUE) t; +select MIRROR from (select 1 as MIRROR) t; +select MUST_CHANGE from (select 1 as MUST_CHANGE) t; +select NEWID from (select 1 as NEWID) t; +select NEWSEQUENTIALID from (select 1 as NEWSEQUENTIALID) t; +select NOFORMAT from (select 1 as NOFORMAT) t; +select NOINIT from (select 1 as NOINIT) t; +select NONE from (select 1 as NONE) t; +select NOREWIND from (select 1 as NOREWIND) t; +select NOSKIP from (select 1 as NOSKIP) t; +select NOUNLOAD from (select 1 as NOUNLOAD) t; +select NO_CHECKSUM from (select 1 as NO_CHECKSUM) t; +select NO_COMPRESSION from (select 1 as NO_COMPRESSION) t; +select NO_EVENT_LOSS from (select 1 as NO_EVENT_LOSS) t; +select NOTIFICATION from (select 1 as NOTIFICATION) t; +select NTLM from (select 1 as NTLM) t; +select OLD_PASSWORD from (select 1 as OLD_PASSWORD) t; +select ON_FAILURE from (select 1 as ON_FAILURE) t; +select OPERATIONS from (select 1 as OPERATIONS) t; +select ORIGINAL_LOGIN from (select 1 as ORIGINAL_LOGIN) t; +select PAGE from (select 1 as PAGE) t; +select PARAM_NODE from (select 1 as PARAM_NODE) t; +select PARTIAL from (select 1 as PARTIAL) t; +select PASSWORD from (select 1 as PASSWORD) t; +select PERMISSION_SET from (select 1 as PERMISSION_SET) t; +select PERMISSIONS from (select 1 as PERMISSIONS) t; +select PER_CPU from (select 1 as PER_CPU) t; +select PER_DB from (select 1 as PER_DB) t; +select PER_NODE from (select 1 as PER_NODE) t; +select PERSISTED from (select 1 as PERSISTED) t; +select PLATFORM from (select 1 as PLATFORM) t; +select POLICY from (select 1 as POLICY) t; +select PREDICATE from (select 1 as PREDICATE) t; +select PROCESS from (select 1 as PROCESS) t; +select PROFILE from (select 1 as PROFILE) t; +select PWDCOMPARE from (select 1 as PWDCOMPARE) t; +select PWDENCRYPT from (select 1 as PWDENCRYPT) t; +select PYTHON from (select 1 as PYTHON) t; +select R from (select 1 as R) t; +select READ_WRITE_FILEGROUPS from (select 1 as READ_WRITE_FILEGROUPS) t; +select REGENERATE from (select 1 as REGENERATE) t; +select RELATED_CONVERSATION from (select 1 as RELATED_CONVERSATION) t; +select RELATED_CONVERSATION_GROUP from (select 1 as RELATED_CONVERSATION_GROUP) t; +select REQUIRED from (select 1 as REQUIRED) t; +select RESET from (select 1 as RESET) t; +select RESOURCES from (select 1 as RESOURCES) t; +select RESTART from (select 1 as RESTART) t; +select RESUME from (select 1 as RESUME) t; +select RETAINDAYS from (select 1 as RETAINDAYS) t; +select RETURNS from (select 1 as RETURNS) t; +select REWIND from (select 1 as REWIND) t; +select ROLE from (select 1 as ROLE) t; +select ROUND_ROBIN from (select 1 as ROUND_ROBIN) t; +select ROWCOUNT_BIG from (select 1 as ROWCOUNT_BIG) t; +select RSA_512 from (select 1 as RSA_512) t; +select RSA_1024 from (select 1 as RSA_1024) t; +select RSA_2048 from (select 1 as RSA_2048) t; +select RSA_3072 from (select 1 as RSA_3072) t; +select RSA_4096 from (select 1 as RSA_4096) t; +select SAFETY from (select 1 as SAFETY) t; +select SAFE from (select 1 as SAFE) t; +select SCHEDULER from (select 1 as SCHEDULER) t; +select SCHEME from (select 1 as SCHEME) t; +select SCRIPT from (select 1 as SCRIPT) t; +select SERVER from (select 1 as SERVER) t; +select SERVICE from (select 1 as SERVICE) t; +select SERVICE_BROKER from (select 1 as SERVICE_BROKER) t; +select SERVICE_NAME from (select 1 as SERVICE_NAME) t; +select SESSION from (select 1 as SESSION) t; +select SESSION_CONTEXT from (select 1 as SESSION_CONTEXT) t; +select SESSIONPROPERTY from (select 1 as SESSIONPROPERTY) t; +select SETTINGS from (select 1 as SETTINGS) t; +select SHRINKLOG from (select 1 as SHRINKLOG) t; +select SID from (select 1 as SID) t; +select SKIP from (select 1 as SKIP) t; +select SOFTNUMA from (select 1 as SOFTNUMA) t; +select SOURCE from (select 1 as SOURCE) t; +select SPECIFICATION from (select 1 as SPECIFICATION) t; +select SPLIT from (select 1 as SPLIT) t; +select SQL from (select 1 as SQL) t; +select SQLDUMPERFLAGS from (select 1 as SQLDUMPERFLAGS) t; +select SQLDUMPERPATH from (select 1 as SQLDUMPERPATH) t; +select SQLDUMPERTIMEOUT from (select 1 as SQLDUMPERTIMEOUT) t; +select STATE from (select 1 as STATE) t; +select STATS from (select 1 as STATS) t; +select START from (select 1 as START) t; +select STARTED from (select 1 as STARTED) t; +select STARTUP_STATE from (select 1 as STARTUP_STATE) t; +select STOP from (select 1 as STOP) t; +select STOPPED from (select 1 as STOPPED) t; +select STOP_ON_ERROR from (select 1 as STOP_ON_ERROR) t; +select SUPPORTED from (select 1 as SUPPORTED) t; +select SUSER_ID from (select 1 as SUSER_ID) t; +select SUSER_NAME from (select 1 as SUSER_NAME) t; +select SUSER_SID from (select 1 as SUSER_SID) t; +select SUSER_SNAME from (select 1 as SUSER_SNAME) t; +select SWITCH from (select 1 as SWITCH) t; +select TAPE from (select 1 as TAPE) t; +select TARGET from (select 1 as TARGET) t; +select TCP from (select 1 as TCP) t; +select TOSTRING from (select 1 as TOSTRING) t; +select TRACE from (select 1 as TRACE) t; +select TRACK_CAUSALITY from (select 1 as TRACK_CAUSALITY) t; +select TRANSFER from (select 1 as TRANSFER) t; +select UNCHECKED from (select 1 as UNCHECKED) t; +select UNLOCK from (select 1 as UNLOCK) t; +select UNSAFE from (select 1 as UNSAFE) t; +select URL from (select 1 as URL) t; +select USED from (select 1 as USED) t; +select USER_ID from (select 1 as USER_ID) t; +select USER_NAME from (select 1 as USER_NAME) t; +select VERBOSELOGGING from (select 1 as VERBOSELOGGING) t; +select VISIBILITY from (select 1 as VISIBILITY) t; +select WAIT_AT_LOW_PRIORITY from (select 1 as WAIT_AT_LOW_PRIORITY) t; +select WINDOWS from (select 1 as WINDOWS) t; +select WITHOUT from (select 1 as WITHOUT) t; +select WITNESS from (select 1 as WITNESS) t; +select XACT_ABORT from (select 1 as XACT_ABORT) t; +select XACT_STATE from (select 1 as XACT_STATE) t; +select VARCHAR from (select 1 as VARCHAR) t; +select NVARCHAR from (select 1 as NVARCHAR) t; +select PRECISION from (select 1 as PRECISION) t; diff --git a/tsql/examples/keywords_reserved.sql b/tsql/examples/keywords_reserved.sql new file mode 100644 index 0000000..c0bd11a --- /dev/null +++ b/tsql/examples/keywords_reserved.sql @@ -0,0 +1 @@ +select [fillfactor] from (select 1 as [fillfactor]) t; \ No newline at end of file diff --git a/tsql/examples/kill_statements.sql b/tsql/examples/kill_statements.sql new file mode 100644 index 0000000..26d4d86 --- /dev/null +++ b/tsql/examples/kill_statements.sql @@ -0,0 +1,14 @@ +KILL 53; +GO +KILL 53 WITH STATUSONLY; +GO +KILL 'D5499C66-E398-45CA-BF7E-DC9C194B48CF'; +GO + +KILL QUERY NOTIFICATION SUBSCRIPTION ALL; +GO +KILL QUERY NOTIFICATION SUBSCRIPTION 53; +GO + +KILL STATS JOB 53; +GO \ No newline at end of file diff --git a/tsql/examples/locktable.sql b/tsql/examples/locktable.sql new file mode 100644 index 0000000..35d3928 --- /dev/null +++ b/tsql/examples/locktable.sql @@ -0,0 +1 @@ +lock table xyz in exclusive mode wait 30 diff --git a/tsql/examples/logins.sql b/tsql/examples/logins.sql new file mode 100644 index 0000000..74d4ce7 --- /dev/null +++ b/tsql/examples/logins.sql @@ -0,0 +1,49 @@ +ALTER LOGIN Mary5 ENABLE; +ALTER LOGIN Mary5 WITH PASSWORD = ''; +ALTER LOGIN Mary5 WITH NAME = John2; +ALTER LOGIN John2 WITH CREDENTIAL = Custodian04; +ALTER LOGIN Mary5 +ADD CREDENTIAL EKMProvider1; +GO +ALTER LOGIN [Mary5] WITH PASSWORD = '****' UNLOCK ; + +GO +ALTER LOGIN [Mary5] WITH CHECK_POLICY = OFF; +ALTER LOGIN [Mary5] WITH CHECK_POLICY = ON; +GO +ALTER LOGIN TestUser WITH +PASSWORD = 0x01000CF35567C60BFB41EBDE4CF700A985A13D773D6B45B90900 HASHED ; +GO +ALTER LOGIN Login1 +ADD CREDENTIAL CredentialForEKM; +ALTER LOGIN Login1 +WITH CREDENTIAL = AlterEgo; +GO + +CREATE LOGIN login_name WITH PASSWORD = ''; +GO +CREATE LOGIN login_name WITH PASSWORD = '' MUST_CHANGE; +GO +CREATE LOGIN login_name WITH PASSWORD = '', + CREDENTIAL = credentialName; +GO +USE MASTER; +CREATE CERTIFICATE CertificateName + WITH SUBJECT = ' certificate in master database', + EXPIRY_DATE = '12/05/2025'; +GO +CREATE LOGIN login_name FROM CERTIFICATE certificateName; +GO +CREATE LOGIN [domainName\login_name] FROM WINDOWS; +GO +CREATE LOGIN TestLogin +WITH PASSWORD = 'SuperSecret52&&', SID = 0x241C11948AEEB749B0D22646DB1A19F2; + + +CREATE LOGIN Mary7 WITH PASSWORD = 'A2c3456$#' ; + +CREATE LOGIN Mary8 WITH PASSWORD = 'A2c3456$#' MUST_CHANGE, +CHECK_EXPIRATION = ON, +CHECK_POLICY = ON; +CREATE LOGIN [Contoso\Mary] FROM WINDOWS; +GO diff --git a/tsql/examples/master_key.sql b/tsql/examples/master_key.sql new file mode 100644 index 0000000..3069bd6 --- /dev/null +++ b/tsql/examples/master_key.sql @@ -0,0 +1,8 @@ +USE AdventureWorks2012; +ALTER MASTER KEY REGENERATE WITH ENCRYPTION BY PASSWORD = 'dsjdkflJ435907NnmM#sX003'; +GO +USE master; +ALTER MASTER KEY FORCE REGENERATE WITH ENCRYPTION BY PASSWORD = 'dsjdkflJ435907NnmM#sX003'; +GO +CREATE MASTER KEY ENCRYPTION BY PASSWORD = '23987hxJ#KL95234nl0zBe'; +GO diff --git a/tsql/examples/message_type.sql b/tsql/examples/message_type.sql new file mode 100644 index 0000000..bd333af --- /dev/null +++ b/tsql/examples/message_type.sql @@ -0,0 +1,3 @@ +ALTER MESSAGE TYPE + [//Adventure-Works.com/Expenses/SubmitExpense] + VALIDATION = WELL_FORMED_XML ; diff --git a/tsql/examples/nestedcomment.sql b/tsql/examples/nestedcomment.sql new file mode 100644 index 0000000..0143c43 --- /dev/null +++ b/tsql/examples/nestedcomment.sql @@ -0,0 +1 @@ +/* Es folgt ein Kommentar: /* Kommentar */ Danke */ diff --git a/tsql/examples/non_ansi_join.sql b/tsql/examples/non_ansi_join.sql new file mode 100644 index 0000000..affad93 --- /dev/null +++ b/tsql/examples/non_ansi_join.sql @@ -0,0 +1,8 @@ +SELECT a.au_id, + t.titlr e +FROM titles AS t, + authors AS a, + titleauthor AS ta +WHERE a.au_id = ta.au_id +AND ta.title_id = t.title_id +AND t.title LIKE 'Example%' \ No newline at end of file diff --git a/tsql/examples/parameters.sql b/tsql/examples/parameters.sql new file mode 100644 index 0000000..943ef53 --- /dev/null +++ b/tsql/examples/parameters.sql @@ -0,0 +1 @@ +SELECT * FROM t WHERE ID = ? diff --git a/tsql/examples/parse.sql b/tsql/examples/parse.sql new file mode 100644 index 0000000..63fc400 --- /dev/null +++ b/tsql/examples/parse.sql @@ -0,0 +1,7 @@ +SELECT PARSE('Monday, 13 December 2010' AS datetime2 USING 'en-US') AS Result; + +SELECT PARSE('€345,98' AS money USING 'de-DE') AS Result; + +-- The English language is mapped to en-US specific culture +SET LANGUAGE 'English'; +SELECT PARSE('12/16/2010' AS datetime2) AS Result; diff --git a/tsql/examples/partition_function.sql b/tsql/examples/partition_function.sql new file mode 100644 index 0000000..afa1c89 --- /dev/null +++ b/tsql/examples/partition_function.sql @@ -0,0 +1,7 @@ +CREATE PARTITION FUNCTION myRangePF1(DATETIME) +AS RANGE RIGHT +FOR VALUES ('20200101'); +ALTER PARTITION FUNCTION myRangePF1 () +MERGE RANGE (100); +ALTER PARTITION FUNCTION myRangePF1 () +SPLIT RANGE (500); diff --git a/tsql/examples/partition_scheme.sql b/tsql/examples/partition_scheme.sql new file mode 100644 index 0000000..f22a35f --- /dev/null +++ b/tsql/examples/partition_scheme.sql @@ -0,0 +1,5 @@ +CREATE PARTITION SCHEME MyRangePS1 +AS PARTITION PfMyFunction +ALL TO ([PRIMARY]); +ALTER PARTITION SCHEME MyRangePS1 +NEXT USED test5fg; diff --git a/tsql/examples/pr754.sql b/tsql/examples/pr754.sql new file mode 100644 index 0000000..a8183ea --- /dev/null +++ b/tsql/examples/pr754.sql @@ -0,0 +1,21 @@ +CREATE PROCEDURE Example_Sproc + @SomeValue BIT, + @SomeOtherValue SMALLINT, + @Days INT +AS +BEGIN + SET NOCOUNT ON; + + INSERT INTO Example ( + SomeValue, + SomeOtherValue, + DAYS + ) + OUTPUT inserted.Id + VALUES ( + @SomeValue, + @SomeOtherValue, + @DAYS + ); + +END diff --git a/tsql/examples/predicates.sql b/tsql/examples/predicates.sql new file mode 100644 index 0000000..2d74b25 --- /dev/null +++ b/tsql/examples/predicates.sql @@ -0,0 +1,271 @@ +----------------------------------------------------------------------- +-- ALL https://msdn.microsoft.com/en-us/library/ms178543.aspx +-- scalar_expression { = | <> | != | > | >= | !> | < | <= | !< } ALL ( subquery ) + +USE AdventureWorks2012 ; +GO + +CREATE PROCEDURE DaysToBuild @OrderID int, @NumberOfDays int +AS +IF +@NumberOfDays >= ALL + ( + SELECT DaysToManufacture + FROM Sales.SalesOrderDetail + JOIN Production.Product + ON Sales.SalesOrderDetail.ProductID = Production.Product.ProductID + WHERE SalesOrderID = @OrderID + ) +PRINT 'All items for this order can be manufactured in specified number of days or less.' +ELSE +PRINT 'Some items for this order cannot be manufactured in specified number of days or less.' ; + +----------------------------------------------------------------------- +-- SOME | ANY https://msdn.microsoft.com/en-us/library/ms175064.aspx +-- scalar_expression { = | < > | ! = | > | > = | ! > | < | < = | ! < } { SOME | ANY } ( subquery ) + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Running a simple example + +IF 3 < SOME (SELECT ID FROM T1) +PRINT 'TRUE' +ELSE +PRINT 'FALSE' ; + +IF 3 < ALL (SELECT ID FROM T1) +PRINT 'TRUE' +ELSE +PRINT 'FALSE' ; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Running a practical example + +USE AdventureWorks2012 ; +GO + +CREATE PROCEDURE ManyDaysToComplete @OrderID int, @NumberOfDays int +AS +IF +@NumberOfDays < SOME + ( + SELECT DaysToManufacture + FROM Sales.SalesOrderDetail + JOIN Production.Product + ON Sales.SalesOrderDetail.ProductID = Production.Product.ProductID + WHERE SalesOrderID = @OrderID + ) +PRINT 'At least one item for this order cannot be manufactured in specified number of days.' +ELSE +PRINT 'All items for this order can be manufactured in the specified number of days or less.' ; + +----------------------------------------------------------------------- +-- BETWEEN https://msdn.microsoft.com/en-us/library/ms187922.aspx +-- test_expression [ NOT ] BETWEEN begin_expression AND end_expression + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using BETWEEN + +USE AdventureWorks2012; +GO +SELECT e.FirstName, e.LastName, ep.Rate +FROM HumanResources.vEmployee e +JOIN HumanResources.EmployeePayHistory ep + ON e.BusinessEntityID = ep.BusinessEntityID +WHERE ep.Rate BETWEEN 27 AND 30 +ORDER BY ep.Rate; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using NOT BETWEEN + +USE AdventureWorks2012; +GO +SELECT e.FirstName, e.LastName, ep.Rate +FROM HumanResources.vEmployee e +JOIN HumanResources.EmployeePayHistory ep + ON e.BusinessEntityID = ep.BusinessEntityID +WHERE ep.Rate NOT BETWEEN 27 AND 30 +ORDER BY ep.Rate; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using BETWEEN with datetime values + +USE AdventureWorks2012; +GO +SELECT BusinessEntityID, RateChangeDate +FROM HumanResources.EmployeePayHistory +WHERE RateChangeDate BETWEEN '20011212' AND '20020105'; + +----------------------------------------------------------------------- +-- IN https://msdn.microsoft.com/en-us/library/ms177682.aspx +-- test_expression [ NOT ] IN ( subquery | expression [ ,...n ]) + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using IN with a subquery + +USE AdventureWorks2012; +GO +SELECT p.FirstName, p.LastName +FROM Person.Person AS p + JOIN Sales.SalesPerson AS sp + ON p.BusinessEntityID = sp.BusinessEntityID +WHERE p.BusinessEntityID IN + (SELECT BusinessEntityID + FROM Sales.SalesPerson + WHERE SalesQuota > 250000); +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using IN with a subquery + +USE AdventureWorks2012; +GO +SELECT p.FirstName, p.LastName +FROM Person.Person AS p + JOIN Sales.SalesPerson AS sp + ON p.BusinessEntityID = sp.BusinessEntityID +WHERE p.BusinessEntityID NOT IN + (SELECT BusinessEntityID + FROM Sales.SalesPerson + WHERE SalesQuota > 250000); +GO + +----------------------------------------------------------------------- +-- LIKE https://msdn.microsoft.com/en-us/library/ms179859.aspx +-- match_expression [ NOT ] LIKE pattern [ ESCAPE escape_character ] + +USE AdventureWorks2012; +GO +CREATE PROCEDURE FindEmployee @EmpLName char(20) +AS +SELECT @EmpLName = RTRIM(@EmpLName) + '%'; +SELECT p.FirstName, p.LastName, a.City +FROM Person.Person p JOIN Person.Address a ON p.BusinessEntityID = a.AddressID +WHERE p.LastName LIKE @EmpLName; +GO +EXEC FindEmployee @EmpLName = 'Barb'; +GO + +USE AdventureWorks2012; +GO +CREATE PROCEDURE FindEmployee @EmpLName varchar(20) +AS +SELECT @EmpLName = RTRIM(@EmpLName) + '%'; +SELECT p.FirstName, p.LastName, a.City +FROM Person.Person p JOIN Person.Address a ON p.BusinessEntityID = a.AddressID +WHERE p.LastName LIKE @EmpLName; +GO +EXEC FindEmployee @EmpLName = 'Barb'; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Pattern Matching by Using LIKE + +-- ASCII pattern matching with char column +CREATE TABLE t (col1 char(30)); +INSERT INTO t VALUES ('Robert King'); +SELECT * +FROM t +WHERE col1 LIKE '% King'; -- returns 1 row + +-- Unicode pattern matching with nchar column +CREATE TABLE t (col1 nchar(30)); +INSERT INTO t VALUES ('Robert King'); +SELECT * +FROM t +WHERE col1 LIKE '% King'; -- no rows returned + +-- Unicode pattern matching with nchar column and RTRIM +CREATE TABLE t (col1 nchar (30)); +INSERT INTO t VALUES ('Robert King'); +SELECT * +FROM t +WHERE RTRIM(col1) LIKE '% King'; -- returns 1 row + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the % Wildcard Character + +USE AdventureWorks2012; +GO +SELECT Name +FROM sys.system_views +WHERE Name LIKE 'dm%'; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using LIKE with the % wildcard character + +USE AdventureWorks2012; +GO +SELECT p.FirstName, p.LastName, ph.PhoneNumber +FROM Person.PersonPhone AS ph +INNER JOIN Person.Person AS p +ON ph.BusinessEntityID = p.BusinessEntityID +WHERE ph.PhoneNumber LIKE '415%' +ORDER by p.LastName; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using NOT LIKE with the % wildcard character + +USE AdventureWorks2012; +GO +SELECT p.FirstName, p.LastName, ph.PhoneNumber +FROM Person.PersonPhone AS ph +INNER JOIN Person.Person AS p +ON ph.BusinessEntityID = p.BusinessEntityID +WHERE ph.PhoneNumber NOT LIKE '415%' AND p.FirstName = 'Gail' +ORDER BY p.LastName; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the ESCAPE clause + +USE tempdb; +GO +IF EXISTS(SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES + WHERE TABLE_NAME = 'mytbl2') + DROP TABLE mytbl2; +GO +USE tempdb; +GO +CREATE TABLE mytbl2 +( + c1 sysname +); +GO +INSERT mytbl2 VALUES ('Discount is 10-15% off'), ('Discount is .10-.15 off'); +GO +SELECT c1 +FROM mytbl2 +WHERE c1 LIKE '%10-15!% off%' ESCAPE '!'; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Using the [ ] wildcard characters + +USE AdventureWorks2012; +GO +SELECT BusinessEntityID, FirstName, LastName +FROM Person.Person +WHERE FirstName LIKE '[CS]heryl'; +GO + +USE AdventureWorks2012; +GO +SELECT LastName, FirstName +FROM Person.Person +WHERE LastName LIKE 'Zh[ae]ng' +ORDER BY LastName ASC, FirstName ASC; +GO + +----------------------------------------------------------------------- +-- OR https://msdn.microsoft.com/en-us/library/ms188361.aspx +-- boolean_expression OR boolean_expression + +USE AdventureWorks2012; +GO +SELECT FirstName, LastName, Shift +FROM HumanResources.vEmployeeDepartmentHistory +WHERE Department = 'Quality Assurance' + AND (Shift = 'Evening' OR Shift = 'Night'); diff --git a/tsql/examples/print_with_param.sql b/tsql/examples/print_with_param.sql new file mode 100644 index 0000000..a5a1817 --- /dev/null +++ b/tsql/examples/print_with_param.sql @@ -0,0 +1,4 @@ +print "Error!" +print "Error: %1!", @anfEnd +print "Error: %1! %2!", @anfEnd, @asd + diff --git a/tsql/examples/raiseerror.sql b/tsql/examples/raiseerror.sql new file mode 100644 index 0000000..7e813c9 --- /dev/null +++ b/tsql/examples/raiseerror.sql @@ -0,0 +1,5 @@ + raiserror 721350 "Fehler %1!.", @err + raiserror 72958 'Quartal %1!.', @quartal + raiserror 641523 'Sülz.' + raiserror ( N'%s', 10, 1, NULL ); + diff --git a/tsql/examples/reconfigure_statement.sql b/tsql/examples/reconfigure_statement.sql new file mode 100644 index 0000000..83b4152 --- /dev/null +++ b/tsql/examples/reconfigure_statement.sql @@ -0,0 +1,5 @@ +RECONFIGURE WITH OVERRIDE; +GO + +RECONFIGURE; +GO diff --git a/tsql/examples/remote_service_binding.sql b/tsql/examples/remote_service_binding.sql new file mode 100644 index 0000000..503be67 --- /dev/null +++ b/tsql/examples/remote_service_binding.sql @@ -0,0 +1,9 @@ +ALTER REMOTE SERVICE BINDING APBinding + WITH USER = SecurityAccount +CREATE REMOTE SERVICE BINDING APBinding + TO SERVICE '//Adventure-Works.com/services/AccountsPayable' + WITH USER = APUser ; +CREATE REMOTE SERVICE BINDING APBinding + TO SERVICE '//Adventure-Works.com/services/AccountsPayable' + WITH USER = APUser, ANONYMOUS=ON ; + diff --git a/tsql/examples/replace.sql b/tsql/examples/replace.sql new file mode 100644 index 0000000..e98bde8 --- /dev/null +++ b/tsql/examples/replace.sql @@ -0,0 +1,18 @@ +SELECT REPLACE FROM (SELECT 1 AS REPLACE) T +GO + +SELECT REPLACE('abcdefghicde','cde','xxx'); +GO + +SELECT REPLACE('This is a Test' COLLATE Latin1_General_BIN, +'Test', 'desk' ); +GO + +DECLARE @STR NVARCHAR(100), @LEN1 INT, @LEN2 INT; +SET @STR = N'This is a sentence with spaces in it.'; +SET @LEN1 = LEN(@STR); +SET @STR = REPLACE(@STR, N' ', N''); +SET @LEN2 = LEN(@STR); +SELECT N'Number of spaces in the string: ' + CONVERT(NVARCHAR(20), @LEN1 - @LEN2); + +GO diff --git a/tsql/examples/resource_governor.sql b/tsql/examples/resource_governor.sql new file mode 100644 index 0000000..49933a8 --- /dev/null +++ b/tsql/examples/resource_governor.sql @@ -0,0 +1,20 @@ +ALTER RESOURCE GOVERNOR RECONFIGURE; +ALTER RESOURCE GOVERNOR WITH (CLASSIFIER_FUNCTION = NULL); +GO +ALTER RESOURCE GOVERNOR RECONFIGURE; +ALTER RESOURCE GOVERNOR WITH (CLASSIFIER_FUNCTION=dbo.rgclassifier_v1); +GO +ALTER RESOURCE GOVERNOR RECONFIGURE; +GO +ALTER RESOURCE GOVERNOR RESET STATISTICS; +ALTER RESOURCE GOVERNOR +WITH (MAX_OUTSTANDING_IO_PER_VOLUME = 20); +CREATE EXTERNAL RESOURCE POOL ep_1 +WITH ( + MAX_CPU_PERCENT = 75 + , AFFINITY CPU = AUTO + , MAX_MEMORY_PERCENT = 30 +); +GO +ALTER RESOURCE GOVERNOR RECONFIGURE; +GO diff --git a/tsql/examples/resource_pools.sql b/tsql/examples/resource_pools.sql new file mode 100644 index 0000000..570b0d5 --- /dev/null +++ b/tsql/examples/resource_pools.sql @@ -0,0 +1,26 @@ +ALTER EXTERNAL RESOURCE POOL ep_1 +WITH ( + MAX_CPU_PERCENT = 50 + , AFFINITY CPU = AUTO + , MAX_MEMORY_PERCENT = 25 +); +GO +CREATE RESOURCE POOL bigPool; +GO +ALTER RESOURCE GOVERNOR RECONFIGURE; +GO +CREATE RESOURCE POOL PoolAdmin +WITH ( + MIN_CPU_PERCENT = 10, + MAX_CPU_PERCENT = 20, + CAP_CPU_PERCENT = 30, + AFFINITY SCHEDULER = (0 TO 63, 128 TO 191), + MIN_MEMORY_PERCENT = 5, + MAX_MEMORY_PERCENT = 15 + ); + +CREATE RESOURCE POOL PoolAdmin +WITH ( + MIN_IOPS_PER_VOLUME = 20, + MAX_IOPS_PER_VOLUME = 100 + ); diff --git a/tsql/examples/revert.sql b/tsql/examples/revert.sql new file mode 100644 index 0000000..7458c73 --- /dev/null +++ b/tsql/examples/revert.sql @@ -0,0 +1,2 @@ +REVERT; +REVERT WITH COOKIE = @cookie; diff --git a/tsql/examples/route.sql b/tsql/examples/route.sql new file mode 100644 index 0000000..5ad2ba2 --- /dev/null +++ b/tsql/examples/route.sql @@ -0,0 +1,35 @@ +CREATE ROUTE ExpenseRoute + WITH + SERVICE_NAME = '//Adventure-Works.com/Expenses', + BROKER_INSTANCE = 'D8D4D268-00A3-4C62-8F91-634B89C1E315', + ADDRESS = 'TCP://www.Adventure-Works.com:1234' ; +CREATE ROUTE ExpenseRoute + WITH + SERVICE_NAME = '//Adventure-Works.com/Expenses', + BROKER_INSTANCE = 'D8D4D268-00A3-4C62-8F91-634B89C1E315', + ADDRESS = 'TCP://SERVER02:1234' ; +CREATE ROUTE ExpenseRoute + WITH + SERVICE_NAME = '//Adventure-Works.com/Expenses', + BROKER_INSTANCE = 'D8D4D268-00A3-4C62-8F91-634B89C1E315', + ADDRESS = 'TCP://192.168.10.2:1234' ; +CREATE ROUTE ExpenseRoute + WITH + ADDRESS = 'TCP://dispatch.Adventure-Works.com' ; +CREATE ROUTE LogRequests + WITH + SERVICE_NAME = '//Adventure-Works.com/LogRequests', + ADDRESS = 'LOCAL' ; +CREATE ROUTE ExpenseRoute + WITH + SERVICE_NAME = '//Adventure-Works.com/Expenses', + LIFETIME = 259200, + ADDRESS = 'TCP://services.Adventure-Works.com:1234' ; +CREATE ROUTE ExpenseRoute + WITH + SERVICE_NAME = '//Adventure-Works.com/Expenses', + BROKER_INSTANCE = '69fcc80c-2239-4700-8437-1001ecddf933', + ADDRESS = 'TCP://services.Adventure-Works.com:1234', + MIRROR_ADDRESS = 'TCP://services-mirror.Adventure-Works.com:1234' ; +CREATE ROUTE TransportRoute + WITH ADDRESS = 'TRANSPORT' ; diff --git a/tsql/examples/rule.sql b/tsql/examples/rule.sql new file mode 100644 index 0000000..b671cfb --- /dev/null +++ b/tsql/examples/rule.sql @@ -0,0 +1,9 @@ +CREATE RULE range_rule +AS +@range>= $1000 AND @range <$20000; +CREATE RULE list_rule +AS +@list IN ('1389', '0736', '0877'); +CREATE RULE pattern_rule +AS +@value LIKE '__-%[0-9]' diff --git a/tsql/examples/schema.sql b/tsql/examples/schema.sql new file mode 100644 index 0000000..6138e93 --- /dev/null +++ b/tsql/examples/schema.sql @@ -0,0 +1,25 @@ +USE AdventureWorks2012; +GO +ALTER SCHEMA HumanResources TRANSFER Person.Address; +GO +ALTER SCHEMA Person TRANSFER type::Production.TestType ; +GO +ALTER SCHEMA Sales TRANSFER OBJECT::dbo.Region; +GO +USE AdventureWorks2012; +GO +CREATE SCHEMA Sprockets AUTHORIZATION Annik + CREATE TABLE NineProngs (source int, cost int, partnumber int) + GRANT SELECT ON SCHEMA::Sprockets TO Mandar + DENY SELECT ON SCHEMA::Sprockets TO Prasanna; +GO +CREATE SCHEMA Sales; +GO; + +CREATE TABLE Sales.Region +(Region_id int NOT NULL, +Region_Name char(5) NOT NULL) +WITH (DISTRIBUTION = REPLICATE); +GO +CREATE SCHEMA Production AUTHORIZATION [Contoso\Mary]; +GO diff --git a/tsql/examples/search_property_list.sql b/tsql/examples/search_property_list.sql new file mode 100644 index 0000000..063d917 --- /dev/null +++ b/tsql/examples/search_property_list.sql @@ -0,0 +1,5 @@ +CREATE SEARCH PROPERTY LIST DocumentPropertyList; +CREATE SEARCH PROPERTY LIST JobCandidateProperties +FROM AdventureWorks2012.DocumentPropertyList; + + diff --git a/tsql/examples/security_policy.sql b/tsql/examples/security_policy.sql new file mode 100644 index 0000000..c404a64 --- /dev/null +++ b/tsql/examples/security_policy.sql @@ -0,0 +1,15 @@ +CREATE SECURITY POLICY [FederatedSecurityPolicy] +ADD FILTER PREDICATE [rls].[fn_securitypredicate]([CustomerId]) +ON [dbo].[Customer]; +CREATE SECURITY POLICY [FederatedSecurityPolicy] +ADD FILTER PREDICATE [rls].[fn_securitypredicate1]([CustomerId]) + ON [dbo].[Customer], +ADD FILTER PREDICATE [rls].[fn_securitypredicate1]([VendorId]) + ON [dbo].[ Vendor], +ADD FILTER PREDICATE [rls].[fn_securitypredicate2]([WingId]) + ON [dbo].[Patient] +WITH (STATE = ON); +CREATE SECURITY POLICY rls.SecPol + ADD FILTER PREDICATE rls.tenantAccessPredicate(TenantId) ON dbo.Sales, + ADD BLOCK PREDICATE rls.tenantAccessPredicate(TenantId) ON dbo.Sales AFTER INSERT; + diff --git a/tsql/examples/security_statement.sql b/tsql/examples/security_statement.sql new file mode 100644 index 0000000..444bda6 --- /dev/null +++ b/tsql/examples/security_statement.sql @@ -0,0 +1,5 @@ +GRANT CONTROL ON APPLICATION ROLE::TestAppRole TO dbo; +GO + +GRANT ADMINISTER BULK OPERATIONS TO [testRole] +GO \ No newline at end of file diff --git a/tsql/examples/select_partition_function.sql b/tsql/examples/select_partition_function.sql new file mode 100644 index 0000000..d5ffb6a --- /dev/null +++ b/tsql/examples/select_partition_function.sql @@ -0,0 +1,4 @@ +SELECT $PARTITION.TRANSACTION_RANGE_PF1(TRANSACTIONDATE) AS PARTITION, + COUNT(*) AS [COUNT] +FROM PRODUCTION.TRANSACTION_HISTORY +GROUP BY $PARTITION.TRANSACTION_RANGE_PF1(TRANSACTIONDATE); \ No newline at end of file diff --git a/tsql/examples/sequences.sql b/tsql/examples/sequences.sql new file mode 100644 index 0000000..6cc9c3d --- /dev/null +++ b/tsql/examples/sequences.sql @@ -0,0 +1,53 @@ +ALTER SEQUENCE Test. TestSeq + RESTART WITH 100 + INCREMENT BY 50 + MINVALUE 50 + MAXVALUE 200 + NO CYCLE + NO CACHE +; +GO +ALTER SEQUENCE Test.CountBy1 RESTART WITH 1 ; +ALTER SEQUENCE Test.CountBy1 + CYCLE + CACHE 20 ; +CREATE SEQUENCE Test.CountBy1 + START WITH 1 + INCREMENT BY 1 ; +GO +CREATE SEQUENCE Test.CountByNeg1 + START WITH 0 + INCREMENT BY -1 ; +GO +CREATE SEQUENCE Test.CountBy1 + START WITH 5 + INCREMENT BY 5 ; +GO +CREATE SEQUENCE Test.ID_Seq + START WITH 24329 + INCREMENT BY 1 ; +GO +CREATE SEQUENCE Test.TestSequence ; +CREATE SEQUENCE SmallSeq + AS smallint ; +CREATE SEQUENCE Test.DecSeq + AS decimal(3,0) + START WITH 125 + INCREMENT BY 25 + MINVALUE 100 + MAXVALUE 200 + CYCLE + CACHE 3 +; +GO + +CREATE SEQUENCE Test.DecSeqNegativeValues + AS [int] + START WITH 1 + INCREMENT BY 1 + MINVALUE -2147483648 + MAXVALUE -100 + CACHE +; +GO + diff --git a/tsql/examples/server_audit.sql b/tsql/examples/server_audit.sql new file mode 100644 index 0000000..702c9ab --- /dev/null +++ b/tsql/examples/server_audit.sql @@ -0,0 +1,57 @@ +USE master +GO +ALTER SERVER AUDIT HIPAA_Audit +WITH (STATE = OFF); +GO +ALTER SERVER AUDIT HIPAA_Audit +MODIFY NAME = HIPAA_Audit_Old; +GO +ALTER SERVER AUDIT HIPAA_Audit_Old +WITH (STATE = ON); +GO +USE master +GO +ALTER SERVER AUDIT HIPAA_Audit +WITH (STATE = OFF); +GO +ALTER SERVER AUDIT HIPAA_Audit +TO FILE (FILEPATH ='\\SQLPROD_1\Audit\', + MAXSIZE = 1000 MB, + RESERVE_DISK_SPACE=OFF) +WITH (QUEUE_DELAY = 1000, + ON_FAILURE = CONTINUE); +GO +ALTER SERVER AUDIT HIPAA_Audit +WITH (STATE = ON); +GO +ALTER SERVER AUDIT [FilterForSensitiveData] WITH (STATE = OFF) +GO +ALTER SERVER AUDIT [FilterForSensitiveData] +WHERE user_defined_event_id = 27; +GO +ALTER SERVER AUDIT [FilterForSensitiveData] WITH (STATE = ON); +GO +ALTER SERVER AUDIT [FilterForSensitiveData] WITH (STATE = OFF) +GO +ALTER SERVER AUDIT [FilterForSensitiveData] +REMOVE WHERE; +GO +ALTER SERVER AUDIT [FilterForSensitiveData] WITH (STATE = ON); +GO +ALTER SERVER AUDIT [FilterForSensitiveData] WITH (STATE = OFF) +GO +ALTER SERVER AUDIT [FilterForSensitiveData] +MODIFY NAME = AuditDataAccess; +GO +ALTER SERVER AUDIT [AuditDataAccess] WITH (STATE = ON); +GO +CREATE SERVER AUDIT HIPAA_Audit + TO FILE ( FILEPATH ='\\SQLPROD_1\Audit\' ); +CREATE SERVER AUDIT HIPAA_Audit + TO APPLICATION_LOG + WITH ( QUEUE_DELAY = 1000, ON_FAILURE = SHUTDOWN); +CREATE SERVER AUDIT AuditDataAccess + TO FILE ( FILEPATH ='C:\SQLAudit\' ) + WHERE object_name = 'SensitiveData' ; +GO + diff --git a/tsql/examples/server_audit_specification.sql b/tsql/examples/server_audit_specification.sql new file mode 100644 index 0000000..d04a08b --- /dev/null +++ b/tsql/examples/server_audit_specification.sql @@ -0,0 +1,9 @@ +ALTER SERVER AUDIT SPECIFICATION HIPPA_Audit_Specification +FOR SERVER AUDIT HIPPA_Audit + DROP (FAILED_LOGIN_GROUP) + ADD (DATABASE_OBJECT_ACCESS_GROUP); +GO +CREATE SERVER AUDIT SPECIFICATION HIPPA_Audit_Specification +FOR SERVER AUDIT HIPPA_Audit + ADD (FAILED_LOGIN_GROUP); +GO diff --git a/tsql/examples/server_configuration.sql b/tsql/examples/server_configuration.sql new file mode 100644 index 0000000..bd4951f --- /dev/null +++ b/tsql/examples/server_configuration.sql @@ -0,0 +1,29 @@ +ALTER SERVER CONFIGURATION +SET PROCESS AFFINITY CPU=0 TO 63, 128 TO 191; +ALTER SERVER CONFIGURATION +SET PROCESS AFFINITY NUMANODE=0, 7; +ALTER SERVER CONFIGURATION +SET PROCESS AFFINITY NUMANODE=0, 7; +ALTER SERVER CONFIGURATION SET PROCESS AFFINITY CPU=0; +ALTER SERVER CONFIGURATION +SET PROCESS AFFINITY CPU=AUTO; +ALTER SERVER CONFIGURATION SET DIAGNOSTICS LOG ON; +ALTER SERVER CONFIGURATION SET DIAGNOSTICS LOG OFF; +ALTER SERVER CONFIGURATION +SET DIAGNOSTICS LOG PATH = 'C:\logs'; +ALTER SERVER CONFIGURATION +SET DIAGNOSTICS LOG MAX_SIZE = 10 MB; +ALTER SERVER CONFIGURATION +SET FAILOVER CLUSTER PROPERTY HealthCheckTimeout = 15000; +ALTER SERVER CONFIGURATION SET HADR CLUSTER CONTEXT = 'clus01.xyz.com'; +ALTER SERVER CONFIGURATION +SET BUFFER POOL EXTENSION ON + (FILENAME = 'F:\SSDCACHE\Example.BPE', SIZE = 50 GB); +ALTER SERVER CONFIGURATION +SET BUFFER POOL EXTENSION OFF; +GO +ALTER SERVER CONFIGURATION +SET BUFFER POOL EXTENSION ON + (FILENAME = 'F:\SSDCACHE\Example.BPE', SIZE = 60 GB); +GO + diff --git a/tsql/examples/server_roles.sql b/tsql/examples/server_roles.sql new file mode 100644 index 0000000..eb0e996 --- /dev/null +++ b/tsql/examples/server_roles.sql @@ -0,0 +1,14 @@ +ALTER SERVER ROLE Product WITH NAME = Production ; +ALTER SERVER ROLE Production ADD MEMBER [adventure-works\roberto0] ; +ALTER SERVER ROLE diskadmin ADD MEMBER Ted ; +ALTER SERVER ROLE Production DROP MEMBER [adventure-works\roberto0] ; +ALTER SERVER ROLE Production DROP MEMBER Ted ; +ALTER SERVER ROLE LargeRC ADD MEMBER Anna; +ALTER SERVER ROLE LargeRC DROP MEMBER Anna; +USE master; +CREATE SERVER ROLE buyers AUTHORIZATION BenMiller; +GO +USE master; +CREATE SERVER ROLE auditors AUTHORIZATION securityadmin; +GO + diff --git a/tsql/examples/service.sql b/tsql/examples/service.sql new file mode 100644 index 0000000..3e647c2 --- /dev/null +++ b/tsql/examples/service.sql @@ -0,0 +1,7 @@ +CREATE SERVICE [//Adventure-Works.com/Expenses] + ON QUEUE [dbo].[ExpenseQueue] + ([//Adventure-Works.com/Expenses/ExpenseSubmission]) +CREATE SERVICE [//Adventure-Works.com/Expenses] ON QUEUE ExpenseQueue + ([//Adventure-Works.com/Expenses/ExpenseSubmission], + [//Adventure-Works.com/Expenses/ExpenseProcessing]) ; +CREATE SERVICE [//Adventure-Works.com/Expenses] ON QUEUE ExpenseQueue ; diff --git a/tsql/examples/service_master_keys.sql b/tsql/examples/service_master_keys.sql new file mode 100644 index 0000000..fdd26b8 --- /dev/null +++ b/tsql/examples/service_master_keys.sql @@ -0,0 +1 @@ +ALTER SERVICE MASTER KEY REGENERATE; diff --git a/tsql/examples/shutdown_statements.sql b/tsql/examples/shutdown_statements.sql new file mode 100644 index 0000000..880923e --- /dev/null +++ b/tsql/examples/shutdown_statements.sql @@ -0,0 +1,5 @@ +SHUTDOWN; +GO + +SHUTDOWN WITH NOWAIT; +GO diff --git a/tsql/examples/slow.sql b/tsql/examples/slow.sql new file mode 100644 index 0000000..7563760 --- /dev/null +++ b/tsql/examples/slow.sql @@ -0,0 +1,972 @@ + + +if exists (select * from sysobjects where name = 'up_com_test') + drop proc up_com_test +go + +create proc up_com_test + @p_vipa1111111111111 dtint, + @p_tblname dtchar32 + + -- + as + set nocount on + + declare @a1111111111111 dtint, + @sysdate dtdate, + @a2222222222 dtdate, + @a333333333333 dtkind, + @a444444444444444 dtint, + @vipid dtchar32, + @vipa333333333333 dtkind + + + exec nb_com_getsysconfig @a1111111111111 output, @sysdate output , @a2222222222 output, @a333333333333 output + select @a444444444444444 = paravalue from dbo.mixedconfig where a1111111111111 = @a1111111111111 and paraid = 'vipsubsys_sn' + select @vipid = vipid,@vipa333333333333 = a333333333333 from dbo.vipconfig where a1111111111111 = @a1111111111111 and vip_a1111111111111 = @p_vipa1111111111111 + if @a333333333333 !='0' + begin + select errorcode = -1, errormsg = '执行!' + return -1 + end + + if @vipa333333333333 !='0' + begin + select errorcode = -1, errormsg = '准备!' + return -1 + end + + + declare @gmhardware dtkind + set @gmhardware = '0' + select @gmhardware = paravalue from dbo.mixedconfig where a1111111111111 = @a1111111111111 and paraid = 'gmhardware' + + + create table #stktype + (a1111111111111 int default 0, + market char(1) default ' ', + stktype char(1) default ' ', + feestktype char(1) default ' ', + moneytype char(1) default ' ' + ) + + create table #diffstktype + (market char(1) default ' ', + stktype char(1) default ' ') + + + create table #bizConvert + (fstkbiz int default 0, + tstkbiz int default 0) + + if @p_tblname = 'ITF_USERS' + begin + delete from dbo.ITF_USERS where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + insert into dbo.ITF_USERS + (USER_CODE, USER_ROLES, USER_NAME, USER_TYPE, INT_ORG, + ID_TYPE, ID_CODE, OPEN_DATE, vipa1111111111111, SYNC_TYPE ) + select a.custid as USER_CODE, + '1' as USER_ROLES, + ISNULL(rtrim(a.custname),' ') as USER_NAME, + b.singleflag as USER_TYPE, + a.orgid as INT_ORG, + dbo.fn_ksts_idtype2ID_TYPE(b.idtype) as ID_TYPE, + + case when @gmhardware = '2' then b.sm_data1 else b.idno end as ID_CODE, + b.opendate as OPEN_DATE, + @p_vipa1111111111111 as vipa1111111111111, + '1' as SYNC_TYPE + from dbo.customer a + inner join dbo.c666666666666666 b with (nolock) on a.custid = b.custid and a.a1111111111111 = b.a1111111111111 + inner join dbo.vip_customers d with (nolock) on a.a1111111111111 = d.a1111111111111 and a.custid = d.custid and a.orgid = d.orgid + inner join dbo.fundinfo e with (nolock) on d.a1111111111111 = e.a1111111111111 and d.orgid = e.orgid and d.fundid = e.fundid and a.custid = e.custid + where a.custprop = '0' and a.a333333333333 != '*' and e.fundtype != 'T' and e.a333333333333 != '*' + and d.vipid = @vipid + and d.a333333333333 = '3' + if @@error != 0 + begin + select errorcode = -1 , errormsg = '失败' + end + + + select errorcode = 0 , errormsg = 'ITF_USERS数据处理成功' + update dbo.itf_sync_tables set prepcnt = (select count(*) from dbo.ITF_USERS where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111),a333333333333 = '1' + where vipid = @vipid and tablename = @p_tblname and direct = 'e' + select tablecnt = count(*) from dbo.ITF_USERS where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + end + + else if @p_tblname = 'ITF_CUSTOMER' + begin + delete from dbo.ITF_CUSTOMER where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + insert into dbo.ITF_CUSTOMER + (CUST_CODE, CUST_TYPE, CUST_CLS, CUST_a333333333333, CARD_ID,CRITERION, RISK_FACTOR,INT_ORG,OPEN_DATE, + CHANNELS,REMARK,CREDIT_LVL,REMOTE_PROTOCOL,CUST_SOURCE,SERVICE_LVL,CUST_EXT_ATTR,CLOSE_DATE, + vipa1111111111111, SYNC_TYPE) + select + a.custid as CUST_CODE, + a.custprop as USER_TYPE, + a.custkind as CUST_CLS, + a.a333333333333 as CUST_a333333333333, + case when len(ltrim(rtrim(a.custcard))) < 1 then ' ' + else ltrim(rtrim(a.custcard)) + end as CARD_ID, + case when len(b.criterion) < 1 then ' ' + else b.criterion + end as CRITERION, + case when len(b.riskfactor) < 1 then ' ' + else b.riskfactor + end as RISK_FACTOR, + a.orgid as INT_ORG, + b.opendate as OPEN_DATE, + left(ltrim(rtrim(ISNULL(d.operway,''))),64) as CHANNELS, + b.remark as REMARK, + '' as CREDIT_LVL, + '' as REMOTE_PROTOCOL, + '' as CUST_SOURCE, + '' as SERVICE_LVL, + '' as CUST_EXT_ATTR, + b.closedate as CLOSE_DATE, + @p_vipa1111111111111 as vipa1111111111111, + '1' as SYNC_TYPE + FROM dbo.customer a + inner join dbo.c666666666666666 b with (nolock) on a.custid = b.custid and a.a1111111111111 = b.a1111111111111 + inner join dbo.vip_customers c with (nolock) on a.a1111111111111 = c.a1111111111111 and a.custid = c.custid and a.orgid = c.orgid + inner join dbo.fundinfo d with (nolock) on c.a1111111111111 = d.a1111111111111 and c.orgid = d.orgid and c.fundid = d.fundid and a.custid = d.custid + WHERE a.a333333333333 != '*' and d.fundtype != 'T' and d.a333333333333 != '*' and a.custprop = '0' + and c.vipid = @vipid + and c.a333333333333 = '3' + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败' + return -1 + end + + select errorcode = 0 , errormsg = '成功' + update dbo.itf_sync_tables set prepcnt = (select count(*) from dbo.ITF_CUSTOMER where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111),a333333333333 = '1' + where vipid = @vipid and tablename = @p_tblname and direct = 'e' + select tablecnt = count(*) from dbo.ITF_CUSTOMER where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + end + + else if @p_tblname = 'ITF_CUST_AGREEMENT' + begin + delete from dbo.ITF_CUST_AGREEMENT where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + insert into dbo.ITF_CUST_AGREEMENT + (CUST_CODE, CUST_AGMT_TYPE, EFT_DATE, EXP_DATE, UPD_DATE, + vipa1111111111111, SYNC_TYPE , CUACCT_CODE,TRDACCT,STKBD) + select distinct + b.custid as CUST_CODE, + dbo.fn_ksts_khqx2AGREEMENT(c.subitem) as CUST_AGMT_TYPE, + isnull(d.effectdate, 19990101) as EFT_DATE, + case when c.recordflag = '1' then isnull(d.expiredate,19990101) else isnull(d.expiredate, 20990101) end as EXP_DATE, + isnull(d.procdate, 19990101) as UPD_DATE, + @p_vipa1111111111111 as vipa1111111111111, + '1' as SYNC_TYPE, + b.fundid as CUACCT_CODE, + b.secuid as TRDACCT, + dbo.fn_ksts_market2STKBD(b.market, '0') as STKBD + from dbo.vip_customers a + inner join (select distinct x.a1111111111111 a1111111111111, x.orgid orgid, x.custid custid, x.fundid, y.secuid,y.market,x.fundright+case when x.fundright!='' then ',' else '' end+y.securight fundright from dbo.fundinfo x, dbo.secuid y where x.custid = y.custid and x.orgid = y.orgid and y.a333333333333<>'*' and x.a333333333333<>'*') b + on a.custid = b.custid and a.orgid = b.orgid and a.a1111111111111 = b.a1111111111111 and a.fundid = b.fundid + inner join (select distinct rtrim(subitem) subitem , recordflag from dbo.dictvalue a, dbo.rightpropery b + where dictitem = 'Bkhqx' and subitem in ('03','04','0A','0G','0H','0J','0K','0h','0V','0X','2k','0b','0e','0p','0q','0m','0v','0k','0^','0s','0N','0n','0$','0w','1e','1g','2C','2h','2i','2j','2l','1n','1q','2q','2H')--1n 基础设施基金交易权限 + and a.subitem = b.rightid and a.a1111111111111 = b.a1111111111111 + ) c on 1=1 + left join (select a1111111111111, orgid, custid, market,secuid, fundright,min(effectdate) effectdate, max(expiredate) expiredate, min(procdate) procdate from dbo.fundrightvalid where a333333333333 <> '0' + group by a1111111111111,orgid,custid,market,secuid,fundright ) d + on a.custid = d.custid and a.orgid = d.orgid and a.a1111111111111 = d.a1111111111111 AND c.subitem = d.fundright + and b.market = d.market and b.secuid = d.secuid + where a.vipid = @vipid and a.a333333333333= '3' + and charindex(c.subitem, b.fundright) > 0 + + + + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败' + return -1 + end + + + select errorcode = 0 , errormsg = '成功' + update dbo.itf_sync_tables set prepcnt = (select count(*) from dbo.ITF_CUST_AGREEMENT where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111),a333333333333 = '1' + where vipid = @vipid and tablename = @p_tblname and direct = 'e' + select tablecnt = count(*) from dbo.ITF_CUST_AGREEMENT where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + end + + else if @p_tblname = 'ITF_CUST_STK_TRD_CTRL' + begin + delete from dbo.ITF_CUST_STK_TRD_CTRL where vipa1111111111111 = @p_vipa1111111111111 and SYNC_TYPE = '1' + insert into dbo.ITF_CUST_STK_TRD_CTRL + ( SYNC_TYPE , INT_ORG,CUST_CODE ,CUACCT_CODE ,STKBD ,TRDACCT ,STK_BIZES ,STK_CLSES ,STK_CODE ,GRANT_TYPE ,STK_BIZ_ACTIONS,vipa1111111111111) + select distinct + '1' as SYNC_TYPE, + a.orgid as INT_ORG, + a.custid as CUST_CODE, + a.fundid as CUACCT_CODE, + dbo.fn_ksts_market2STKBD(a.market, '0') as STKBD, + '@' as TRDACCT, + dbo.fn_ksts_bsflag2STK_BIZ_EX(a.bsflag,a.stktype) as STK_BIZES, + dbo.fn_ksts_stktype2STK_CLS(a.stktype,'0',0,a.market, ' ', ' ') as STK_CLSES, + a.stkcode_s as STK_CODE, + case when a.stk_direct = '0' then '1' else '0' end as GRANT_TYPE, + '@' as STK_BIZ_ACTIONS, + @p_vipa1111111111111 as vipa1111111111111 + from dbo.fundtrdctrl a inner join dbo.vip_customers b with (nolock) + on a.custid = b.custid and a.fundid = b.fundid and a.a1111111111111 = b.a1111111111111 + where b.vipid = @vipid and b.a333333333333 = '3' + and dbo.fn_ksts_bsflag2STK_BIZ_EX(a.bsflag,a.stktype) <> 0 + if @@error != 0 + begin + select errorcode = -1 , errormsg = '失败' + end + + select errorcode = 0 , errormsg = 'STK_HS_DETAIL数据处理成功' + update dbo.itf_sync_tables set prepcnt = (select count(*) from dbo.ITF_CUST_STK_TRD_CTRL where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111),a333333333333 = '1' + where vipid = @vipid and tablename = @p_tblname and direct = 'e' + + select tablecnt = count(*) from dbo.ITF_CUST_STK_TRD_CTRL where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + end + else if @p_tblname = 'ITF_CUACCT' + begin + delete from dbo.ITF_CUACCT where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + insert into dbo.ITF_CUACCT + (USER_CODE, CUACCT_CODE, CUACCT_ATTR, CUACCT_CLS, CUACCT_LVL, + CUACCT_GRP, CUACCT_a333333333333, MAIN_FLAG, INT_ORG, OPEN_DATE, + PRINT_DATE, vipa1111111111111, SYNC_TYPE, CLOSE_DATE, FUND_LIMITE) + select + a.custid as USER_CODE, + a.fundid as CUACCT_CODE, + '0' as CUACCT_ATTR, + case when len(a.fundkind) < 1 then ' ' + else a.fundkind + end as CUACCT_CLS, + case when len(a.fundlevel) < 1 then ' ' + else a.fundlevel + end as CUACCT_LVL, + case when len(a.fundgroup) < 1 then ' ' + else a.fundgroup + end as CUACCT_GRP, + a.a333333333333 as CUACCT_a333333333333, + case when a.fundtype = 'T' then '0' + else '1' + end as MAIN_FLAG, + a.orgid as INT_ORG, + opendate as OPEN_DATE, + printdate as PRINT_DATE, + @p_vipa1111111111111 as vipa1111111111111, + '1' as SYNC_TYPE, + a.closedate as CLOSE_DATE, + a.fundlimit as FUND_LIMITE + from dbo.fundinfo a + inner join dbo.vip_customers b with (nolock) on a.a1111111111111 = b.a1111111111111 and a.orgid = b.orgid and a.custid = b.custid and a.fundid = b.fundid + where 1 = 1 and a.a333333333333 != '*' + and b.vipid = @vipid + and b.a333333333333 = '3' + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败' + return -1 + end + + select errorcode = 0 , errormsg = '成功' + update dbo.itf_sync_tables set prepcnt = (select count(*) from dbo.ITF_CUACCT where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111),a333333333333 = '1' + where vipid = @vipid and tablename = @p_tblname and direct = 'e' + select tablecnt = count(*) from dbo.ITF_CUACCT where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + end + + else if @p_tblname = 'ITF_STK_TRDACCT' + begin + declare @secusno dtsno + set @secusno = 0 + select @secusno = secusno from dbo.seculist where a1111111111111 = @a1111111111111 and flag = '1' + + delete from dbo.ITF_STK_TRDACCT where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + insert into dbo.ITF_STK_TRDACCT + (CUST_CODE, CUACCT_CODE, INT_ORG, STKEX, STKBD, + TRDACCT, TRDACCT_SN, TRDACCT_EXID, TRDACCT_TYPE, TRDACCT_EXCLS, + TRDACCT_NAME, TRDACCT_a333333333333, TREG_a333333333333, BREG_a333333333333, STKPBU, + FIRMID, ID_TYPE, ID_CODE, ID_ISS_AGCY, ID_EXP_DATE, + OPEN_DATE, vipa1111111111111, SYNC_TYPE,TRDACCT_MAIN_FLAG + ) + select + a.custid as CUST_CODE, + b.fundid as CUACCT_CODE, + a.orgid as INT_ORG, + dbo.fn_ksts_market2STKEX(a.market) as STKEX, + dbo.fn_ksts_market2STKBD(a.market, '0') as STKBD, + a.secuid as TRDACCT, + '0' as TRDACCT_SN, + case when len(a.rptsecuid) < 1 then ' ' else a.rptsecuid end as TRDACCT_EXID, + case when len(a.foreignflag) < 1 then ' ' else a.foreignflag end as TRDACCT_TYPE, + case when @secusno = 24 then c.singleflag else dbo.fn_ksts_secucls2TRDACCT_EXCLS(a.secucls, c.singleflag) end as TRDACCT_EXCLS, + case when len(ltrim(rtrim(a.name))) < 1 then ' ' else ISNULL(ltrim(rtrim(a.name)),' ') end as TRDACCT_NAME, + a.a333333333333 as TRDACCT_a333333333333, + dbo.fn_ksts_regflag2TREG_a333333333333(a.regflag) as TREG_a333333333333, + dbo.fn_ksts_regflag2TREG_a333333333333(a.bondreg) as BREG_a333333333333, + a.seat as STKPBU, + case when a.market = '3' then isnull(j.firmid, ' ') else ' ' end as FIRMID, + dbo.fn_ksts_idtype2ID_TYPE(a.idtype) as ID_TYPE, + case when @gmhardware = '2' then c.sm_data1 else c.idno end as ID_CODE, + case when len(c.policeorg) < 1 then ' ' else c.policeorg end as ID_ISS_AGCY, + c.idenddate as ID_EXP_DATE, + a.opendate as OPEN_DATE, + @p_vipa1111111111111 as vipa1111111111111, + '1' as SYNC_TYPE, + case when a.secuseq = 0 then '1' else '0' end as TRDACCT_MAIN_FLAG + from dbo.secuid a + inner join dbo.vip_customers b with (nolock) on a.custid = b.custid and a.a1111111111111 = b.a1111111111111 and a.orgid = b.orgid + inner join dbo.c666666666666666 c with (nolock) on b.custid = c.custid and b.a1111111111111 = c.a1111111111111 + inner join dbo.fundinfo x with (nolock) on b.custid = x.custid and b.fundid = x.fundid and b.orgid = x.orgid and b.a1111111111111 = x.a1111111111111 + left join dbo.orgseat i on a.orgid = i.orgid and a.market = i.market and (i.pt_bsflag = '@' or charindex('0B', i.pt_bsflag) > 0 ) + left join dbo.seat j on a.a1111111111111 = j.a1111111111111 and a.market = j.market and i.seat = j.seat + where a.a333333333333 != '*' and x.a333333333333 != '*' and x.fundtype != 'T' + and b.vipid = @vipid + and b.a333333333333 = '3' + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败' + return -1 + end + + update dbo.ITF_STK_TRDACCT set + TREG_a333333333333 = dbo.fn_ksts_regflag2TREG_a333333333333(b.regflag) + from dbo.secuid b where TRDACCT = b.secuid and CUST_CODE = b.custid and b.market='1' and STKBD = '13' + + + + select errorcode = 0 , errormsg = '成功' + update dbo.itf_sync_tables set prepcnt = (select count(*) from dbo.ITF_STK_TRDACCT where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111),a333333333333 = '1' + where vipid = @vipid and tablename = @p_tblname and direct = 'e' + select tablecnt = count(*) from dbo.ITF_STK_TRDACCT where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + end + + else if @p_tblname = 'ITF_CUACCT_FUND' + begin + delete from dbo.ITF_CUACCT_FUND where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + + select custid, fundid, isnull(sum(payqty * matchprice),0.00) as fundeffect + into #fundeffect + from dbo.mateconfirm + where issuetype = '1' and a333333333333 = '1' + group by custid, fundid + + insert into dbo.ITF_CUACCT_FUND + (USER_CODE, USER_NAME, CUACCT_CODE, CUACCT_ATTR, CUACCT_CLS, + CUACCT_LVL, CUACCT_GRP, CUACCT_DMF, INT_ORG, CURRENCY, + FUND_PREBLN, FUND_BLN, FUND_AVL, FUND_FRZ, FUND_UFZ, + FUND_TRD_FRZ, FUND_TRD_UFZ, FUND_TRD_OTD, FUND_TRD_BLN, FUND_CLR_FRZ, + FUND_CLR_UFZ, FUND_CLR_OTD, FUND_CLR_CTF, FUND_TRN_FRZ, FUND_TRN_UFZ, + FUND_DEBT, FUND_CREDIT, INT_RATE_SN, DR_RATE_SN, INT_CAL_BLN, + INT_BLN_ACCU, INT_CAL_DATE, INTEREST, INT_TAX, DR_INT, + MKT_VAL, CASH_ACCU, CHEQUE_ACCU, LAST_FUND_CLR, LWLMT_FUND, + LWLMT_ASSET, UPD_TIME, FUND_a333333333333, MAC, PAYLATER, + SUBSYS_SN, vipa1111111111111, SYNC_TYPE, CREDIT_FUND_BLN, FUND_SPECIAL,ASSETCASHPRO) + select + a.custid as USER_CODE, + ISNULL(ltrim(rtrim(b.fundname)),' ') as USER_NAME, + a.fundid as CUACCT_CODE, + '0' as CUACCT_ATTR, + case when len(b.fundkind) < 1 then ' ' else b.fundkind end as CUACCT_CLS, + case when len(b.fundlevel) < 1 then ' ' else b.fundlevel end as CUACCT_LVL, + case when len(b.fundgroup) < 1 then ' ' else b.fundgroup end as CUACCT_GRP, + '1' as CUACCT_DMF, + b.orgid as INT_ORG, + a.moneytype as CURRENCY, + a.fundlastbal as FUND_PREBLN, + a.fundbal as FUND_BLN, + a.fundavl as FUND_AVL, + a.fundfrz as FUND_FRZ, + a.fundunfrz as FUND_UFZ, + a.fundbuy as FUND_TRD_FRZ, + a.fundsale as FUND_TRD_UFZ, + 0 as FUND_TRD_OTD, + a.fundbuysale as FUND_TRD_BLN, + a.funduncomebuy as FUND_CLR_FRZ, + a.funduncomesale as FUND_CLR_UFZ, + 0 as FUND_CLR_OTD, + 0 as FUND_CLR_CTF, + 0 as FUND_TRN_FRZ, + 0 as FUND_TRN_UFZ, + 0 as FUND_DEBT, + 0 as FUND_CREDIT, + 0 as INT_RATE_SN, + 0 as DR_RATE_SN, + 0 as INT_CAL_BLN, + 0 as INT_BLN_ACCU, + 0 as INT_CAL_DATE, + 0 as INTEREST, + 0 as INT_TAX, + 0 as DR_INT, + a.marketvalue as MKT_VAL, + 0 as CASH_ACCU, + 0 as CHEQUE_ACCU, + 0 as LAST_FUND_CLR, + 0 as LWLMT_FUND, + 0 as LWLMT_ASSET, + ' ' as UPD_TIME, + '0' as FUND_a333333333333, + ' ' as MAC, + 0 as PAYLATER, + @a444444444444444 as SUBSYS_SN, + @p_vipa1111111111111 as vipa1111111111111, + '1' as SYNC_TYPE, + 0 as CREDIT_FUND_BLN, + isnull(c.fundeffect,0.00) as FUND_SPECIAL, + a.fundcashpro as assetcashpro + from dbo.syncfundasset a + inner join dbo.vip_customers d with (nolock) on a.custid = d.custid and a.fundid = d.fundid and a.orgid = d.orgid and a.a1111111111111 = d.a1111111111111 + inner join dbo.fundinfo b with (nolock) on a.fundid = b.fundid and a.a1111111111111 = b.a1111111111111 and a.orgid = b.orgid and a.custid = b.custid + left join #fundeffect c on b.fundid = c.fundid and b.custid = c.fundid + where 1 = 1 and b.a333333333333 != '*' + and d.vipid = @vipid + and d.a333333333333 = '3' + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败' + return -1 + end + + select errorcode = 0 , errormsg = '成功' + update dbo.itf_sync_tables set prepcnt = (select count(*) from dbo.ITF_CUACCT_FUND where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111),a333333333333 = '1' + where vipid = @vipid and tablename = @p_tblname and direct = 'e' + select tablecnt = count(*) from dbo.ITF_CUACCT_FUND where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + end + + else if @p_tblname = 'ITF_STK_ASSET' + begin + delete from dbo.ITF_STK_ASSET where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + insert into dbo.ITF_STK_ASSET + (CUST_CODE, CUACCT_CODE, CUACCT_ATTR, CUACCT_CLS, CUACCT_LVL, + CUACCT_GRP, INT_ORG, STKEX, STKBD, STKPBU, + TRDACCT, CURRENCY, STK_CODE, STK_CLS, STK_PREBLN, + STK_BLN, STK_AVL, STK_FRZ, STK_UFZ, STK_NTRD, + STK_TRD_FRZ, STK_TRD_UFZ, STK_TRD_OTD, STK_TRD_BLN, STK_CLR_FRZ, + STK_CLR_UFZ, STK_CLR_OTD, STK_BCOST, STK_BCOST_RLT, STK_PLAMT, + STK_PLAMT_RLT, MKT_VAL, UPD_TIME, MAC, SUBSYS_SN, + vipa1111111111111, SYNC_TYPE) + select + a.custid as CUST_CODE, + a.fundid as CUACCT_CODE, + '0' as CUACCT_ATTR, + (select fundkind from dbo.fundinfo where a.fundid=fundid and fundtype != 'T' and a333333333333 != '*') as CUACCT_CLS, + (select fundlevel from dbo.fundinfo where a.fundid=fundid and fundtype != 'T' and a333333333333 != '*') as CUACCT_LVL, + (select fundgroup from dbo.fundinfo where a.fundid=fundid and fundtype != 'T' and a333333333333 != '*') as CUACCT_GRP, + a.orgid as INT_ORG, + dbo.fn_ksts_market2STKEX(a.market) as STKEX, + dbo.fn_ksts_market2STKBD(a.market, '0') as STKBD, + case when f.seat = '' then i.seat else f.seat end as STKPBU, + a.secuid as TRDACCT, + a.moneytype as CURRENCY, + a.stkcode as STK_CODE, + dbo.fn_ksts_stktype2STK_CLS(g.stktype, '0', 0,g.market, ' ', g.isreg) as STK_CLS, + a.stklastbal as STK_PREBLN, + a.stkbal as STK_BLN, + a.stkavl as STK_VAL, + a.stkfrz as STK_FRZ, + a.stkunfrz as STK_UFZ, + 0 as STK_NTRD, + a.stkbuy as STK_TRD_FRZ, + a.stksale as STK_TRD_UFZ, + --a.stkuncomebuy + a.stkuncomesale as STK_TRD_OTD, + 0 as STK_TRD_OTD, + a.stkbuysale as STK_TRD_BLN, + a.stkuncomesale as STK_CLR_FRZ, + a.stkuncomebuy as STK_CLR_UFZ, + a.stkuncomebuy as STK_CLR_OTD, + a.buycost as STK_BCOST, + a.buycost as STK_BCOST_RLT, + a.profitcost as STK_PLAMT, + a.profitcost as STK_PLAMT_RLT, + a.mktval as MKT_VAL, + ' ' as UPD_TIME, + ' ' as MAC, + @a444444444444444 as SUBSYS_SN, + @p_vipa1111111111111 as vipa1111111111111, + '1' as SYNC_TYPE + FROM dbo.syncstkasset a + inner join dbo.fundinfo b with (nolock) on a.a1111111111111 = b.a1111111111111 and a.orgid = b.orgid and a.custid = b.custid and a.fundid = b.fundid and b.fundtype != 'T' + inner join dbo.vip_customers c with (nolock) on b.a1111111111111 = c.a1111111111111 and b.orgid = c.orgid and b.custid = c.custid and b.fundid = c.fundid + inner join dbo.secuid f with (nolock) on a.a1111111111111 = f.a1111111111111 and a.orgid = f.orgid and a.custid = f.custid and a.market = f.market and a.secuid = f.secuid + inner join dbo.stktrd g with (nolock) on a.market = g.market and a.stkcode = g.stkcode and a.a1111111111111 = g.a1111111111111 + inner join dbo.orgseat i on a.orgid = i.orgid and a.market = i.market and (i.pt_bsflag = '@' or charindex('0B', i.pt_bsflag) > 0 ) + where 1 = 1 and b.a333333333333 != '*' and f.a333333333333 != '*' + and c.vipid = @vipid + and c.a333333333333 = '3' + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败' + return -1 + end + + + select errorcode = 0 , errormsg = 'ITF_STK_ASSET数据处理成功' + update dbo.itf_sync_tables set prepcnt = (select count(*) from dbo.ITF_STK_ASSET where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111),a333333333333 = '1' + where vipid = @vipid and tablename = @p_tblname and direct = 'e' + select tablecnt = count(*) from dbo.ITF_STK_ASSET where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + end + + else if @p_tblname = 'ITF_STK_COM_SPCFG' + begin + delete from dbo.ITF_STK_COM_SPCFG where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + + insert #stktype(a1111111111111,market,stktype, feestktype,moneytype) + select distinct a1111111111111,market,stktype,feestktype = case when feestktype = '' then stktype else feestktype end,moneytype + from dbo.stktype where stktype in (select stktype from dbo.stktype where feestktype != '' and feestktype != stktype) + and a1111111111111 = @a1111111111111 + + insert #diffstktype + ( market, stktype ) + select distinct market,stktype from #stktype + + insert #stktype (a1111111111111,market,stktype,feestktype,moneytype) + select distinct a1111111111111,market,stktype,stktype,moneytype + from dbo.stktype a + where exists (select 1 from #stktype where market = a.market and feestktype = a.stktype and a1111111111111 = a.a1111111111111 and moneytype = a.moneytype and feestktype <> stktype) + + select a.custid,a.fundid, a.orgid into #effectcust from dbo.vip_customers a, dbo.customer b, dbo.fundinfo c + where a.custid = b.custid and a.vipid = @vipid + and a.custid = c.custid and a.fundid = c.fundid and a.orgid = c.orgid + and c.fundtype != 'T' and c.a333333333333 != '*' and a.a333333333333 = '3' + and (exists(select 1 from dbo.customer where custid = a.custid and calfeetype = '1' and effectdate <= @sysdate ) + or exists(select 1 from dbo.kfee_org_calflag where a.orgid = orgid and startdate <= @sysdate and kfeetype = '1')) + + create index #effectcust_idx_custid on #effectcust(custid) + + select A.* into #surcharge_nocontain from + ( + select b.a1111111111111,a.orgid, a.custid,a.fundid, d.market, d.stktype, d.trdid, d.bsflag, d.stkcode, s.feerate, s.feemax, s.feemin, rowid = row_number() + over(partition by b.a1111111111111, a.custid, d.market, d.stktype, d.trdid, d.bsflag, d.stkcode order by feerate desc) + from #effectcust a, dbo.kfee_custcommission b, dbo.kfee_productdetails c, dbo.kfee_business d, dbo.kfee_custsurcharge e, dbo.kfee_surcharge s + where a.custid = b.custid + and b.productid = c.productid and b.a1111111111111 = c.a1111111111111 + and c.businessid = d.businessid and c.a1111111111111 = d.a1111111111111 + and b.custid = e.custid and b.productid = e.productid and b.a1111111111111 = e.a1111111111111 and charindex(e.servicetype, b.servicetypes) > 0 + and s.surchargeid = e.surchargeid and s.a1111111111111 = e.a1111111111111 and s.containflag = '0' + ) A where A.rowid = 1 + + insert #bizConvert values(249,249) + insert #bizConvert values(249,251) + insert #bizConvert values(249,253) + insert #bizConvert values(250,250) + insert #bizConvert values(250,252) + insert #bizConvert values(250,254) + + insert #bizConvert values(242,960) + insert #bizConvert values(243,961) + + insert #bizConvert values(100,100) + insert #bizConvert values(101,101) + insert #bizConvert values(100,240) + insert #bizConvert values(101,241) + + insert #bizConvert values(242,242) + insert #bizConvert values(242,244) + insert #bizConvert values(242,247) + insert #bizConvert values(242,257) + insert #bizConvert values(243,243) + insert #bizConvert values(243,245) + insert #bizConvert values(243,248) + insert #bizConvert values(243,255) + insert #bizConvert values(243,256) + + select rec_dentity=identity(int,1,1),finalstkBiz = isnull(b.tstkbiz, t1.STK_BIZ),t1.* into #ITF_STK_COM_SPCFG1 from + ( + select + REC_SN = 10000000, + INT_ORG = convert(int, A.orgid), + OBJ_TYPE = '0', + OBJ_VALUE = convert(varchar(20), A.fundid), + STKBD = dbo.fn_ksts_market2STKBD(A.market, '0'), + STK_CLS = dbo.fn_ksts_stktype2STK_CLS(isnull(B.stktype,A.stktype), '0', 0, A.market,' ', ' '), + STK_FLAG = '0', + STK_CODE = '@', + STK_BIZ = dbo.fn_ksts_bsflag2STK_BIZ(isnull(B.stktype,A.stktype), A.trdid, A.bsflag, A.market), + CHANNELS = A.pt_operway, + FEE_RATE = A.commissionrate , + FEE_MAX = A.maxfee, + FEE_MIN = A.minfee, + vipa1111111111111 = @p_vipa1111111111111, + SYNC_TYPE = '1' + from dbo.specialcommission A + inner join dbo.vip_customers C with (nolock) on A.a1111111111111 = C.a1111111111111 and A.orgid = C.orgid and A.fundid = C.fundid and A.custid = C.custid + inner join dbo.fundinfo F with (nolock) on C.a1111111111111 = F.a1111111111111 and C.orgid = F.orgid and C.custid = F.custid and C.fundid = F.fundid + inner join dbo.customer k on A.custid = k.custid and A.a1111111111111 = k.a1111111111111 + left join #stktype B on A.market = B.market and A.moneytype = B.moneytype and A.stktype = B.feestktype + where F.fundtype != 'T' and F.a333333333333 != '*' and C.vipid = @vipid + and A.trdid not in('4', '7', '8', 'R') and C.a333333333333 = '3' + and ((A.market+A.stktype in (select market+stktype from #diffstktype) and B.stktype is not null) or A.market+A.stktype not in (select market+stktype from #diffstktype)) + + and (not (k.calfeetype = '1' and k.effectdate <= @sysdate)) + and k.orgid not in (select orgid from dbo.kfee_org_calflag where startdate <= @sysdate and kfeetype = '1') + union all + select REC_SN = 10000000, + INT_ORG = convert(int, A.orgid), + OBJ_TYPE = '0', + OBJ_VALUE = convert(varchar(20), A.fundid), + STKBD = dbo.fn_ksts_market2STKBD(A.market, '0'), + STK_CLS = dbo.fn_ksts_stktype2STK_CLS(isnull(B.stktype,A.stktype), '0', 0,A.market,' ', ' '), + STK_FLAG = '0', + STK_CODE = A.stkcode, + STK_BIZ = dbo.fn_ksts_bsflag2STK_BIZ(isnull(B.stktype,A.stktype), A.trdid, A.bsflag, A.market), + CHANNELS = '@', + FEE_RATE = A.feerate + isnull(s.feerate, 0.00), + FEE_MAX = A.feemax, + FEE_MIN = A.feemin, + vipa1111111111111 = @p_vipa1111111111111, + SYNC_TYPE = '1' + from + ( + select a.*, rowid = row_number() over(partition by a.a1111111111111,a.custid, a.market, a.stktype, a.trdid, a.bsflag,a.stkcode order by feerate desc) from + ( + select a.a1111111111111,c.orgid, a.custid,c.fundid, b.market,b.stktype, b.trdid, b.bsflag, b.stkcode, k.feerate, k.feemax, k.feemin + from dbo.kfee_custbusiness a, dbo.kfee_business b,#effectcust c, dbo.kfee_productprices k + where a.businessid = b.businessid and a.a1111111111111 = b.a1111111111111 and b.stkcode = '' + and a.custid = c.custid + and a.priceid = k.priceid and a.a1111111111111 = k.a1111111111111 + union + select a.a1111111111111, d.orgid, a.custid,d.fundid, c.market,c.stktype, c.trdid, c.bsflag, c.stkcode, k.feerate, k.feemax, k.feemin + from dbo.kfee_custcommission a, dbo.kfee_productdetails b, dbo.kfee_business c,#effectcust d, dbo.kfee_productprices k + where a.a1111111111111 = b.a1111111111111 and a.productid = b.productid and c.stkcode = '' + and b.businessid = c.businessid and b.a1111111111111 = c.a1111111111111 + and a.custid = d.custid + and a.priceid = k.priceid and a.a1111111111111 = k.a1111111111111 + union + select b.a1111111111111, a.orgid, a.custid,a.fundid, d.market, d.stktype, d.trdid, d.bsflag, d.stkcode, s.feerate, s.feemax, s.feemin + from #effectcust a, dbo.kfee_custcommission b, dbo.kfee_productdetails c, dbo.kfee_business d, dbo.kfee_custsurcharge e, dbo.kfee_surcharge s + where a.custid = b.custid + and b.productid = c.productid and b.a1111111111111 = c.a1111111111111 + and c.businessid = d.businessid and c.a1111111111111 = d.a1111111111111 + and b.custid = e.custid and b.productid = e.productid and b.a1111111111111 = e.a1111111111111 and charindex(e.servicetype, b.servicetypes) > 0 + and s.surchargeid = e.surchargeid and s.a1111111111111 = e.a1111111111111 and s.containflag = '1' + ) a + ) A inner join dbo.marketmoney e on A.market = e.market and A.a1111111111111 = e.a1111111111111 + left join #stktype B on A.market = B.market and e.moneytype = B.moneytype and A.stktype = B.feestktype + left join #surcharge_nocontain s on s.a1111111111111 = A.a1111111111111 and s.custid = A.custid and s.market = A.market and s.stktype = A.stktype and s.trdid = A.trdid and s.bsflag = A.bsflag and s.stkcode = A.stkcode + where A.a1111111111111 = @a1111111111111 and A.rowid = 1 + and A.trdid not in('4', '7', '8', 'R') + and ((A.market+A.stktype in (select market+stktype from #diffstktype) and B.stktype is not null) or A.market+A.stktype not in (select market+stktype from #diffstktype)) + + ) t1 left join #bizConvert b on STK_BIZ = b.fstkbiz order by OBJ_VALUE + + insert into dbo.ITF_STK_COM_SPCFG + (REC_SN, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE) + select rec_dentity+REC_SN, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, finalstkBiz, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE + from #ITF_STK_COM_SPCFG1 + + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败' + return -1 + end + + drop table #ITF_STK_COM_SPCFG1 + + + if exists (select * from dbo.ITF_STK_COM_SPCFG where STK_BIZ in (181, 182, 183) and SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111) + begin + + select REC_SN=identity(int,1,1),t2.* into #ITF_STK_COM_SPCFG2 from ( + select + INT_ORG = A.INT_ORG, + OBJ_TYPE = A.OBJ_TYPE, + OBJ_VALUE = A.OBJ_VALUE, + STKBD = A.STKBD, + STK_CLS = A.STK_CLS, + STK_FLAG = A.STK_FLAG, + STK_CODE = A.STK_CODE, + STK_BIZ = case when A.STK_BIZ = 181 then 187 when A.STK_BIZ = 182 then 188 else 180 end, + CHANNELS = A.CHANNELS, + FEE_RATE = A.FEE_RATE, + FEE_MAX = A.FEE_MAX, + FEE_MIN = A.FEE_MIN, + vipa1111111111111 = @p_vipa1111111111111, + SYNC_TYPE = '1' + from dbo.ITF_STK_COM_SPCFG A where A.STK_BIZ in (181, 182, 183) and A.SYNC_TYPE = '1' and A.vipa1111111111111 = @p_vipa1111111111111) t2 order by OBJ_VALUE + + insert into dbo.ITF_STK_COM_SPCFG + (REC_SN, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE) + select REC_SN + 30000000, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE + from #ITF_STK_COM_SPCFG2 + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败' + return -1 + end + + drop table #ITF_STK_COM_SPCFG2 + end + + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败' + return -1 + end + + if exists (select * from dbo.ITF_STK_COM_SPCFG where STK_BIZ in (181, 182, 183) and SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111) + begin + + select REC_SN=identity(int,1,1),t3.* into #ITF_STK_COM_SPCFG3 from ( + select + INT_ORG = A.INT_ORG, + OBJ_TYPE = A.OBJ_TYPE, + OBJ_VALUE = A.OBJ_VALUE, + STKBD = A.STKBD, + STK_CLS = A.STK_CLS, + STK_FLAG = A.STK_FLAG, + STK_CODE = A.STK_CODE, + STK_BIZ = case when A.STK_BIZ = 181 then 827 when A.STK_BIZ = 182 then 828 else 184 end, + CHANNELS = A.CHANNELS, + FEE_RATE = A.FEE_RATE, + FEE_MAX = A.FEE_MAX, + FEE_MIN = A.FEE_MIN, + vipa1111111111111 = @p_vipa1111111111111, + SYNC_TYPE = '1' + from dbo.ITF_STK_COM_SPCFG A where A.STK_BIZ in (181, 182, 183) and A.SYNC_TYPE = '1' and A.vipa1111111111111 = @p_vipa1111111111111) t3 order by OBJ_VALUE + + insert into dbo.ITF_STK_COM_SPCFG + (REC_SN, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE) + select REC_SN + 35000000, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE + from #ITF_STK_COM_SPCFG3 + + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败' + return -1 + end + + drop table #ITF_STK_COM_SPCFG3 + + end + if exists (select * from dbo.ITF_STK_COM_SPCFG where STK_BIZ in (181, 182) and SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111) + begin + select REC_SN=identity(int,1,1),t3.* into #ITF_STK_COM_SPCFG825_826 from ( + select + INT_ORG = A.INT_ORG, + OBJ_TYPE = A.OBJ_TYPE, + OBJ_VALUE = A.OBJ_VALUE, + STKBD = A.STKBD, + STK_CLS = A.STK_CLS, + STK_FLAG = A.STK_FLAG, + STK_CODE = A.STK_CODE, + STK_BIZ = case when A.STK_BIZ = 181 then 825 else 826 end, + CHANNELS = A.CHANNELS, + FEE_RATE = A.FEE_RATE, + FEE_MAX = A.FEE_MAX, + FEE_MIN = A.FEE_MIN, + vipa1111111111111 = @p_vipa1111111111111, + SYNC_TYPE = '1' + from dbo.ITF_STK_COM_SPCFG A where A.STK_BIZ in (181, 182) and A.SYNC_TYPE = '1' and A.vipa1111111111111 = @p_vipa1111111111111) t3 order by OBJ_VALUE + + insert into dbo.ITF_STK_COM_SPCFG + (REC_SN, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE) + select REC_SN + 40000000, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE + from #ITF_STK_COM_SPCFG825_826 + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败' + return -1 + end + drop table #ITF_STK_COM_SPCFG825_826 + + end + if exists (select * from dbo.ITF_STK_COM_SPCFG where STK_BIZ in (803, 804) and SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111) + begin + select REC_SN=identity(int,1,1),t6.* into #ITF_STK_COM_SPCFG807_808 from ( + select + INT_ORG = A.INT_ORG, + OBJ_TYPE = A.OBJ_TYPE, + OBJ_VALUE = A.OBJ_VALUE, + STKBD = A.STKBD, + STK_CLS = A.STK_CLS, + STK_FLAG = A.STK_FLAG, + STK_CODE = A.STK_CODE, + STK_BIZ = case when A.STK_BIZ = 803 then 807 else 808 end, + CHANNELS = A.CHANNELS, + FEE_RATE = A.FEE_RATE, + FEE_MAX = A.FEE_MAX, + FEE_MIN = A.FEE_MIN, + vipa1111111111111 = @p_vipa1111111111111, + SYNC_TYPE = '1' + from dbo.ITF_STK_COM_SPCFG A where A.STK_BIZ in (803, 804) and A.SYNC_TYPE = '1' and A.vipa1111111111111 = @p_vipa1111111111111) t6 order by OBJ_VALUE + + insert into dbo.ITF_STK_COM_SPCFG + (REC_SN, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE) + select REC_SN + 45000000, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE + from #ITF_STK_COM_SPCFG807_808 + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败' + return -1 + end + drop table #ITF_STK_COM_SPCFG807_808 + + end + if exists (select * from dbo.ITF_STK_COM_SPCFG where STK_BIZ in (260,261,960,961,966,967)and SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111) + begin + + select REC_SN=identity(int,1,1),t4.* into #ITF_STK_COM_SPCFG4 from ( + select + INT_ORG = A.INT_ORG, + OBJ_TYPE = A.OBJ_TYPE, + OBJ_VALUE = A.OBJ_VALUE, + STKBD = A.STKBD, + STK_CLS = A.STK_CLS, + STK_FLAG = A.STK_FLAG, + STK_CODE = A.STK_CODE, + STK_BIZ = case when A.STK_BIZ = 260 then 262 + when A.STK_BIZ = 261 then 263 + when A.STK_BIZ = 960 then 962 + when A.STK_BIZ = 961 then 963 + when A.STK_BIZ = 966 then 968 + when A.STK_BIZ = 967 then 969 + end, + CHANNELS = A.CHANNELS, + FEE_RATE = A.FEE_RATE, + FEE_MAX = A.FEE_MAX, + FEE_MIN = A.FEE_MIN, + vipa1111111111111 = A.vipa1111111111111, + SYNC_TYPE = A.SYNC_TYPE + from dbo.ITF_STK_COM_SPCFG A where A.STK_BIZ in (260,261,960,961,966,967)and SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111) t4 order by OBJ_VALUE + + insert into dbo.ITF_STK_COM_SPCFG + (REC_SN, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE) + select REC_SN + 50000000, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE + from #ITF_STK_COM_SPCFG4 + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败1' + return -1 + end + drop table #ITF_STK_COM_SPCFG4 + + + + select REC_SN=identity(int,1,1),t5.* into #ITF_STK_COM_SPCFG5 from ( + select + INT_ORG = A.INT_ORG, + OBJ_TYPE = A.OBJ_TYPE, + OBJ_VALUE = A.OBJ_VALUE, + STKBD = A.STKBD, + STK_CLS = A.STK_CLS, + STK_FLAG = A.STK_FLAG, + STK_CODE = A.STK_CODE, + STK_BIZ = case when A.STK_BIZ = 260 then 264 + when A.STK_BIZ = 261 then 265 + when A.STK_BIZ = 262 then 268 + when A.STK_BIZ = 263 then 269 + when A.STK_BIZ = 960 then 964 + when A.STK_BIZ = 961 then 965 + when A.STK_BIZ = 962 then 970 + when A.STK_BIZ = 963 then 971 + end, + CHANNELS = A.CHANNELS, + FEE_RATE = A.FEE_RATE, + FEE_MAX = A.FEE_MAX, + FEE_MIN = A.FEE_MIN, + vipa1111111111111 = A.vipa1111111111111, + SYNC_TYPE = A.SYNC_TYPE + from dbo.ITF_STK_COM_SPCFG A where A.STK_BIZ in (260,261,262,263,960,961,962,963)and SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111) t5 order by OBJ_VALUE + + insert into dbo.ITF_STK_COM_SPCFG + (REC_SN, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE) + select REC_SN + 55000000, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE + from #ITF_STK_COM_SPCFG5 + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败2' + return -1 + end + drop table #ITF_STK_COM_SPCFG5 + + end + + + if exists (select * from dbo.ITF_STK_COM_SPCFG where STK_BIZ in (100,101) and SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111) + begin + select REC_SN=identity(int,1,1),t9.* into #ITF_STK_COM_SPCFG120_121 from ( + select + INT_ORG = A.INT_ORG, + OBJ_TYPE = A.OBJ_TYPE, + OBJ_VALUE = A.OBJ_VALUE, + STKBD = A.STKBD, + STK_CLS = A.STK_CLS, + STK_FLAG = A.STK_FLAG, + STK_CODE = A.STK_CODE, + STK_BIZ = case when A.STK_BIZ = 100 then 120 else 121 end, + CHANNELS = A.CHANNELS, + FEE_RATE = A.FEE_RATE, + FEE_MAX = A.FEE_MAX, + FEE_MIN = A.FEE_MIN, + vipa1111111111111 = @p_vipa1111111111111, + SYNC_TYPE = '1' + from dbo.ITF_STK_COM_SPCFG A where A.STK_BIZ in (100,101) and A.SYNC_TYPE = '1' and A.vipa1111111111111 = @p_vipa1111111111111) t9 order by OBJ_VALUE + + insert into dbo.ITF_STK_COM_SPCFG + (REC_SN, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE) + select REC_SN + 60000000, INT_ORG, OBJ_TYPE, OBJ_VALUE, STKBD, + STK_CLS, STK_FLAG, STK_CODE, STK_BIZ, CHANNELS, + FEE_RATE, FEE_MAX, FEE_MIN, vipa1111111111111, SYNC_TYPE + from #ITF_STK_COM_SPCFG120_121 + if @@error != 0 + begin + select errorcode = -1, errormsg = '失败' + return -1 + end + drop table #ITF_STK_COM_SPCFG120_121 + end + + + + if @@error != 0 + begin + select errorcode = -1 , errormsg = '失败' + end + + select errorcode = 0 , errormsg = '成功' + update dbo.itf_sync_tables set prepcnt = (select count(*) from dbo.STK_HS_DETAIL where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111),a333333333333 = '1' + where vipid = @vipid and tablename = @p_tblname and direct = 'e' + + select tablecnt = count(*) from dbo.STK_HS_DETAIL where SYNC_TYPE = '1' and vipa1111111111111 = @p_vipa1111111111111 + end + + else + begin + select errorcode = -1, errormsg = '错误' + return -1 + end + + return 0 +go + +exec nb_add_sysobjects 'P','up_com_test' +go \ No newline at end of file diff --git a/tsql/examples/spatial_comprehensive.sql b/tsql/examples/spatial_comprehensive.sql new file mode 100644 index 0000000..637068e --- /dev/null +++ b/tsql/examples/spatial_comprehensive.sql @@ -0,0 +1,209 @@ +-- Comprehensive Spatial Index Test Cases +-- This file demonstrates all supported spatial index features and edge cases + +-- Table creation with spatial columns for testing +CREATE TABLE [dbo].[SpatialTestTable] ( + [ID] int IDENTITY(1,1) NOT NULL PRIMARY KEY, + [Name] nvarchar(100), + [Location] geometry, + [GlobalPosition] geography, + [BoundaryShape] geometry, + [Region] geography +); + +-- Basic spatial index variations +CREATE SPATIAL INDEX [IX_Location_AutoGrid] ON [dbo].[SpatialTestTable] ([Location]) USING GEOMETRY_AUTO_GRID; +CREATE SPATIAL INDEX [IX_Location_Grid] ON [dbo].[SpatialTestTable] ([Location]) USING GEOMETRY_GRID; +CREATE SPATIAL INDEX [IX_GlobalPos_AutoGrid] ON [dbo].[SpatialTestTable] ([GlobalPosition]) USING GEOGRAPHY_AUTO_GRID; +CREATE SPATIAL INDEX [IX_GlobalPos_Grid] ON [dbo].[SpatialTestTable] ([GlobalPosition]) USING GEOGRAPHY_GRID; + +-- Spatial indexes with bounding box - testing various coordinate ranges +CREATE SPATIAL INDEX [IX_BBox_World] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (BOUNDING_BOX = (-180, -90, 180, 90)); + +CREATE SPATIAL INDEX [IX_BBox_USA] ON [dbo].[SpatialTestTable] ([BoundaryShape]) +USING GEOMETRY_GRID +WITH (BOUNDING_BOX = (-125, 25, -65, 50)); + +CREATE SPATIAL INDEX [IX_BBox_Custom] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (BOUNDING_BOX = (-10.5, -5.25, 15.75, 20.125)); + +-- Spatial indexes with grid level configurations +CREATE SPATIAL INDEX [IX_Grid_SingleLevel] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = HIGH)); + +CREATE SPATIAL INDEX [IX_Grid_TwoLevels] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = MEDIUM)); + +CREATE SPATIAL INDEX [IX_Grid_ThreeLevels] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = LOW)); + +CREATE SPATIAL INDEX [IX_Grid_AllLevels] ON [dbo].[SpatialTestTable] ([BoundaryShape]) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM, LEVEL_4 = LOW)); + +-- Spatial indexes with cells per object variations +CREATE SPATIAL INDEX [IX_Cells_Min] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (CELLS_PER_OBJECT = 1); + +CREATE SPATIAL INDEX [IX_Cells_Default] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (CELLS_PER_OBJECT = 16); + +CREATE SPATIAL INDEX [IX_Cells_High] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (CELLS_PER_OBJECT = 256); + +CREATE SPATIAL INDEX [IX_Cells_Max] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (CELLS_PER_OBJECT = 8192); + +-- Complex spatial indexes combining multiple options +CREATE SPATIAL INDEX [IX_Complex_Geometry] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH ( + BOUNDING_BOX = (0, 0, 1000, 1000), + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM, LEVEL_4 = LOW), + CELLS_PER_OBJECT = 64 +); + +CREATE SPATIAL INDEX [IX_Complex_Geography] ON [dbo].[SpatialTestTable] ([GlobalPosition]) +USING GEOGRAPHY_GRID +WITH ( + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = HIGH, LEVEL_4 = MEDIUM), + CELLS_PER_OBJECT = 128 +); + +-- Spatial indexes with traditional index options +CREATE SPATIAL INDEX [IX_IndexOptions_Basic] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH ( + BOUNDING_BOX = (-100, -100, 100, 100), + PAD_INDEX = ON, + FILLFACTOR = 90 +); + +CREATE SPATIAL INDEX [IX_IndexOptions_Performance] ON [dbo].[SpatialTestTable] ([BoundaryShape]) +USING GEOMETRY_GRID +WITH ( + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = MEDIUM), + CELLS_PER_OBJECT = 32, + PAD_INDEX = OFF, + FILLFACTOR = 80, + SORT_IN_TEMPDB = ON, + IGNORE_DUP_KEY = OFF, + STATISTICS_NORECOMPUTE = OFF +); + +CREATE SPATIAL INDEX [IX_IndexOptions_Advanced] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH ( + BOUNDING_BOX = (-50, -50, 50, 50), + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM, LEVEL_4 = LOW), + CELLS_PER_OBJECT = 64, + PAD_INDEX = ON, + FILLFACTOR = 85, + SORT_IN_TEMPDB = OFF, + IGNORE_DUP_KEY = ON, + STATISTICS_NORECOMPUTE = ON, + STATISTICS_INCREMENTAL = OFF +); + +-- Spatial indexes with file group specifications +CREATE SPATIAL INDEX [IX_FileGroup_Primary] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_AUTO_GRID +ON [PRIMARY]; + +CREATE SPATIAL INDEX [IX_FileGroup_Custom] ON [dbo].[SpatialTestTable] ([GlobalPosition]) +USING GEOGRAPHY_GRID +WITH ( + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = MEDIUM), + CELLS_PER_OBJECT = 32 +) +ON [SPATIAL_DATA]; + +CREATE SPATIAL INDEX [IX_FileGroup_Complex] ON [dbo].[SpatialTestTable] ([BoundaryShape]) +USING GEOMETRY_GRID +WITH ( + BOUNDING_BOX = (0, 0, 1000, 1000), + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM, LEVEL_4 = LOW), + CELLS_PER_OBJECT = 128, + PAD_INDEX = ON, + FILLFACTOR = 90, + SORT_IN_TEMPDB = ON +) +ON [INDEXES]; + +-- Schema-qualified table examples +CREATE SPATIAL INDEX [IX_Schema_Simple] ON [GIS].[Locations] ([Coordinates]) USING GEOGRAPHY_AUTO_GRID; + +CREATE SPATIAL INDEX [IX_Schema_Complex] ON [Mapping].[SpatialData] ([GeometryField]) +USING GEOMETRY_GRID +WITH ( + BOUNDING_BOX = (-1000, -1000, 1000, 1000), + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM), + CELLS_PER_OBJECT = 64, + PAD_INDEX = ON, + FILLFACTOR = 85 +) +ON [GIS_INDEXES]; + +-- Edge cases and variations +CREATE SPATIAL INDEX [IX_Edge_ShortName] ON [T] ([C]) USING GEOMETRY_AUTO_GRID; +CREATE SPATIAL INDEX [IX_Edge_LongTableName] ON [VeryLongDatabaseName].[VeryLongSchemaName].[VeryLongTableNameForTesting] ([SpatialColumn]) USING GEOGRAPHY_AUTO_GRID; + +-- Different grid density combinations +CREATE SPATIAL INDEX [IX_Grid_AllLow] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = LOW, LEVEL_2 = LOW, LEVEL_3 = LOW, LEVEL_4 = LOW)); + +CREATE SPATIAL INDEX [IX_Grid_AllMedium] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = MEDIUM, LEVEL_2 = MEDIUM, LEVEL_3 = MEDIUM, LEVEL_4 = MEDIUM)); + +CREATE SPATIAL INDEX [IX_Grid_AllHigh] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = HIGH, LEVEL_4 = HIGH)); + +CREATE SPATIAL INDEX [IX_Grid_Mixed] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = LOW, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM, LEVEL_4 = HIGH)); + +-- Geography-specific examples with different configurations +CREATE SPATIAL INDEX [IX_Geography_WorldWide] ON [dbo].[SpatialTestTable] ([GlobalPosition]) +USING GEOGRAPHY_GRID +WITH ( + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM, LEVEL_4 = LOW), + CELLS_PER_OBJECT = 512 +); + +CREATE SPATIAL INDEX [IX_Geography_Regional] ON [dbo].[SpatialTestTable] ([Region]) +USING GEOGRAPHY_AUTO_GRID +WITH (CELLS_PER_OBJECT = 64); + +-- Test cases without optional semicolons +CREATE SPATIAL INDEX [IX_NoSemicolon1] ON [dbo].[SpatialTestTable] ([Location]) USING GEOMETRY_AUTO_GRID +CREATE SPATIAL INDEX [IX_NoSemicolon2] ON [dbo].[SpatialTestTable] ([GlobalPosition]) +USING GEOGRAPHY_GRID +WITH (GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = MEDIUM)) + +-- Test cases with optional semicolons +CREATE SPATIAL INDEX [IX_WithSemicolon1] ON [dbo].[SpatialTestTable] ([Location]) USING GEOMETRY_AUTO_GRID; +CREATE SPATIAL INDEX [IX_WithSemicolon2] ON [dbo].[SpatialTestTable] ([GlobalPosition]) +USING GEOGRAPHY_GRID +WITH (GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = MEDIUM)); + +-- Multiple spatial indexes on the same column with different configurations +CREATE SPATIAL INDEX [IX_Multi_Config1] ON [dbo].[SpatialTestTable] ([Location]) USING GEOMETRY_AUTO_GRID; +CREATE SPATIAL INDEX [IX_Multi_Config2] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (BOUNDING_BOX = (0, 0, 100, 100)); +CREATE SPATIAL INDEX [IX_Multi_Config3] ON [dbo].[SpatialTestTable] ([Location]) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = MEDIUM), CELLS_PER_OBJECT = 32); \ No newline at end of file diff --git a/tsql/examples/spatial_index.sql b/tsql/examples/spatial_index.sql new file mode 100644 index 0000000..87b5093 --- /dev/null +++ b/tsql/examples/spatial_index.sql @@ -0,0 +1,194 @@ +-- Spatial Index Examples for TSQL Parser +-- Testing all variations of CREATE SPATIAL INDEX statements + +-- Basic CREATE SPATIAL INDEX statements +CREATE SPATIAL INDEX IX_SpatialBasic_1 ON SpatialTable (GeometryColumn) USING GEOMETRY_AUTO_GRID; +CREATE SPATIAL INDEX IX_SpatialBasic_2 ON SpatialTable (GeometryColumn) USING GEOMETRY_GRID; +CREATE SPATIAL INDEX IX_SpatialBasic_3 ON SpatialTable (GeographyColumn) USING GEOGRAPHY_AUTO_GRID; +CREATE SPATIAL INDEX IX_SpatialBasic_4 ON SpatialTable (GeographyColumn) USING GEOGRAPHY_GRID; + +-- Spatial indexes with schema-qualified table names +CREATE SPATIAL INDEX IX_SchemaQualified_1 ON dbo.SpatialTable (LocationColumn) USING GEOMETRY_AUTO_GRID; +CREATE SPATIAL INDEX IX_SchemaQualified_2 ON [Sales].[LocationData] ([GeoPoint]) USING GEOGRAPHY_AUTO_GRID; +CREATE SPATIAL INDEX IX_SchemaQualified_3 ON MyDatabase.dbo.SpatialTable (SpatialColumn) USING GEOMETRY_GRID; + +-- Spatial indexes with bounding box (supporting negative coordinates) +CREATE SPATIAL INDEX IX_BoundingBox_1 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (BOUNDING_BOX = (0, 0, 100, 100)); + +CREATE SPATIAL INDEX IX_BoundingBox_2 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (BOUNDING_BOX = (-180, -90, 180, 90)); + +CREATE SPATIAL INDEX IX_BoundingBox_3 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (BOUNDING_BOX = (-123.456, -78.901, 234.567, 89.012)); + +-- Spatial indexes with grid level specifications +CREATE SPATIAL INDEX IX_GridLevels_1 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = LOW)); + +CREATE SPATIAL INDEX IX_GridLevels_2 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = MEDIUM)); + +CREATE SPATIAL INDEX IX_GridLevels_3 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM)); + +CREATE SPATIAL INDEX IX_GridLevels_4 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM, LEVEL_4 = LOW)); + +-- Spatial indexes with cells per object +CREATE SPATIAL INDEX IX_CellsPerObject_1 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (CELLS_PER_OBJECT = 1); + +CREATE SPATIAL INDEX IX_CellsPerObject_2 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (CELLS_PER_OBJECT = 16); + +CREATE SPATIAL INDEX IX_CellsPerObject_3 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (CELLS_PER_OBJECT = 8192); + +-- Spatial indexes with multiple options +CREATE SPATIAL INDEX IX_MultipleOptions_1 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH ( + BOUNDING_BOX = (0, 0, 1000, 1000), + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = MEDIUM), + CELLS_PER_OBJECT = 32 +); + +CREATE SPATIAL INDEX IX_MultipleOptions_2 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH ( + BOUNDING_BOX = (-50.5, -25.25, 50.5, 25.25), + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM, LEVEL_4 = LOW), + CELLS_PER_OBJECT = 64 +); + +-- Spatial indexes with traditional index options +CREATE SPATIAL INDEX IX_TraditionalOptions_1 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH ( + BOUNDING_BOX = (0, 0, 100, 100), + PAD_INDEX = ON, + FILLFACTOR = 90 +); + +CREATE SPATIAL INDEX IX_TraditionalOptions_2 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH ( + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = MEDIUM), + SORT_IN_TEMPDB = ON, + IGNORE_DUP_KEY = OFF, + STATISTICS_NORECOMPUTE = OFF +); + +CREATE SPATIAL INDEX IX_TraditionalOptions_3 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH ( + CELLS_PER_OBJECT = 16, + PAD_INDEX = OFF, + FILLFACTOR = 80, + SORT_IN_TEMPDB = OFF, + IGNORE_DUP_KEY = ON, + STATISTICS_NORECOMPUTE = ON, + STATISTICS_INCREMENTAL = OFF +); + +-- Spatial indexes with file group specification +CREATE SPATIAL INDEX IX_FileGroup_1 ON SpatialTable (GeometryColumn) +USING GEOMETRY_AUTO_GRID +ON [PRIMARY]; + +CREATE SPATIAL INDEX IX_FileGroup_2 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (BOUNDING_BOX = (0, 0, 100, 100)) +ON [SPATIAL_DATA]; + +CREATE SPATIAL INDEX IX_FileGroup_3 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH ( + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = MEDIUM), + CELLS_PER_OBJECT = 32, + PAD_INDEX = ON +) +ON [INDEXES]; + +-- Complex spatial indexes combining all features +CREATE SPATIAL INDEX IX_Complex_1 ON dbo.SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH ( + BOUNDING_BOX = (-180, -90, 180, 90), + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM, LEVEL_4 = LOW), + CELLS_PER_OBJECT = 64, + PAD_INDEX = ON, + FILLFACTOR = 85, + SORT_IN_TEMPDB = ON, + IGNORE_DUP_KEY = OFF, + STATISTICS_NORECOMPUTE = OFF +) +ON [SPATIAL_INDEXES]; + +CREATE SPATIAL INDEX IX_Complex_2 ON [GIS].[LocationData] ([Coordinates]) +USING GEOGRAPHY_GRID +WITH ( + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = HIGH, LEVEL_4 = MEDIUM), + CELLS_PER_OBJECT = 128, + PAD_INDEX = OFF, + FILLFACTOR = 95, + SORT_IN_TEMPDB = OFF +) +ON [GEO_DATA]; + +-- Spatial indexes without semicolon terminator +CREATE SPATIAL INDEX IX_NoSemicolon_1 ON SpatialTable (GeometryColumn) USING GEOMETRY_AUTO_GRID +CREATE SPATIAL INDEX IX_NoSemicolon_2 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (BOUNDING_BOX = (0, 0, 100, 100)) + +-- Spatial indexes with optional semicolon +CREATE SPATIAL INDEX IX_OptionalSemicolon_1 ON SpatialTable (GeometryColumn) USING GEOMETRY_AUTO_GRID; +CREATE SPATIAL INDEX IX_OptionalSemicolon_2 ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (BOUNDING_BOX = (0, 0, 100, 100)); + +-- Geography-specific spatial indexes +CREATE SPATIAL INDEX IX_Geography_1 ON GlobalData (LocationColumn) USING GEOGRAPHY_AUTO_GRID; +CREATE SPATIAL INDEX IX_Geography_2 ON GlobalData (LocationColumn) +USING GEOGRAPHY_GRID +WITH (GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = MEDIUM, LEVEL_3 = LOW)); + +CREATE SPATIAL INDEX IX_Geography_3 ON GlobalData (LocationColumn) +USING GEOGRAPHY_GRID +WITH ( + GRIDS = (LEVEL_1 = HIGH, LEVEL_2 = HIGH, LEVEL_3 = MEDIUM, LEVEL_4 = LOW), + CELLS_PER_OBJECT = 256 +); + +-- Edge cases and variations +CREATE SPATIAL INDEX IX_EdgeCase_1 ON T (C) USING GEOMETRY_AUTO_GRID; +CREATE SPATIAL INDEX [IX_Brackets] ON [Table] ([Column]) USING GEOMETRY_GRID; +CREATE SPATIAL INDEX IX_MinCells ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (CELLS_PER_OBJECT = 1); + +CREATE SPATIAL INDEX IX_MaxCells ON SpatialTable (GeometryColumn) +USING GEOMETRY_GRID +WITH (CELLS_PER_OBJECT = 8192); + +-- Spatial indexes with simple column references only +-- Note: Computed columns/expressions are not supported in spatial index column specifications + +-- Multiple spatial indexes on same table +CREATE SPATIAL INDEX IX_Multi_1 ON SpatialTable (GeometryColumn) USING GEOMETRY_AUTO_GRID; +CREATE SPATIAL INDEX IX_Multi_2 ON SpatialTable (GeographyColumn) USING GEOGRAPHY_AUTO_GRID; +CREATE SPATIAL INDEX IX_Multi_3 ON SpatialTable (AnotherGeometryColumn) +USING GEOMETRY_GRID +WITH (BOUNDING_BOX = (0, 0, 1000, 1000)); \ No newline at end of file diff --git a/tsql/examples/splitfunction.sql b/tsql/examples/splitfunction.sql new file mode 100644 index 0000000..9d2e9f6 --- /dev/null +++ b/tsql/examples/splitfunction.sql @@ -0,0 +1,7 @@ +SELECT SPLIT.A.VALUE('.', 'INT') AS SPLV +FROM + (SELECT + CAST('' + REPLACE('1,2,3', ',', '') + '' AS XML) AS DTA + ) AS A + CROSS APPLY + DTA.NODES ('/SPL') AS SPLIT(A) \ No newline at end of file diff --git a/tsql/examples/statements.sql b/tsql/examples/statements.sql new file mode 100644 index 0000000..c4a2866 --- /dev/null +++ b/tsql/examples/statements.sql @@ -0,0 +1,581 @@ +----------------------------------------------------------------------- +-- GRANT https://msdn.microsoft.com/en-us/library/ms187965.aspx + +-- GRANT ALL +GRANT ALL TO pax_writer; + +-- Execute the following as a database owner +GRANT EXECUTE ON TestProc TO TesterRole WITH GRANT OPTION; +EXEC sp_addrolemember TesterRole, User1; +-- Execute the following as User1 +-- The following fails because User1 does not have the permission as the User1 +GRANT EXECUTE ON TestMe TO User2; +-- The following succeeds because User1 invokes the TesterRole membership +GRANT EXECUTE ON TestMe TO User2 AS TesterRole; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Asymmetric Key Permissions + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Availability Group Permissions + +-- Granting VIEW DEFINITION permission on an availability group +-- USE master; +-- GRANT VIEW DEFINITION ON AVAILABILITY GROUP::MyAg TO ZArifin; +-- GO + +-- Granting TAKE OWNERSHIP permission with the GRANT OPTION +-- USE master; +-- GRANT TAKE OWNERSHIP ON AVAILABILITY GROUP::MyAg TO PKomosinski + -- WITH GRANT OPTION; +-- GO + +-- Granting CONTROL permission on an availability group +-- USE master; +-- GRANT CONTROL ON AVAILABILITY GROUP::MyAg TO PKomosinski; +-- GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Certificate Permissions https://msdn.microsoft.com/en-us/library/ms186278.aspx + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Database Permissions https://msdn.microsoft.com/en-us/library/ms178569.aspx + +-- Granting permission to create tables +USE AdventureWorks; +GRANT CREATE TABLE TO MelanieK; +GO + +-- Granting SHOWPLAN permission to an application role +USE AdventureWorks2012; +GRANT SHOWPLAN TO AuditMonitor; +GO + +-- Granting CREATE VIEW with GRANT OPTION +USE AdventureWorks2012; +GRANT CREATE VIEW TO CarmineEs WITH GRANT OPTION; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Database Principal Permissions https://msdn.microsoft.com/en-us/library/ms173848.aspx + +-- Granting CONTROL permission on a user to another user +-- USE AdventureWorks2012; +-- GRANT CONTROL ON USER::Wanida TO RolandX; +-- GO + +-- Granting VIEW DEFINITION permission on a role to a user with GRANT OPTION +-- USE AdventureWorks2012; +-- GRANT VIEW DEFINITION ON ROLE::SammamishParking + -- TO JinghaoLiu WITH GRANT OPTION; +-- GO + +-- Granting IMPERSONATE permission on a user to an application role +-- USE AdventureWorks2012; +-- GRANT IMPERSONATE ON USER::HamithaL TO AccountsPayable17; +-- GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Endpoint Permissions https://msdn.microsoft.com/en-us/library/ms187811.aspx + +-- Granting VIEW DEFINITION permission on an endpoint +-- USE master; +-- GRANT VIEW DEFINITION ON ENDPOINT::Mirror7 TO ZArifin; +-- GO + +-- Granting TAKE OWNERSHIP permission with the GRANT OPTION +-- USE master; +-- GRANT TAKE OWNERSHIP ON ENDPOINT::Shipping83 TO PKomosinski + -- WITH GRANT OPTION; +-- GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Full-Text Permissions https://msdn.microsoft.com/en-us/library/ms190502.aspx + +-- Granting permissions to a full-text catalog +-- GRANT CONTROL + -- ON FULLTEXT CATALOG :: ProductCatalog + -- TO Ted ; + +-- Granting permissions to a stoplist +-- GRANT VIEW DEFINITION + -- ON FULLTEXT STOPLIST :: ProductStoplist + -- TO Mary ; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Object Permissions https://msdn.microsoft.com/en-us/library/ms188371.aspx + +-- Granting SELECT permission on a table +-- USE AdventureWorks2012; +-- GRANT SELECT ON OBJECT::Person.Address TO RosaQdM; +-- GO + +-- Granting EXECUTE permission on a stored procedure +-- USE AdventureWorks2012; +-- GRANT EXECUTE ON OBJECT::HumanResources.uspUpdateEmployeeHireInfo + -- TO Recruiting11; +-- GO + +-- Granting REFERENCES permission on a view with GRANT OPTION +-- USE AdventureWorks2012; +-- GRANT REFERENCES (BusinessEntityID) ON OBJECT::HumanResources.vEmployee + -- TO Wanida WITH GRANT OPTION; +-- GO + +-- Granting SELECT permission on a table without using the OBJECT phrase +USE AdventureWorks2012; +GRANT SELECT ON Person.Address TO RosaQdM; +GO + +-- Granting SELECT permission on a table to a domain account +USE AdventureWorks2012; +GRANT SELECT ON Person.Address TO [AdventureWorks2012\RosaQdM]; +GO + +-- Granting EXECUTE permission on a procedure to a role +USE AdventureWorks2012; +--CREATE ROLE newrole ; +GRANT EXECUTE ON dbo.uspGetBillOfMaterials TO newrole ; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Schema Permissions https://msdn.microsoft.com/en-us/library/ms187940.aspx + +-- Granting INSERT permission on schema HumanResources to guest +-- GRANT INSERT ON SCHEMA :: HumanResources TO guest; + +-- Granting SELECT permission on schema Person to database user WilJo +-- GRANT SELECT ON SCHEMA :: Person TO WilJo WITH GRANT OPTION; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Search Property List Permissions + +-- GRANT VIEW DEFINITION + -- ON SEARCH PROPERTY LIST :: DocumentTablePropertyList + -- TO Mary ; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Server Permissions https://msdn.microsoft.com/en-us/library/ms186717.aspx + +-- Granting a permission to a login +USE master; +GRANT CONTROL SERVER TO TerryEminhizer; +GO + +-- Granting a permission that has GRANT permission +-- USE master; +-- GRANT ALTER ANY EVENT NOTIFICATION TO JanethEsteves WITH GRANT OPTION; +-- GO + +-- Granting a permission to a server role +USE master; +--CREATE SERVER ROLE ITDevAdmin ; +--CREATE SERVER ROLE ITDevelopers ; +GRANT ALTER ANY DATABASE TO ITDevAdmin WITH GRANT OPTION ; +GRANT ALTER ANY DATABASE TO ITDevelopers AS ITDevAdmin ; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Server Principal Permissions https://msdn.microsoft.com/en-us/library/ms178640.aspx + +-- Granting IMPERSONATE permission on a login +-- USE master; +-- GRANT IMPERSONATE ON LOGIN::WanidaBenshoof to [AdvWorks\YoonM]; +-- GO + +-- Granting IMPERSONATE permission on a login +-- Granting VIEW DEFINITION permission with GRANT OPTION +-- USE master; +-- GRANT VIEW DEFINITION ON LOGIN::EricKurjan TO RMeyyappan + -- WITH GRANT OPTION; +-- GO + +-- Granting VIEW DEFINITION permission on a server role +-- USE master; +-- GRANT VIEW DEFINITION ON SERVER ROLE::Sales TO Auditors ; +-- GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Service Broker Permissions https://msdn.microsoft.com/en-us/library/ms188798.aspx + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Symmetric Key Permissions https://msdn.microsoft.com/en-us/library/ms179887.aspx + +-- USE AdventureWorks2012; +-- GRANT ALTER ON SYMMETRIC KEY::SamInventory42 TO HamidS; +-- GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT System Object Permissions https://msdn.microsoft.com/en-us/library/ms187797.aspx +-- GRANT { SELECT | EXECUTE } ON [ sys.]system_object TO principal + +-- Granting SELECT permission on a view +USE AdventureWorks2012; +GRANT SELECT ON sys.sql_logins TO Sylvester1; +--GRANT VIEW SERVER STATE to Sylvester1; +GO + +-- Granting EXECUTE permission on an extended stored procedure +GRANT EXECUTE ON xp_readmail TO Sylvester1; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT Type Permissions https://msdn.microsoft.com/en-us/library/ms174346.aspx + +-- GRANT VIEW DEFINITION ON TYPE::Telemarketing.PhoneNumber + -- TO KhalidR WITH GRANT OPTION; +-- GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- GRANT XML Schema Collection Permissions https://msdn.microsoft.com/en-us/library/ms179867.aspx +-- USE AdventureWorks2012; +-- GRANT EXECUTE ON XML SCHEMA COLLECTION::Sales.Invoices4 TO Wanida; +-- GO + +--Test if the security_statement can accept Public as target +--Also tests if it can accepts multiple targets +--ref: https://msdn.microsoft.com/en-us/library/ms187965.aspx +GRANT EXECUTE ON [dbo].[closeLead] to Public,XYZPublic + +--Test empty statements +;;; + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Declare XML Schema (https://docs.microsoft.com/en-us/sql/relational-databases/xml/create-xml-data-type-variables-and-columns) +DECLARE @x xml (Sales.StoreSurveySchemaCollection) + +-- Decrypts a symmetric key and makes it available for use +OPEN SYMMETRIC KEY SomeKeyName DECRYPTION +BY CERTIFICATE SomeCertificateName; +GO; + +-- Closing a symmetric key +CLOSE SYMMETRIC KEY SomeKeyName; +GO; + +-- Closing all symmetric keys +CLOSE ALL SYMMETRIC KEYS; +GO + +-- Conversation timer +BEGIN CONVERSATION TIMER (@dialog_handle) +TIMEOUT = 120; +GO; + +-- Beginning a conversation dialog +DECLARE @dialog_handle UNIQUEIDENTIFIER; +BEGIN DIALOG CONVERSATION @dialog_handle + FROM SERVICE [//Adventure-Works.com/ExpenseClient] + TO SERVICE '//Adventure-Works.com/Expenses' + ON CONTRACT [//Adventure-Works.com/Expenses/ExpenseSubmission]; +GO; + +-- Begin a dialog with an explicit lifetime +DECLARE @dialog_handle UNIQUEIDENTIFIER; +BEGIN DIALOG CONVERSATION @dialog_handle + FROM SERVICE [//Adventure-Works.com/ExpenseClient] + TO SERVICE '//Adventure-Works.com/Expenses' + ON CONTRACT [//Adventure-Works.com/Expenses/ExpenseSubmission] + WITH LIFETIME = 60; +GO; + +-- Begin a dialog with a specific broker instance +DECLARE @dialog_handle UNIQUEIDENTIFIER; +BEGIN DIALOG CONVERSATION @dialog_handle + FROM SERVICE [//Adventure-Works.com/ExpenseClient] + TO SERVICE '//Adventure-Works.com/Expenses', + 'a326e034-d4cf-4e8b-8d98-4d7e1926c904' + ON CONTRACT [//Adventure-Works.com/Expenses/ExpenseSubmission]; +GO; + +-- Begin a dialog, and relating it to an existing conversation group +DECLARE @dialog_handle UNIQUEIDENTIFIER; +DECLARE @conversation_group_id UNIQUEIDENTIFIER; +BEGIN DIALOG CONVERSATION @dialog_handle + FROM SERVICE [//Adventure-Works.com/ExpenseClient] + TO SERVICE '//Adventure-Works.com/Expenses' + ON CONTRACT [//Adventure-Works.com/Expenses/ExpenseSubmission] + WITH RELATED_CONVERSATION_GROUP = @conversation_group_id; +GO; + +-- Begin a dialog with an explicit lifetime, and relating the dialog to an existing conversation +DECLARE @dialog_handle UNIQUEIDENTIFIER +DECLARE @existing_conversation_handle UNIQUEIDENTIFIER +BEGIN DIALOG CONVERSATION @dialog_handle + FROM SERVICE [//Adventure-Works.com/ExpenseClient] + TO SERVICE '//Adventure-Works.com/Expenses' + ON CONTRACT [//Adventure-Works.com/Expenses/ExpenseSubmission] + WITH RELATED_CONVERSATION = @existing_conversation_handle + LIFETIME = 600; +GO; + +-- Begin a dialog with optional encryption +DECLARE @dialog_handle UNIQUEIDENTIFIER +BEGIN DIALOG CONVERSATION @dialog_handle + FROM SERVICE [//Adventure-Works.com/ExpenseClient] + TO SERVICE '//Adventure-Works.com/Expenses' + ON CONTRACT [//Adventure-Works.com/Expenses/ExpenseSubmission] + WITH ENCRYPTION = OFF; +GO; + +-- Ending a conversation +END CONVERSATION @dialog_handle; +GO; + +-- Ending a conversation with an error +DECLARE @dialog_handle UNIQUEIDENTIFIER, + @ErrorSave INT, + @ErrorDesc NVARCHAR(100) ; +BEGIN TRANSACTION ; +SET @ErrorSave = @@ERROR ; + +IF (@ErrorSave <> 0) + BEGIN + ROLLBACK TRANSACTION ; + SET @ErrorDesc = N'An error has occurred.' ; + END CONVERSATION @dialog_handle + WITH ERROR = @ErrorSave DESCRIPTION = @ErrorDesc ; + END +ELSE + +COMMIT TRANSACTION ; +GO; + +-- Cleaning up a conversation that cannot complete normally +END CONVERSATION @dialog_handle WITH CLEANUP; +GO; + +-- Getting a conversation group, waiting indefinitely +DECLARE @conversation_group_id UNIQUEIDENTIFIER ; +WAITFOR ( + GET CONVERSATION GROUP @conversation_group_id + FROM ExpenseQueue +); +GO; + +-- Getting a conversation group, waiting one minute +DECLARE @conversation_group_id UNIQUEIDENTIFIER +WAITFOR ( + GET CONVERSATION GROUP @conversation_group_id + FROM ExpenseQueue ), +TIMEOUT 60000 ; +GO; + +-- Getting a conversation group, returning immediately +DECLARE @conversation_group_id UNIQUEIDENTIFIER; +GET CONVERSATION GROUP @conversation_group_id +FROM AdventureWorks.dbo.ExpenseQueue; +GO; + +-- Starts a dialog and sends an XML message on the dialog +DECLARE @dialog_handle UNIQUEIDENTIFIER, + @ExpenseReport XML; + +SET @ExpenseReport = ''; + +BEGIN DIALOG @dialog_handle +FROM SERVICE [//Adventure-Works.com/Expenses/ExpenseClient] +TO SERVICE '//Adventure-Works.com/Expenses' +ON CONTRACT [//Adventure-Works.com/Expenses/ExpenseProcessing] ; + +SEND ON CONVERSATION @dialog_handle + MESSAGE TYPE [//Adventure-Works.com/Expenses/SubmitExpense] + (@ExpenseReport) ; +GO; + +-- Starts a dialog and sends an XML message on the dialog using local vars without message body +DECLARE @dialog_handle UNIQUEIDENTIFIER, + @ExpenseReport XML; + +SET @ExpenseReport = ''; + +BEGIN DIALOG @dialog_handle +FROM SERVICE @from_service +TO SERVICE @to_service +ON CONTRACT @contract; + +SEND ON CONVERSATION @dialog_handle + MESSAGE TYPE @MessageType +GO; + +-- Create Master Key +CREATE MASTER KEY ENCRYPTION BY PASSWORD = 'password'; +GO; + +-- Open Master Key +OPEN MASTER KEY DECRYPTION BY PASSWORD = 'password'; +GO; + +-- Close Master Key +CLOSE MASTER KEY; +GO; + +-- Creating a self-signed certificate +USE AdventureWorks2012; +CREATE CERTIFICATE Shipping04 + ENCRYPTION BY PASSWORD = 'pGFD4bb925DGvbd2439587y' + WITH SUBJECT = 'Sammamish Shipping Records', + EXPIRY_DATE = '20201031'; +GO; + +-- Creating a certificate from a file +USE AdventureWorks2012; +CREATE CERTIFICATE Shipping11 + FROM FILE = 'c:\Shipping\Certs\Shipping11.cer' + WITH PRIVATE KEY (FILE = 'c:\Shipping\Certs\Shipping11.pvk', + DECRYPTION BY PASSWORD = 'sldkflk34et6gs%53#v00'); +GO; + +-- Creating a certificate from a signed executable file +USE AdventureWorks2012; +CREATE CERTIFICATE Shipping19 + FROM EXECUTABLE FILE = 'c:\Shipping\Certs\Shipping19.dll'; +GO; + +-- Creating a symmetric key +CREATE SYMMETRIC KEY JanainaKey09 +WITH ALGORITHM = AES_256 +ENCRYPTION BY CERTIFICATE Shipping04; +GO; + +-- Creating a temporary symmetric key +CREATE SYMMETRIC KEY #MarketingXXV +WITH ALGORITHM = AES_128, +KEY_SOURCE + = 'The square of the hypotenuse is equal to the sum of the squares of the sides', +IDENTITY_VALUE = 'Pythagoras' +ENCRYPTION BY CERTIFICATE Marketing25; +GO; + +-- Creating a symmetric key using an Extensible Key Management (EKM) device +CREATE SYMMETRIC KEY MySymKey +AUTHORIZATION User1 +FROM PROVIDER EKMProvider +WITH +PROVIDER_KEY_NAME='KeyForSensitiveData', +CREATION_DISPOSITION=OPEN_EXISTING; +GO; + +-- Creating a message type for an empty message +CREATE MESSAGE TYPE + [//Adventure-Works.com/Expenses/SubmitExpense] + VALIDATION = EMPTY; +GO; + +-- Creating a message type containing binary data +CREATE MESSAGE TYPE + [//Adventure-Works.com/Expenses/ReceiptImage] + VALIDATION = NONE; +GO; + +-- Create Contract +CREATE MESSAGE TYPE + [//Adventure-Works.com/Expenses/SubmitExpense] + VALIDATION = WELL_FORMED_XML ; + +CREATE MESSAGE TYPE + [//Adventure-Works.com/Expenses/ExpenseApprovedOrDenied] + VALIDATION = WELL_FORMED_XML ; + +CREATE MESSAGE TYPE + [//Adventure-Works.com/Expenses/ExpenseReimbursed] + VALIDATION= WELL_FORMED_XML ; + +CREATE CONTRACT + [//Adventure-Works.com/Expenses/ExpenseSubmission] + ( [//Adventure-Works.com/Expenses/SubmitExpense] + SENT BY INITIATOR, + [//Adventure-Works.com/Expenses/ExpenseApprovedOrDenied] + SENT BY TARGET, + [//Adventure-Works.com/Expenses/ExpenseReimbursed] + SENT BY TARGET + ) ; +GO; + +-- Creating a queue with no parameters +CREATE QUEUE ExpenseQueue ; +GO; + +-- Creating an unavailable queue +CREATE QUEUE ExpenseQueue WITH STATUS=OFF ; +GO; + +-- Creating a queue and specify internal activation information +CREATE QUEUE ExpenseQueue + WITH STATUS=ON, + ACTIVATION ( + PROCEDURE_NAME = expense_procedure, + MAX_QUEUE_READERS = 5, + EXECUTE AS 'ExpenseUser' ) ; +GO; + +-- Creating a queue on a specific filegroup +CREATE QUEUE ExpenseQueue + ON ExpenseWorkFileGroup ; +GO; + +-- Creating a queue with multiple parameters +CREATE QUEUE ExpenseQueue + WITH STATUS = OFF, + RETENTION = ON, + ACTIVATION ( + PROCEDURE_NAME = AdventureWorks2012.dbo.expense_procedure, + MAX_QUEUE_READERS = 10, + EXECUTE AS SELF ) + ON [DEFAULT] ; +GO; + +-- Making a queue unavailable +ALTER QUEUE ExpenseQueue WITH STATUS = OFF ; +GO; + +-- Changing the activation stored procedure +ALTER QUEUE ExpenseQueue + WITH ACTIVATION ( + PROCEDURE_NAME = new_stored_proc, + EXECUTE AS SELF) ; +GO; + +-- Changing the number of queue readers +ALTER QUEUE ExpenseQueue WITH ACTIVATION (MAX_QUEUE_READERS = 7) ; +GO; + +-- Changing the activation stored procedure and the EXECUTE AS account +ALTER QUEUE ExpenseQueue + WITH ACTIVATION ( + PROCEDURE_NAME = AdventureWorks2012.dbo.new_stored_proc , + EXECUTE AS 'SecurityAccount') ; +GO; + +-- Setting the queue to retain messages +ALTER QUEUE ExpenseQueue WITH RETENTION = ON ; +GO; + +-- Removing activation from a queue +ALTER QUEUE ExpenseQueue WITH ACTIVATION (DROP) ; +GO; + +-- Rebuilding queue indexes +ALTER QUEUE ExpenseQueue REBUILD WITH (MAXDOP = 2) +GO; + +-- Reorganizing queue indexes +ALTER QUEUE ExpenseQueue REORGANIZE +GO; + +-- Moving queue internal table to another filegroup +ALTER QUEUE ExpenseQueue MOVE TO [NewFilegroup] +GO; + +DECLARE @var AS dbo.tableType +GO + +--Execute statement +EXECUTE ( 'Operation', @var OUTPUT) AT linkedServerName +GO + +exec('selectSELECT * FROM ' + @SCHEMA + '.' + @TABLE + ' where ID = ' + @ID) +GO + +EXEC(@sql + @where) +GO diff --git a/tsql/examples/stoplist.sql b/tsql/examples/stoplist.sql new file mode 100644 index 0000000..95c0de5 --- /dev/null +++ b/tsql/examples/stoplist.sql @@ -0,0 +1,8 @@ +ALTER FULLTEXT STOPLIST CombinedFunctionWordList ADD 'en' LANGUAGE 'Spanish'; +ALTER FULLTEXT STOPLIST CombinedFunctionWordList ADD 'en' LANGUAGE 'French'; +CREATE FULLTEXT STOPLIST myStoplist; +GO +CREATE FULLTEXT STOPLIST myStoplist2 FROM AdventureWorks.otherStoplist; +GO +CREATE FULLTEXT STOPLIST myStoplist3 FROM SYSTEM STOPLIST; +GO diff --git a/tsql/examples/string_agg.sql b/tsql/examples/string_agg.sql new file mode 100644 index 0000000..ebe67ea --- /dev/null +++ b/tsql/examples/string_agg.sql @@ -0,0 +1,6 @@ +SELECT + ETLTYPE, + STRING_AGG(ETLNAME, ',') WITHIN GROUP (ORDER BY TABLENAME) AS NAMES +FROM CONFIG.ETL +GROUP BY + ETLTYPE \ No newline at end of file diff --git a/tsql/examples/symmetric_keys.sql b/tsql/examples/symmetric_keys.sql new file mode 100644 index 0000000..03e6a96 --- /dev/null +++ b/tsql/examples/symmetric_keys.sql @@ -0,0 +1,23 @@ +ALTER SYMMETRIC KEY JanainaKey043 + ADD ENCRYPTION BY PASSWORD = ''; +-- Now remove encryption by the certificate. +ALTER SYMMETRIC KEY JanainaKey043 + DROP ENCRYPTION BY CERTIFICATE Shipping04; +CREATE SYMMETRIC KEY JanainaKey09 +WITH ALGORITHM = AES_256 +ENCRYPTION BY CERTIFICATE Shipping04; +GO +CREATE SYMMETRIC KEY #MarketingXXV +WITH ALGORITHM = AES_128, +KEY_SOURCE + = 'The square of the hypotenuse is equal to the sum of the squares of the sides', +IDENTITY_VALUE = 'Pythagoras' +ENCRYPTION BY CERTIFICATE Marketing25; +GO +CREATE SYMMETRIC KEY MySymKey +AUTHORIZATION User1 +FROM PROVIDER EKMProvider +WITH +PROVIDER_KEY_NAME='KeyForSensitiveData', +CREATION_DISPOSITION=OPEN_EXISTING; +GO diff --git a/tsql/examples/synonym.sql b/tsql/examples/synonym.sql new file mode 100644 index 0000000..7dbc2df --- /dev/null +++ b/tsql/examples/synonym.sql @@ -0,0 +1,8 @@ +CREATE SYNONYM MyProduct +FOR AdventureWorks2012.Production.Product; +GO +CREATE SYNONYM MyEmployee FOR Server_Remote.AdventureWorks2012.HumanResources.Employee; +GO +CREATE SYNONYM dbo.CorrectOrder +FOR dbo.OrderDozen; +GO diff --git a/tsql/examples/temporary_tables.sql b/tsql/examples/temporary_tables.sql new file mode 100644 index 0000000..0f89acd --- /dev/null +++ b/tsql/examples/temporary_tables.sql @@ -0,0 +1,25 @@ +-- Global temporary tables +CREATE PROCEDURE createMyGlobalTables AS + CREATE TABLE ##globalTemporary1 + (id INT DEFAULT 0); + CREATE TABLE ##globalTemporary2 + (name VARCHAR(300) DEFAULT 'John'); + SELECT * FROM ##globalTemporary1; + SELECT * FROM ##globalTemporary2; + DROP TABLE ##globalTemporary1; + DROP TABLE ##globalTemporary2; + +GO +-- Local temporary tables +CREATE PROCEDURE createMyLocalTables AS + CREATE table #Color( + Color varchar(10) PRIMARY key) + INSERT INTO #color SELECT 'Red' UNION SELECT 'White' + UNION SELECT 'green'UNION SELECT'Yellow'UNION SELECT'blue' + DROP TABLE #color + go + CREATE table #Color( + Color varchar(10) PRIMARY key) + INSERT INTO #color SELECT 'Red' UNION SELECT 'White' + UNION SELECT 'green'UNION SELECT'Yellow'UNION SELECT'blue' + DROP TABLE #color diff --git a/tsql/examples/test_alias_add.sql b/tsql/examples/test_alias_add.sql new file mode 100644 index 0000000..4138a6c --- /dev/null +++ b/tsql/examples/test_alias_add.sql @@ -0,0 +1 @@ +SELECT COL ADD FROM DBO.TBL; \ No newline at end of file diff --git a/tsql/examples/transactions.sql b/tsql/examples/transactions.sql new file mode 100644 index 0000000..0ae4382 --- /dev/null +++ b/tsql/examples/transactions.sql @@ -0,0 +1,254 @@ +----------------------------------------------------------------------- +-- BEGIN DISTRIBUTED TRANSACTION https://msdn.microsoft.com/en-us/library/ms188386.aspx +-- BEGIN DISTRIBUTED { TRAN | TRANSACTION } + -- [ transaction_name | @tran_name_variable ] +-- [ ; ] + +USE AdventureWorks2012; +GO +BEGIN DISTRIBUTED TRANSACTION; +-- Delete candidate from local instance. +DELETE AdventureWorks2012.HumanResources.JobCandidate + WHERE JobCandidateID = 13; +-- Delete candidate from remote instance. +DELETE RemoteServer.AdventureWorks2012.HumanResources.JobCandidate + WHERE JobCandidateID = 13; +COMMIT TRANSACTION; +GO + +----------------------------------------------------------------------- +-- BEGIN TRANSACTION https://msdn.microsoft.com/en-us/library/ms188929.aspx +-- BEGIN { TRAN | TRANSACTION } + -- [ { transaction_name | @tran_name_variable } + -- [ WITH MARK [ 'description' ] ] + -- ] +-- [ ; ] + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Naming a transaction + +DECLARE @TranName VARCHAR(20); +SELECT @TranName = 'MyTransaction'; + +BEGIN TRANSACTION @TranName; +USE AdventureWorks2012; +DELETE FROM AdventureWorks2012.HumanResources.JobCandidate + WHERE JobCandidateID = 13; + +COMMIT TRANSACTION @TranName; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Marking a transaction + +BEGIN TRANSACTION CandidateDelete + WITH MARK N'Deleting a Job Candidate'; +GO +USE AdventureWorks2012; +GO +DELETE FROM AdventureWorks2012.HumanResources.JobCandidate + WHERE JobCandidateID = 13; +GO +COMMIT TRANSACTION CandidateDelete; +GO + +----------------------------------------------------------------------- +-- COMMIT TRANSACTION https://msdn.microsoft.com/en-us/library/ms190295.aspx +-- COMMIT [ { TRAN | TRANSACTION } [ transaction_name | @tran_name_variable ] ] +-- [ WITH ( DELAYED_DURABILITY = { OFF | ON } ) ] + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Committing a transaction + +USE AdventureWorks2012; +GO +BEGIN TRANSACTION; +GO +DELETE FROM HumanResources.JobCandidate + WHERE JobCandidateID = 13; +GO +COMMIT TRANSACTION; +GO + +--+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +-- Committing a nested transaction + +USE AdventureWorks2012; +GO +IF OBJECT_ID(N'TestTran',N'U') IS NOT NULL + DROP TABLE TestTran; +GO +CREATE TABLE TestTran (Cola int PRIMARY KEY, Colb char(3)); +GO +-- This statement sets @@TRANCOUNT to 1. +BEGIN TRANSACTION OuterTran; +GO +PRINT N'Transaction count after BEGIN OuterTran = ' + + CAST(@@TRANCOUNT AS nvarchar(10)); +GO +INSERT INTO TestTran VALUES (1, 'aaa'); +GO +-- This statement sets @@TRANCOUNT to 2. +BEGIN TRANSACTION Inner1; +GO +PRINT N'Transaction count after BEGIN Inner1 = ' + + CAST(@@TRANCOUNT AS nvarchar(10)); +GO +INSERT INTO TestTran VALUES (2, 'bbb'); +GO +-- This statement sets @@TRANCOUNT to 3. +BEGIN TRANSACTION Inner2; +GO +PRINT N'Transaction count after BEGIN Inner2 = ' + + CAST(@@TRANCOUNT AS nvarchar(10)); +GO +INSERT INTO TestTran VALUES (3, 'ccc'); +GO +-- This statement decrements @@TRANCOUNT to 2. +-- Nothing is committed. +COMMIT TRANSACTION Inner2; +GO +PRINT N'Transaction count after COMMIT Inner2 = ' + + CAST(@@TRANCOUNT AS nvarchar(10)); +GO +-- This statement decrements @@TRANCOUNT to 1. +-- Nothing is committed. +COMMIT TRANSACTION Inner1; +GO +PRINT N'Transaction count after COMMIT Inner1 = ' + + CAST(@@TRANCOUNT AS nvarchar(10)); +GO +-- This statement decrements @@TRANCOUNT to 0 and +-- commits outer transaction OuterTran. +COMMIT TRANSACTION OuterTran; +GO +PRINT N'Transaction count after COMMIT OuterTran = ' + + CAST(@@TRANCOUNT AS nvarchar(10)); +GO + +----------------------------------------------------------------------- +-- ROLLBACK TRANSACTION https://msdn.microsoft.com/en-us/library/ms181299.aspx +-- ROLLBACK { TRAN | TRANSACTION } + -- [ transaction_name | @tran_name_variable + -- | savepoint_name | @savepoint_variable ] +-- [ ; ] + +USE tempdb; +GO +CREATE TABLE ValueTable ([value] int) +GO + +DECLARE @TransactionName varchar(20) = 'Transaction1'; + +--The following statements start a named transaction, +--insert two rows, and then roll back +--the transaction named in the variable @TransactionName. +--Another statement outside of the named transaction inserts two rows. +--The query returns the results of the previous statements. + +BEGIN TRAN @TransactionName + INSERT INTO ValueTable VALUES(1), (2); +ROLLBACK TRAN @TransactionName; + +INSERT INTO ValueTable VALUES(3),(4); + +SELECT [value] FROM ValueTable; + +DROP TABLE ValueTable; + +----------------------------------------------------------------------- +-- SAVE TRANSACTION https://msdn.microsoft.com/en-us/library/ms188378.aspx +-- SAVE { TRAN | TRANSACTION } { savepoint_name | @savepoint_variable } [ ; ] + +USE AdventureWorks2012; +GO +IF EXISTS (SELECT name FROM sys.objects + WHERE name = N'SaveTranExample') + DROP PROCEDURE SaveTranExample; +GO +CREATE PROCEDURE SaveTranExample + @InputCandidateID INT +AS + -- Detect whether the procedure was called + -- from an active transaction and save + -- that for later use. + -- In the procedure, @TranCounter = 0 + -- means there was no active transaction + -- and the procedure started one. + -- @TranCounter > 0 means an active + -- transaction was started before the + -- procedure was called. + DECLARE @TranCounter INT; + SET @TranCounter = @@TRANCOUNT; + IF @TranCounter > 0 + -- Procedure called when there is + -- an active transaction. + -- Create a savepoint to be able + -- to roll back only the work done + -- in the procedure if there is an + -- error. + SAVE TRANSACTION ProcedureSave; + ELSE + -- Procedure must start its own + -- transaction. + BEGIN TRANSACTION; + -- Modify database. + BEGIN TRY + DELETE HumanResources.JobCandidate + WHERE JobCandidateID = @InputCandidateID; + -- Get here if no errors; must commit + -- any transaction started in the + -- procedure, but not commit a transaction + -- started before the transaction was called. + IF @TranCounter = 0 + -- @TranCounter = 0 means no transaction was + -- started before the procedure was called. + -- The procedure must commit the transaction + -- it started. + COMMIT TRANSACTION; + END TRY + BEGIN CATCH + -- An error occurred; must determine + -- which type of rollback will roll + -- back only the work done in the + -- procedure. + IF @TranCounter = 0 + -- Transaction started in procedure. + -- Roll back complete transaction. + ROLLBACK TRANSACTION; + ELSE + -- Transaction started before procedure + -- called, do not roll back modifications + -- made before the procedure was called. + IF XACT_STATE() <> -1 + -- If the transaction is still valid, just + -- roll back to the savepoint set at the + -- start of the stored procedure. + ROLLBACK TRANSACTION ProcedureSave; + -- If the transaction is uncommitable, a + -- rollback to the savepoint is not allowed + -- because the savepoint rollback writes to + -- the log. Just return to the caller, which + -- should roll back the outer transaction. + + -- After the appropriate rollback, echo error + -- information to the caller. + DECLARE @ErrorMessage NVARCHAR(4000); + DECLARE @ErrorSeverity INT; + DECLARE @ErrorState INT; + + SELECT @ErrorMessage = ERROR_MESSAGE(); + SELECT @ErrorSeverity = ERROR_SEVERITY(); + SELECT @ErrorState = ERROR_STATE(); + + RAISERROR (@ErrorMessage, -- Message text. + @ErrorSeverity, -- Severity. + @ErrorState -- State. + ); + END CATCH +GO + +CHECKPOINT; +GO +CHECKPOINT 100; +GO diff --git a/tsql/examples/triggers.sql b/tsql/examples/triggers.sql new file mode 100644 index 0000000..cb6ea54 --- /dev/null +++ b/tsql/examples/triggers.sql @@ -0,0 +1,105 @@ +CREATE TRIGGER reminder1 +ON Sales.Customer +AFTER INSERT, UPDATE +AS RAISERROR ('Notify Customer Relations', 16, 10); +GO + +CREATE OR ALTER TRIGGER reminder2 +ON Sales.Customer +AFTER INSERT, UPDATE, DELETE +AS + EXEC msdb.dbo.sp_send_dbmail + @profile_name = 'AdventureWorks2012 Administrator', + @recipients = 'danw@Adventure-Works.com', + @body = 'Don''t forget to print a report for the sales force.', + @subject = 'Reminder'; +GO + +CREATE TRIGGER Purchasing.LowCredit ON Purchasing.PurchaseOrderHeader +AFTER INSERT +AS +IF EXISTS (SELECT * + FROM Purchasing.PurchaseOrderHeader AS p + JOIN inserted AS i + ON p.PurchaseOrderID = i.PurchaseOrderID + JOIN Purchasing.Vendor AS v + ON v.BusinessEntityID = p.VendorID + WHERE v.CreditRating = 5 + ) +BEGIN +RAISERROR ('A vendor''s credit rating is too low to accept new +purchase orders.', 16, 1); +ROLLBACK TRANSACTION; +RETURN +END; +GO + +CREATE TRIGGER safety +ON DATABASE +FOR DROP_SYNONYM +AS + RAISERROR ('You must disable Trigger "safety" to drop synonyms!',10, 1) + ROLLBACK +GO +DROP TRIGGER safety +ON DATABASE; +GO + +CREATE TRIGGER triggerOnDatabase +ON DATABASE +FOR create_procedure, alter_procedure, drop_procedure, + create_table, alter_table, drop_table, + create_trigger, alter_trigger, drop_trigger, + create_view, alter_view, drop_view, + create_function, alter_function, drop_function, + create_index, alter_index, drop_index +AS +BEGIN + declare @variable int +END +GO + +DROP TRIGGER triggerOnDatabase +ON DATABASE; +GO + +CREATE TRIGGER ddl_trig_database +ON ALL SERVER +FOR CREATE_DATABASE +AS + PRINT 'Database Created.' + SELECT EVENTDATA().value('(/EVENT_INSTANCE/TSQLCommand/CommandText)[1]','nvarchar(max)') +GO +DROP TRIGGER ddl_trig_database +ON ALL SERVER; +GO +DISABLE TRIGGER Person.uAddress ON Person.Address; +GO +ENABLE Trigger Person.uAddress ON Person.Address; +DISABLE TRIGGER safety ON DATABASE; +GO +ENABLE TRIGGER safety ON DATABASE; +ENABLE Trigger ALL ON ALL SERVER; +GO +DISABLE TRIGGER Person.uAddress ON Person.Address; +GO +DISABLE TRIGGER safety ON DATABASE; +GO +DISABLE Trigger ALL ON ALL SERVER; +GO + + +CREATE OR REPLACE TRIGGER triggerOnDatabase +ON DATABASE +FOR create_procedure +AS +BEGIN + declare @variable int +END +GO + +CREATE OR REPLACE TRIGGER myTrigger ON myTable +FOR UPDATE +AS + PRINT 'This is the trigger from create-or-replace' +GO \ No newline at end of file diff --git a/tsql/examples/truncate.sql b/tsql/examples/truncate.sql new file mode 100644 index 0000000..9fdf58e --- /dev/null +++ b/tsql/examples/truncate.sql @@ -0,0 +1,7 @@ +TRUNCATE TABLE HumanResources.JobCandidate; +GO +TRUNCATE TABLE PartitionTable1 +WITH (PARTITIONS (2, 4, 6 TO 8)); +GO +TRUNCATE TABLE DifferentDB..JobCandidate; +GO diff --git a/tsql/examples/try_parse.sql b/tsql/examples/try_parse.sql new file mode 100644 index 0000000..2afae7c --- /dev/null +++ b/tsql/examples/try_parse.sql @@ -0,0 +1,12 @@ +SELECT TRY_PARSE('Jabberwokkie' AS datetime2 USING 'en-US') AS Result; + +SELECT + CASE WHEN TRY_PARSE('Aragorn' AS decimal USING 'sr-Latn-CS') IS NULL + THEN 'True' + ELSE 'False' +END +AS Result; + + +SET LANGUAGE English; +SELECT IIF(TRY_PARSE('01/01/2011' AS datetime2) IS NULL, 'True', 'False') AS Result; diff --git a/tsql/examples/update_statistics.sql b/tsql/examples/update_statistics.sql new file mode 100644 index 0000000..cdb4e1b --- /dev/null +++ b/tsql/examples/update_statistics.sql @@ -0,0 +1,42 @@ +UPDATE STATISTICS t1 (a,b); + +UPDATE STATISTICS t1 (a) WITH SAMPLE 10 ROWS; + +UPDATE STATISTICS t1 (a) WITH NORECOMPUTE; + +UPDATE STATISTICS t1 (a) WITH INCREMENTAL = ON; + +UPDATE STATISTICS t1 (a) WITH stats_stream = 0x01; + +USE AdventureWorks2012; +GO +UPDATE STATISTICS Sales.SalesOrderDetail; +GO + +USE AdventureWorks2012; +GO +UPDATE STATISTICS Sales.SalesOrderDetail AK_SalesOrderDetail_rowguid; +GO + +USE AdventureWorks2012; +GO +CREATE STATISTICS Products + ON Production.Product ([Name], ProductNumber) + WITH SAMPLE 50 PERCENT +-- Time passes. The UPDATE STATISTICS statement is then executed. +UPDATE STATISTICS Production.Product(Products) + WITH SAMPLE 50 PERCENT; + +USE AdventureWorks2012; +GO +UPDATE STATISTICS Production.Product(Products) + WITH FULLSCAN, NORECOMPUTE; +GO + +UPDATE STATISTICS Customer (CustomerStats1); + +UPDATE STATISTICS Customer (CustomerStats1) WITH FULLSCAN; + +UPDATE STATISTICS Customer; + +UPDATE STATISTICS Customer (CustomerStats1) WITH AUTO_DROP = ON diff --git a/tsql/examples/users.sql b/tsql/examples/users.sql new file mode 100644 index 0000000..0f70425 --- /dev/null +++ b/tsql/examples/users.sql @@ -0,0 +1,30 @@ +ALTER USER Mary5 WITH NAME = Mary51; +ALTER USER Mary51 WITH DEFAULT_SCHEMA = Purchasing; +ALTER USER Philip +WITH NAME = Philipe + , DEFAULT_SCHEMA = Development + , PASSWORD = 'W1r77TT98%ab@#' OLD_PASSWORD = 'New Devel0per' + , DEFAULT_LANGUAGE = French ; +GO + +CREATE USER AbolrousHazem FOR LOGIN AbolrousHazem; +GO +CREATE USER Wanida FOR LOGIN WanidaBenshoof + WITH DEFAULT_SCHEMA = Marketing; +CREATE USER JinghaoLiu FOR CERTIFICATE CarnationProduction50; +GO +CREATE USER CustomApp WITHOUT LOGIN ; +CREATE USER Carlo +WITH PASSWORD='RN92piTCh%$!~3K9844 Bl*' + , DEFAULT_LANGUAGE=[Brazilian] + , DEFAULT_SCHEMA=[dbo] +GO +CREATE USER [Contoso\Fritz] ; +GO +CREATE USER CarmenW WITH PASSWORD = 'a8ea v*(Rd##+' +, SID = 0x01050000000000090300000063FF0451A9E7664BA705B10E37DDC4B7; +CREATE USER [Chin] +WITH + DEFAULT_SCHEMA = dbo + , ALLOW_ENCRYPTED_VALUE_MODIFICATIONS = ON ; + diff --git a/tsql/examples/workload_group.sql b/tsql/examples/workload_group.sql new file mode 100644 index 0000000..ac22397 --- /dev/null +++ b/tsql/examples/workload_group.sql @@ -0,0 +1,13 @@ +ALTER WORKLOAD GROUP "default" +WITH (IMPORTANCE = LOW); +GO +ALTER RESOURCE GOVERNOR RECONFIGURE; +GO +ALTER WORKLOAD GROUP adHoc +USING [default]; +GO +ALTER RESOURCE GOVERNOR RECONFIGURE; +GO +CREATE WORKLOAD GROUP newReports + USING "default" ; +GO diff --git a/tsql/examples/xml_data_type.sql b/tsql/examples/xml_data_type.sql new file mode 100644 index 0000000..e3d49c0 --- /dev/null +++ b/tsql/examples/xml_data_type.sql @@ -0,0 +1,202 @@ +-- Use Explicit Mode with FOR XML +SELECT 1 as tag + ,NULL as Parent + ,3 as [Baz!1!Qux!CDATA] +FOR XML EXPLICIT, +BINARY BASE64, TYPE +GO; + +-- Selecting into xml @local_variable with nested subquery +DECLARE @xml xml +SELECT @xml = ( + SELECT + 'foo' AS 'foo', + (SELECT 1 as tag + ,NULL as Parent + ,3 as [Baz!1!Qux!CDATA] + FOR XML EXPLICIT, + BINARY BASE64, TYPE) + FOR XML PATH ('Test')); +GO; + +-- XML With Binary Base64 +CREATE TABLE MyTable (Col1 int PRIMARY KEY, Col2 binary) +INSERT INTO MyTable VALUES (1, 0x7); + +SELECT Col1, + CAST(Col2 as image) as Col2 + FROM MyTable +FOR XML AUTO, BINARY BASE64; +GO; + +-- Create a typed xml variable by specifying an XML schema collection +DECLARE @x xml (Sales.StoreSurveySchemaCollection) +GO; + +-- Using the query() method against an xml type variable +declare @myDoc xml +set @myDoc = ' + + + 1 year parts and labor + 3 year parts and labor extended maintenance is available + + +' +SELECT @myDoc.query('/Root/ProductDescription/Features') +GO; + +-- Using the query() method against an XML type column +SELECT CatalogDescription.query(' +declare namespace PD="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription"; + +') as Result +FROM Production.ProductModel +where CatalogDescription.exist(' +declare namespace PD="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription"; +declare namespace wm="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain"; + /PD:ProductDescription/PD:Features/wm:Warranty ') = 1 +GO; + +-- Using the value() method against an xml type variable +DECLARE @myDoc xml +DECLARE @ProdID int +SET @myDoc = ' + + + 1 year parts and labor + 3 year parts and labor extended maintenance is available + + +' + +SET @ProdID = @myDoc.value('(/Root/ProductDescription/@ProductID)[1]', 'int' ) +SELECT @ProdID +GO; + +-- Specifying the exist() method against an xml type variable +declare @x xml; +declare @f bit; +set @x = ''; +set @f = @x.exist('/root[(@Somedate cast as xs:date?) eq xs:date("2002-01-01Z")]'); +select @f; +GO; + +-- Specifying the exist() method against an xml type variable, with element +DECLARE @x xml; +DECLARE @f bit; +SET @x = '2002-01-01Z'; +SET @f = @x.exist('/Somedate[(text()[1] cast as xs:date ?) = xs:date("2002-01-01Z") ]') +SELECT @f; +GO; + +-- Specifying the exist() method against a typed xml variable +DECLARE @x xml (Production.ManuInstructionsSchemaCollection); +SELECT @x=Instructions +FROM Production.ProductModel +WHERE ProductModelID=67; +--SELECT @x +DECLARE @f int; +SET @f = @x.exist(' declare namespace AWMI="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions"; + /AWMI:root/AWMI:Location[@LocationID=50] +'); +SELECT @f; +GO; + +-- Specifying the exist() method against an xml type column +SELECT ProductModelID, CatalogDescription.query(' +declare namespace pd="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription"; + +') AS Result +FROM Production.ProductModel +WHERE CatalogDescription.exist(' + declare namespace pd="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription"; + /pd:ProductDescription[not(pd:Specifications)]' + ) = 1; +GO; + +-- Specifying the exist() method against an xml type column with XMLNAMESPACES +WITH XMLNAMESPACES ('http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription' AS pd) +SELECT ProductModelID, CatalogDescription.query(' + +') AS Result +FROM Production.ProductModel +WHERE CatalogDescription.exist(' + /pd:ProductDescription[not(pd:Specifications)]' + ) = 1; +GO; + +-- Replacing values in an XML instance using .modify +DECLARE @myDoc xml; +SET @myDoc = ' +Manufacturing steps are described here. +Manufacturing step 1 at this work center +Manufacturing step 2 at this work center + +'; + +SET @myDoc.modify(' + replace value of (/Root/Location/step[1]/text())[1] + with "new text describing the manu step" +'); +SELECT @myDoc; +GO; + +-- Using nodes() to extract the subtree of the context item for each generated row: +SELECT T2.Loc.query('.') +FROM T +CROSS APPLY Instructions.nodes('/root/Location') as T2(Loc) + +-- Using nodes() method against a variable of xml type +DECLARE @x xml +SET @x=' + Larrysome text + moe + +' +SELECT T.c.query('.') AS result +FROM @x.nodes('/Root/row') T(c) OPTION (OPTIMIZE FOR (@xml = NULL)); +GO; + +-- Specifying the nodes() method against a column of xml type +SELECT C.query('.') as result +FROM Production.ProductModel +CROSS APPLY Instructions.nodes(' +declare namespace MI="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions"; +/MI:root/MI:Location') as T(C) +WHERE ProductModelID=7 +GO; + +-- Expression xml methods +SELECT CAST(N'' as xml).value('xs:base64Binary(sql:variable("@str"))', 'varbinary(MAX)') + +SELECT ProductModelID, Locations.value('./@LocationID','int') AS LocID, +steps.query('.') AS Step +FROM Production.ProductModel +CROSS APPLY Instructions.nodes(' +declare namespace MI="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions"; +/MI:root/MI:Location') AS T1(Locations) +CROSS APPLY T1.Locations.nodes(' +declare namespace MI="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions"; +./MI:step ') AS T2(steps) +WHERE ProductModelID=7 +GO + +-- Square bracket variants +SET @ProdID = @myDoc.[value]('(/Root/ProductDescription/@ProductID)[1]', 'int' ) +SET @f = @x.[exist](' declare namespace AWMI="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions"; + /AWMI:root/AWMI:Location[@LocationID=50] +'); +SELECT T.c.[query]('.') AS result +SET @myDoc.[modify](' + replace value of (/Root/Location/step[1]/text())[1] + with "new text describing the manu step" +'); +GO + diff --git a/tsql/examples/xml_schema_collection.sql b/tsql/examples/xml_schema_collection.sql new file mode 100644 index 0000000..61c492e --- /dev/null +++ b/tsql/examples/xml_schema_collection.sql @@ -0,0 +1 @@ +CREATE XML SCHEMA COLLECTION MyCollection AS @MySchemaCollection diff --git a/tsql/generate_keyword_golang_map.py b/tsql/generate_keyword_golang_map.py new file mode 100644 index 0000000..e8698f4 --- /dev/null +++ b/tsql/generate_keyword_golang_map.py @@ -0,0 +1,55 @@ +from typing import List + + +def extract_keyword_candidates(lines: List[str]) -> List[str]: + result = [] + for line in lines: + line = line.strip() + if not line.startswith(":") and not line.startswith("|"): + continue + line = line[1:].strip() + buf = "" + for i in range(len(line)): + if line[i].isdigit() or line[i].isalpha() or line[i] == "_": + buf += line[i] + continue + break + if len(buf) > 0: + result.append(buf) + buf = "" + return result + + + +if __name__ == "__main__": + with open("TSqlParser.g4") as f: + content = f.read() + content_lines = content.split("\n") + for (idx, line) in enumerate(content_lines): + if not line.startswith("keyword"): + continue + + if not (idx < len(content_lines) - 1 and content_lines[idx + 1].endswith(": ABORT")): + continue + + buffer = [] + for j in range(idx + 1, len(content_lines)): + if content_lines[j].endswith(";"): + break + buffer.append(content_lines[j]) + with open("keyword_map.go", "w") as f: + f.write(r"// Code generated from generate_keyword_golang_map.py. DO NOT EDIT") + f.write("\n\n") + f.write(r"package parser") + f.write("\n\n") + f.write(r"var keywordMap map[int]struct{} = map[int]struct{}{") + candidates = extract_keyword_candidates(buffer) + for (_, candidate) in enumerate(candidates): + f.write("\n") + f.write(" "*4) + f.write(f"TSqlLexer{candidate}:") + f.write(" {},") + f.write("\n") + f.write("}") + print("Write keyword map to keyword_map.go successfully!") + diff --git a/tsql/keyword_map.go b/tsql/keyword_map.go new file mode 100644 index 0000000..449fa4b --- /dev/null +++ b/tsql/keyword_map.go @@ -0,0 +1,969 @@ +// Code generated from generate_keyword_golang_map.py. DO NOT EDIT + +package tsql + +var keywordMap map[int]struct{} = map[int]struct{}{ + TSqlLexerABORT: {}, + TSqlLexerABSOLUTE: {}, + TSqlLexerACCENT_SENSITIVITY: {}, + TSqlLexerACCESS: {}, + TSqlLexerACTION: {}, + TSqlLexerACTIVATION: {}, + TSqlLexerACTIVE: {}, + TSqlLexerADD: {}, + TSqlLexerADDRESS: {}, + TSqlLexerAES_128: {}, + TSqlLexerAES_192: {}, + TSqlLexerAES_256: {}, + TSqlLexerAFFINITY: {}, + TSqlLexerAFTER: {}, + TSqlLexerAGGREGATE: {}, + TSqlLexerALGORITHM: {}, + TSqlLexerALL_CONSTRAINTS: {}, + TSqlLexerALL_ERRORMSGS: {}, + TSqlLexerALL_INDEXES: {}, + TSqlLexerALL_LEVELS: {}, + TSqlLexerALLOW_ENCRYPTED_VALUE_MODIFICATIONS: {}, + TSqlLexerALLOW_PAGE_LOCKS: {}, + TSqlLexerALLOW_ROW_LOCKS: {}, + TSqlLexerALLOW_SNAPSHOT_ISOLATION: {}, + TSqlLexerALLOWED: {}, + TSqlLexerALWAYS: {}, + TSqlLexerANSI_DEFAULTS: {}, + TSqlLexerANSI_NULL_DEFAULT: {}, + TSqlLexerANSI_NULL_DFLT_OFF: {}, + TSqlLexerANSI_NULL_DFLT_ON: {}, + TSqlLexerANSI_NULLS: {}, + TSqlLexerANSI_PADDING: {}, + TSqlLexerANSI_WARNINGS: {}, + TSqlLexerAPP_NAME: {}, + TSqlLexerAPPLICATION_LOG: {}, + TSqlLexerAPPLOCK_MODE: {}, + TSqlLexerAPPLOCK_TEST: {}, + TSqlLexerAPPLY: {}, + TSqlLexerARITHABORT: {}, + TSqlLexerARITHIGNORE: {}, + TSqlLexerASCII: {}, + TSqlLexerASSEMBLY: {}, + TSqlLexerASSEMBLYPROPERTY: {}, + TSqlLexerAT_KEYWORD: {}, + TSqlLexerAUDIT: {}, + TSqlLexerAUDIT_GUID: {}, + TSqlLexerAUTO: {}, + TSqlLexerAUTO_CLEANUP: {}, + TSqlLexerAUTO_CLOSE: {}, + TSqlLexerAUTO_CREATE_STATISTICS: {}, + TSqlLexerAUTO_DROP: {}, + TSqlLexerAUTO_SHRINK: {}, + TSqlLexerAUTO_UPDATE_STATISTICS: {}, + TSqlLexerAUTO_UPDATE_STATISTICS_ASYNC: {}, + TSqlLexerAUTOGROW_ALL_FILES: {}, + TSqlLexerAUTOGROW_SINGLE_FILE: {}, + TSqlLexerAVAILABILITY: {}, + TSqlLexerAVG: {}, + TSqlLexerBACKUP_CLONEDB: {}, + TSqlLexerBACKUP_PRIORITY: {}, + TSqlLexerBASE64: {}, + TSqlLexerBEGIN_DIALOG: {}, + TSqlLexerBIGINT: {}, + TSqlLexerBINARY_KEYWORD: {}, + TSqlLexerBINARY_CHECKSUM: {}, + TSqlLexerBINDING: {}, + TSqlLexerBLOB_STORAGE: {}, + TSqlLexerBROKER: {}, + TSqlLexerBROKER_INSTANCE: {}, + TSqlLexerBULK_LOGGED: {}, + TSqlLexerCALLER: {}, + TSqlLexerCAP_CPU_PERCENT: {}, + TSqlLexerCAST: {}, + TSqlLexerTRY_CAST: {}, + TSqlLexerCATALOG: {}, + TSqlLexerCATCH: {}, + TSqlLexerCERT_ID: {}, + TSqlLexerCERTENCODED: {}, + TSqlLexerCERTPRIVATEKEY: {}, + TSqlLexerCHANGE: {}, + TSqlLexerCHANGE_RETENTION: {}, + TSqlLexerCHANGE_TRACKING: {}, + TSqlLexerCHAR: {}, + TSqlLexerCHARINDEX: {}, + TSqlLexerCHECKALLOC: {}, + TSqlLexerCHECKCATALOG: {}, + TSqlLexerCHECKCONSTRAINTS: {}, + TSqlLexerCHECKDB: {}, + TSqlLexerCHECKFILEGROUP: {}, + TSqlLexerCHECKSUM: {}, + TSqlLexerCHECKSUM_AGG: {}, + TSqlLexerCHECKTABLE: {}, + TSqlLexerCLEANTABLE: {}, + TSqlLexerCLEANUP: {}, + TSqlLexerCLONEDATABASE: {}, + TSqlLexerCOL_LENGTH: {}, + TSqlLexerCOL_NAME: {}, + TSqlLexerCOLLECTION: {}, + TSqlLexerCOLUMN_ENCRYPTION_KEY: {}, + TSqlLexerCOLUMN_MASTER_KEY: {}, + TSqlLexerCOLUMNPROPERTY: {}, + TSqlLexerCOLUMNS: {}, + TSqlLexerCOLUMNSTORE: {}, + TSqlLexerCOLUMNSTORE_ARCHIVE: {}, + TSqlLexerCOMMITTED: {}, + TSqlLexerCOMPATIBILITY_LEVEL: {}, + TSqlLexerCOMPRESS_ALL_ROW_GROUPS: {}, + TSqlLexerCOMPRESSION_DELAY: {}, + TSqlLexerCONCAT: {}, + TSqlLexerCONCAT_WS: {}, + TSqlLexerCONCAT_NULL_YIELDS_NULL: {}, + TSqlLexerCONTENT: {}, + TSqlLexerCONTROL: {}, + TSqlLexerCOOKIE: {}, + TSqlLexerCOUNT: {}, + TSqlLexerCOUNT_BIG: {}, + TSqlLexerCOUNTER: {}, + TSqlLexerCPU: {}, + TSqlLexerCREATE_NEW: {}, + TSqlLexerCREATION_DISPOSITION: {}, + TSqlLexerCREDENTIAL: {}, + TSqlLexerCRYPTOGRAPHIC: {}, + TSqlLexerCUME_DIST: {}, + TSqlLexerCURSOR_CLOSE_ON_COMMIT: {}, + TSqlLexerCURSOR_DEFAULT: {}, + TSqlLexerCURSOR_STATUS: {}, + TSqlLexerDATA: {}, + TSqlLexerDATA_PURITY: {}, + TSqlLexerDATABASE_PRINCIPAL_ID: {}, + TSqlLexerDATABASEPROPERTYEX: {}, + TSqlLexerDATALENGTH: {}, + TSqlLexerDATE_CORRELATION_OPTIMIZATION: {}, + TSqlLexerDATEADD: {}, + TSqlLexerDATEDIFF: {}, + TSqlLexerDATENAME: {}, + TSqlLexerDATEPART: {}, + TSqlLexerDAYS: {}, + TSqlLexerDB_CHAINING: {}, + TSqlLexerDB_FAILOVER: {}, + TSqlLexerDB_ID: {}, + TSqlLexerDB_NAME: {}, + TSqlLexerDBCC: {}, + TSqlLexerDBREINDEX: {}, + TSqlLexerDECRYPTION: {}, + TSqlLexerDEFAULT_DOUBLE_QUOTE: {}, + TSqlLexerDEFAULT_FULLTEXT_LANGUAGE: {}, + TSqlLexerDEFAULT_LANGUAGE: {}, + TSqlLexerDEFINITION: {}, + TSqlLexerDELAY: {}, + TSqlLexerDELAYED_DURABILITY: {}, + TSqlLexerDELETED: {}, + TSqlLexerDENSE_RANK: {}, + TSqlLexerDEPENDENTS: {}, + TSqlLexerDES: {}, + TSqlLexerDESCRIPTION: {}, + TSqlLexerDESX: {}, + TSqlLexerDETERMINISTIC: {}, + TSqlLexerDHCP: {}, + TSqlLexerDIALOG: {}, + TSqlLexerDIFFERENCE: {}, + TSqlLexerDIRECTORY_NAME: {}, + TSqlLexerDISABLE: {}, + TSqlLexerDISABLE_BROKER: {}, + TSqlLexerDISABLED: {}, + TSqlLexerDOCUMENT: {}, + TSqlLexerDROP_EXISTING: {}, + TSqlLexerDROPCLEANBUFFERS: {}, + TSqlLexerDYNAMIC: {}, + TSqlLexerELEMENTS: {}, + TSqlLexerEMERGENCY: {}, + TSqlLexerEMPTY: {}, + TSqlLexerENABLE: {}, + TSqlLexerENABLE_BROKER: {}, + TSqlLexerENCRYPTED: {}, + TSqlLexerENCRYPTED_VALUE: {}, + TSqlLexerENCRYPTION: {}, + TSqlLexerENCRYPTION_TYPE: {}, + TSqlLexerENDPOINT_URL: {}, + TSqlLexerERROR_BROKER_CONVERSATIONS: {}, + TSqlLexerESTIMATEONLY: {}, + TSqlLexerEXCLUSIVE: {}, + TSqlLexerEXECUTABLE: {}, + TSqlLexerEXIST: {}, + TSqlLexerEXIST_SQUARE_BRACKET: {}, + TSqlLexerEXPAND: {}, + TSqlLexerEXPIRY_DATE: {}, + TSqlLexerEXPLICIT: {}, + TSqlLexerEXTENDED_LOGICAL_CHECKS: {}, + TSqlLexerFAIL_OPERATION: {}, + TSqlLexerFAILOVER_MODE: {}, + TSqlLexerFAILURE: {}, + TSqlLexerFAILURE_CONDITION_LEVEL: {}, + TSqlLexerFAST: {}, + TSqlLexerFAST_FORWARD: {}, + TSqlLexerFILE_ID: {}, + TSqlLexerFILE_IDEX: {}, + TSqlLexerFILE_NAME: {}, + TSqlLexerFILEGROUP: {}, + TSqlLexerFILEGROUP_ID: {}, + TSqlLexerFILEGROUP_NAME: {}, + TSqlLexerFILEGROUPPROPERTY: {}, + TSqlLexerFILEGROWTH: {}, + TSqlLexerFILENAME: {}, + TSqlLexerFILEPATH: {}, + TSqlLexerFILEPROPERTY: {}, + TSqlLexerFILEPROPERTYEX: {}, + TSqlLexerFILESTREAM: {}, + TSqlLexerFILTER: {}, + TSqlLexerFIRST: {}, + TSqlLexerFIRST_VALUE: {}, + TSqlLexerFMTONLY: {}, + TSqlLexerFOLLOWING: {}, + TSqlLexerFORCE: {}, + TSqlLexerFORCE_FAILOVER_ALLOW_DATA_LOSS: {}, + TSqlLexerFORCED: {}, + TSqlLexerFORCEPLAN: {}, + TSqlLexerFORCESCAN: {}, + TSqlLexerFORMAT: {}, + TSqlLexerFORWARD_ONLY: {}, + TSqlLexerFREE: {}, + TSqlLexerFULLSCAN: {}, + TSqlLexerFULLTEXT: {}, + TSqlLexerFULLTEXTCATALOGPROPERTY: {}, + TSqlLexerFULLTEXTSERVICEPROPERTY: {}, + TSqlLexerGB: {}, + TSqlLexerGENERATED: {}, + TSqlLexerGETDATE: {}, + TSqlLexerGETUTCDATE: {}, + TSqlLexerGLOBAL: {}, + TSqlLexerGO: {}, + TSqlLexerGREATEST: {}, + TSqlLexerGROUP_MAX_REQUESTS: {}, + TSqlLexerGROUPING: {}, + TSqlLexerGROUPING_ID: {}, + TSqlLexerHADR: {}, + TSqlLexerHAS_DBACCESS: {}, + TSqlLexerHAS_PERMS_BY_NAME: {}, + TSqlLexerHASH: {}, + TSqlLexerHEALTH_CHECK_TIMEOUT: {}, + TSqlLexerHIDDEN_KEYWORD: {}, + TSqlLexerHIGH: {}, + TSqlLexerHONOR_BROKER_PRIORITY: {}, + TSqlLexerHOURS: {}, + TSqlLexerIDENT_CURRENT: {}, + TSqlLexerIDENT_INCR: {}, + TSqlLexerIDENT_SEED: {}, + TSqlLexerIDENTITY_VALUE: {}, + TSqlLexerIGNORE_CONSTRAINTS: {}, + TSqlLexerIGNORE_DUP_KEY: {}, + TSqlLexerIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX: {}, + TSqlLexerIGNORE_REPLICATED_TABLE_CACHE: {}, + TSqlLexerIGNORE_TRIGGERS: {}, + TSqlLexerIMMEDIATE: {}, + TSqlLexerIMPERSONATE: {}, + TSqlLexerIMPLICIT_TRANSACTIONS: {}, + TSqlLexerIMPORTANCE: {}, + TSqlLexerINCLUDE_NULL_VALUES: {}, + TSqlLexerINCREMENTAL: {}, + TSqlLexerINDEX_COL: {}, + TSqlLexerINDEXKEY_PROPERTY: {}, + TSqlLexerINDEXPROPERTY: {}, + TSqlLexerINITIATOR: {}, + TSqlLexerINPUT: {}, + TSqlLexerINSENSITIVE: {}, + TSqlLexerINSERTED: {}, + TSqlLexerINT: {}, + TSqlLexerIP: {}, + TSqlLexerIS_MEMBER: {}, + TSqlLexerIS_ROLEMEMBER: {}, + TSqlLexerIS_SRVROLEMEMBER: {}, + TSqlLexerISJSON: {}, + TSqlLexerISOLATION: {}, + TSqlLexerJOB: {}, + TSqlLexerJSON: {}, + TSqlLexerJSON_OBJECT: {}, + TSqlLexerJSON_ARRAY: {}, + TSqlLexerJSON_VALUE: {}, + TSqlLexerJSON_QUERY: {}, + TSqlLexerJSON_MODIFY: {}, + TSqlLexerJSON_PATH_EXISTS: {}, + TSqlLexerKB: {}, + TSqlLexerKEEP: {}, + TSqlLexerKEEPDEFAULTS: {}, + TSqlLexerKEEPFIXED: {}, + TSqlLexerKEEPIDENTITY: {}, + TSqlLexerKEY_SOURCE: {}, + TSqlLexerKEYS: {}, + TSqlLexerKEYSET: {}, + TSqlLexerLAG: {}, + TSqlLexerLAST: {}, + TSqlLexerLAST_VALUE: {}, + TSqlLexerLEAD: {}, + TSqlLexerLEAST: {}, + TSqlLexerLEN: {}, + TSqlLexerLEVEL: {}, + TSqlLexerLIST: {}, + TSqlLexerLISTENER: {}, + TSqlLexerLISTENER_URL: {}, + TSqlLexerLOB_COMPACTION: {}, + TSqlLexerLOCAL: {}, + TSqlLexerLOCATION: {}, + TSqlLexerLOCK: {}, + TSqlLexerLOCK_ESCALATION: {}, + TSqlLexerLOGIN: {}, + TSqlLexerLOGINPROPERTY: {}, + TSqlLexerLOOP: {}, + TSqlLexerLOW: {}, + TSqlLexerLOWER: {}, + TSqlLexerLTRIM: {}, + TSqlLexerMANUAL: {}, + TSqlLexerMARK: {}, + TSqlLexerMASKED: {}, + TSqlLexerMATERIALIZED: {}, + TSqlLexerMAX: {}, + TSqlLexerMAX_CPU_PERCENT: {}, + TSqlLexerMAX_DOP: {}, + TSqlLexerMAX_FILES: {}, + TSqlLexerMAX_IOPS_PER_VOLUME: {}, + TSqlLexerMAX_MEMORY_PERCENT: {}, + TSqlLexerMAX_PROCESSES: {}, + TSqlLexerMAX_QUEUE_READERS: {}, + TSqlLexerMAX_ROLLOVER_FILES: {}, + TSqlLexerMAXDOP: {}, + TSqlLexerMAXRECURSION: {}, + TSqlLexerMAXSIZE: {}, + TSqlLexerMB: {}, + TSqlLexerMEDIUM: {}, + TSqlLexerMEMORY_OPTIMIZED_DATA: {}, + TSqlLexerMESSAGE: {}, + TSqlLexerMIN: {}, + TSqlLexerMIN_ACTIVE_ROWVERSION: {}, + TSqlLexerMIN_CPU_PERCENT: {}, + TSqlLexerMIN_IOPS_PER_VOLUME: {}, + TSqlLexerMIN_MEMORY_PERCENT: {}, + TSqlLexerMINUTES: {}, + TSqlLexerMIRROR_ADDRESS: {}, + TSqlLexerMIXED_PAGE_ALLOCATION: {}, + TSqlLexerMODE: {}, + TSqlLexerMODIFY: {}, + TSqlLexerMODIFY_SQUARE_BRACKET: {}, + TSqlLexerMOVE: {}, + TSqlLexerMULTI_USER: {}, + TSqlLexerNAME: {}, + TSqlLexerNCHAR: {}, + TSqlLexerNESTED_TRIGGERS: {}, + TSqlLexerNEW_ACCOUNT: {}, + TSqlLexerNEW_BROKER: {}, + TSqlLexerNEW_PASSWORD: {}, + TSqlLexerNEWNAME: {}, + TSqlLexerNEXT: {}, + TSqlLexerNO: {}, + TSqlLexerNO_INFOMSGS: {}, + TSqlLexerNO_QUERYSTORE: {}, + TSqlLexerNO_STATISTICS: {}, + TSqlLexerNO_TRUNCATE: {}, + TSqlLexerNO_WAIT: {}, + TSqlLexerNOCOUNT: {}, + TSqlLexerNODES: {}, + TSqlLexerNOEXEC: {}, + TSqlLexerNOEXPAND: {}, + TSqlLexerNOINDEX: {}, + TSqlLexerNOLOCK: {}, + TSqlLexerNON_TRANSACTED_ACCESS: {}, + TSqlLexerNORECOMPUTE: {}, + TSqlLexerNORECOVERY: {}, + TSqlLexerNOTIFICATIONS: {}, + TSqlLexerNOWAIT: {}, + TSqlLexerNTILE: {}, + TSqlLexerNULL_DOUBLE_QUOTE: {}, + TSqlLexerNUMANODE: {}, + TSqlLexerNUMBER: {}, + TSqlLexerNUMERIC_ROUNDABORT: {}, + TSqlLexerOBJECT: {}, + TSqlLexerOBJECT_DEFINITION: {}, + TSqlLexerOBJECT_ID: {}, + TSqlLexerOBJECT_NAME: {}, + TSqlLexerOBJECT_SCHEMA_NAME: {}, + TSqlLexerOBJECTPROPERTY: {}, + TSqlLexerOBJECTPROPERTYEX: {}, + TSqlLexerOFFLINE: {}, + TSqlLexerOFFSET: {}, + TSqlLexerOLD_ACCOUNT: {}, + TSqlLexerONLINE: {}, + TSqlLexerONLY: {}, + TSqlLexerOPEN_EXISTING: {}, + TSqlLexerOPENJSON: {}, + TSqlLexerOPTIMISTIC: {}, + TSqlLexerOPTIMIZE: {}, + TSqlLexerOPTIMIZE_FOR_SEQUENTIAL_KEY: {}, + TSqlLexerORIGINAL_DB_NAME: {}, + TSqlLexerORIGINAL_LOGIN: {}, + TSqlLexerOUT: {}, + TSqlLexerOUTPUT: {}, + TSqlLexerOVERRIDE: {}, + TSqlLexerOWNER: {}, + TSqlLexerOWNERSHIP: {}, + TSqlLexerPAD_INDEX: {}, + TSqlLexerPAGE_VERIFY: {}, + TSqlLexerPAGECOUNT: {}, + TSqlLexerPAGLOCK: {}, + TSqlLexerPARAMETERIZATION: {}, + TSqlLexerPARSENAME: {}, + TSqlLexerPARSEONLY: {}, + TSqlLexerPARTITION: {}, + TSqlLexerPARTITIONS: {}, + TSqlLexerPARTNER: {}, + TSqlLexerPATH: {}, + TSqlLexerPATINDEX: {}, + TSqlLexerPAUSE: {}, + TSqlLexerPDW_SHOWSPACEUSED: {}, + TSqlLexerPERCENT_RANK: {}, + TSqlLexerPERCENTILE_CONT: {}, + TSqlLexerPERCENTILE_DISC: {}, + TSqlLexerPERMISSIONS: {}, + TSqlLexerPERSIST_SAMPLE_PERCENT: {}, + TSqlLexerPHYSICAL_ONLY: {}, + TSqlLexerPOISON_MESSAGE_HANDLING: {}, + TSqlLexerPOOL: {}, + TSqlLexerPORT: {}, + TSqlLexerPRECEDING: {}, + TSqlLexerPRIMARY_ROLE: {}, + TSqlLexerPRIOR: {}, + TSqlLexerPRIORITY: {}, + TSqlLexerPRIORITY_LEVEL: {}, + TSqlLexerPRIVATE: {}, + TSqlLexerPRIVATE_KEY: {}, + TSqlLexerPRIVILEGES: {}, + TSqlLexerPROCCACHE: {}, + TSqlLexerPROCEDURE_NAME: {}, + TSqlLexerPROPERTY: {}, + TSqlLexerPROVIDER: {}, + TSqlLexerPROVIDER_KEY_NAME: {}, + TSqlLexerPWDCOMPARE: {}, + TSqlLexerPWDENCRYPT: {}, + TSqlLexerQUERY: {}, + TSqlLexerQUERY_SQUARE_BRACKET: {}, + TSqlLexerQUEUE: {}, + TSqlLexerQUEUE_DELAY: {}, + TSqlLexerQUOTED_IDENTIFIER: {}, + TSqlLexerQUOTENAME: {}, + TSqlLexerRANDOMIZED: {}, + TSqlLexerRANGE: {}, + TSqlLexerRANK: {}, + TSqlLexerRC2: {}, + TSqlLexerRC4: {}, + TSqlLexerRC4_128: {}, + TSqlLexerREAD_COMMITTED_SNAPSHOT: {}, + TSqlLexerREAD_ONLY: {}, + TSqlLexerREAD_ONLY_ROUTING_LIST: {}, + TSqlLexerREAD_WRITE: {}, + TSqlLexerREADCOMMITTED: {}, + TSqlLexerREADCOMMITTEDLOCK: {}, + TSqlLexerREADONLY: {}, + TSqlLexerREADPAST: {}, + TSqlLexerREADUNCOMMITTED: {}, + TSqlLexerREADWRITE: {}, + TSqlLexerREBUILD: {}, + TSqlLexerRECEIVE: {}, + TSqlLexerRECOMPILE: {}, + TSqlLexerRECOVERY: {}, + TSqlLexerRECURSIVE_TRIGGERS: {}, + TSqlLexerRELATIVE: {}, + TSqlLexerREMOTE: {}, + TSqlLexerREMOTE_PROC_TRANSACTIONS: {}, + TSqlLexerREMOTE_SERVICE_NAME: {}, + TSqlLexerREMOVE: {}, + TSqlLexerREORGANIZE: {}, + TSqlLexerREPAIR_ALLOW_DATA_LOSS: {}, + TSqlLexerREPAIR_FAST: {}, + TSqlLexerREPAIR_REBUILD: {}, + TSqlLexerREPEATABLE: {}, + TSqlLexerREPEATABLEREAD: {}, + TSqlLexerREPLACE: {}, + TSqlLexerREPLICA: {}, + TSqlLexerREPLICATE: {}, + TSqlLexerREQUEST_MAX_CPU_TIME_SEC: {}, + TSqlLexerREQUEST_MAX_MEMORY_GRANT_PERCENT: {}, + TSqlLexerREQUEST_MEMORY_GRANT_TIMEOUT_SEC: {}, + TSqlLexerREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT: {}, + TSqlLexerRESAMPLE: {}, + TSqlLexerRESERVE_DISK_SPACE: {}, + TSqlLexerRESOURCE: {}, + TSqlLexerRESOURCE_MANAGER_LOCATION: {}, + TSqlLexerRESTRICTED_USER: {}, + TSqlLexerRESUMABLE: {}, + TSqlLexerRETENTION: {}, + TSqlLexerREVERSE: {}, + TSqlLexerROBUST: {}, + TSqlLexerROOT: {}, + TSqlLexerROUTE: {}, + TSqlLexerROW: {}, + TSqlLexerROW_NUMBER: {}, + TSqlLexerROWGUID: {}, + TSqlLexerROWLOCK: {}, + TSqlLexerROWS: {}, + TSqlLexerRTRIM: {}, + TSqlLexerSAMPLE: {}, + TSqlLexerSCHEMA_ID: {}, + TSqlLexerSCHEMA_NAME: {}, + TSqlLexerSCHEMABINDING: {}, + TSqlLexerSCOPE_IDENTITY: {}, + TSqlLexerSCOPED: {}, + TSqlLexerSCROLL: {}, + TSqlLexerSCROLL_LOCKS: {}, + TSqlLexerSEARCH: {}, + TSqlLexerSECONDARY: {}, + TSqlLexerSECONDARY_ONLY: {}, + TSqlLexerSECONDARY_ROLE: {}, + TSqlLexerSECONDS: {}, + TSqlLexerSECRET: {}, + TSqlLexerSECURABLES: {}, + TSqlLexerSECURITY: {}, + TSqlLexerSECURITY_LOG: {}, + TSqlLexerSEEDING_MODE: {}, + TSqlLexerSELF: {}, + TSqlLexerSEMI_SENSITIVE: {}, + TSqlLexerSEND: {}, + TSqlLexerSENT: {}, + TSqlLexerSEQUENCE: {}, + TSqlLexerSEQUENCE_NUMBER: {}, + TSqlLexerSERIALIZABLE: {}, + TSqlLexerSERVERPROPERTY: {}, + TSqlLexerSERVICEBROKER: {}, + TSqlLexerSESSIONPROPERTY: {}, + TSqlLexerSESSION_TIMEOUT: {}, + TSqlLexerSETERROR: {}, + TSqlLexerSHARE: {}, + TSqlLexerSHARED: {}, + TSqlLexerSHOWCONTIG: {}, + TSqlLexerSHOWPLAN: {}, + TSqlLexerSHOWPLAN_ALL: {}, + TSqlLexerSHOWPLAN_TEXT: {}, + TSqlLexerSHOWPLAN_XML: {}, + TSqlLexerSIGNATURE: {}, + TSqlLexerSIMPLE: {}, + TSqlLexerSINGLE_USER: {}, + TSqlLexerSIZE: {}, + TSqlLexerSMALLINT: {}, + TSqlLexerSNAPSHOT: {}, + TSqlLexerSORT_IN_TEMPDB: {}, + TSqlLexerSOUNDEX: {}, + TSqlLexerSPACE_KEYWORD: {}, + TSqlLexerSPARSE: {}, + TSqlLexerSPATIAL_WINDOW_MAX_CELLS: {}, + TSqlLexerSQL_VARIANT_PROPERTY: {}, + TSqlLexerSTANDBY: {}, + TSqlLexerSTART_DATE: {}, + TSqlLexerSTATIC: {}, + TSqlLexerSTATISTICS_INCREMENTAL: {}, + TSqlLexerSTATISTICS_NORECOMPUTE: {}, + TSqlLexerSTATS_DATE: {}, + TSqlLexerSTATS_STREAM: {}, + TSqlLexerSTATUS: {}, + TSqlLexerSTATUSONLY: {}, + TSqlLexerSTDEV: {}, + TSqlLexerSTDEVP: {}, + TSqlLexerSTOPLIST: {}, + TSqlLexerSTR: {}, + TSqlLexerSTRING_AGG: {}, + TSqlLexerSTRING_ESCAPE: {}, + TSqlLexerSTUFF: {}, + TSqlLexerSUBJECT: {}, + TSqlLexerSUBSCRIBE: {}, + TSqlLexerSUBSCRIPTION: {}, + TSqlLexerSUBSTRING: {}, + TSqlLexerSUM: {}, + TSqlLexerSUSER_ID: {}, + TSqlLexerSUSER_NAME: {}, + TSqlLexerSUSER_SID: {}, + TSqlLexerSUSER_SNAME: {}, + TSqlLexerSUSPEND: {}, + TSqlLexerSYMMETRIC: {}, + TSqlLexerSYNCHRONOUS_COMMIT: {}, + TSqlLexerSYNONYM: {}, + TSqlLexerSYSTEM: {}, + TSqlLexerTABLERESULTS: {}, + TSqlLexerTABLOCK: {}, + TSqlLexerTABLOCKX: {}, + TSqlLexerTAKE: {}, + TSqlLexerTARGET_RECOVERY_TIME: {}, + TSqlLexerTB: {}, + TSqlLexerTEXTIMAGE_ON: {}, + TSqlLexerTHROW: {}, + TSqlLexerTIES: {}, + TSqlLexerTIME: {}, + TSqlLexerTIMEOUT: {}, + TSqlLexerTIMER: {}, + TSqlLexerTINYINT: {}, + TSqlLexerTORN_PAGE_DETECTION: {}, + TSqlLexerTRACKING: {}, + TSqlLexerTRANSACTION_ID: {}, + TSqlLexerTRANSFORM_NOISE_WORDS: {}, + TSqlLexerTRANSLATE: {}, + TSqlLexerTRIM: {}, + TSqlLexerTRIPLE_DES: {}, + TSqlLexerTRIPLE_DES_3KEY: {}, + TSqlLexerTRUSTWORTHY: {}, + TSqlLexerTRY: {}, + TSqlLexerTSQL: {}, + TSqlLexerTWO_DIGIT_YEAR_CUTOFF: {}, + TSqlLexerTYPE: {}, + TSqlLexerTYPE_ID: {}, + TSqlLexerTYPE_NAME: {}, + TSqlLexerTYPE_WARNING: {}, + TSqlLexerTYPEPROPERTY: {}, + TSqlLexerUNBOUNDED: {}, + TSqlLexerUNCOMMITTED: {}, + TSqlLexerUNICODE: {}, + TSqlLexerUNKNOWN: {}, + TSqlLexerUNLIMITED: {}, + TSqlLexerUNMASK: {}, + TSqlLexerUOW: {}, + TSqlLexerUPDLOCK: {}, + TSqlLexerUPPER: {}, + TSqlLexerUSER_ID: {}, + TSqlLexerUSER_NAME: {}, + TSqlLexerUSING: {}, + TSqlLexerVALID_XML: {}, + TSqlLexerVALIDATION: {}, + TSqlLexerVALUE: {}, + TSqlLexerVALUE_SQUARE_BRACKET: {}, + TSqlLexerVAR: {}, + TSqlLexerVARBINARY_KEYWORD: {}, + TSqlLexerVARP: {}, + TSqlLexerVERIFY_CLONEDB: {}, + TSqlLexerVERSION: {}, + TSqlLexerVIEW_METADATA: {}, + TSqlLexerVIEWS: {}, + TSqlLexerWAIT: {}, + TSqlLexerWELL_FORMED_XML: {}, + TSqlLexerWITHOUT_ARRAY_WRAPPER: {}, + TSqlLexerWORK: {}, + TSqlLexerWORKLOAD: {}, + TSqlLexerXLOCK: {}, + TSqlLexerXML: {}, + TSqlLexerXML_COMPRESSION: {}, + TSqlLexerXMLDATA: {}, + TSqlLexerXMLNAMESPACES: {}, + TSqlLexerXMLSCHEMA: {}, + TSqlLexerXSINIL: {}, + TSqlLexerZONE: {}, + TSqlLexerABORT_AFTER_WAIT: {}, + TSqlLexerABSENT: {}, + TSqlLexerADMINISTER: {}, + TSqlLexerAES: {}, + TSqlLexerALLOW_CONNECTIONS: {}, + TSqlLexerALLOW_MULTIPLE_EVENT_LOSS: {}, + TSqlLexerALLOW_SINGLE_EVENT_LOSS: {}, + TSqlLexerANONYMOUS: {}, + TSqlLexerAPPEND: {}, + TSqlLexerAPPLICATION: {}, + TSqlLexerASYMMETRIC: {}, + TSqlLexerASYNCHRONOUS_COMMIT: {}, + TSqlLexerAUTHENTICATE: {}, + TSqlLexerAUTHENTICATION: {}, + TSqlLexerAUTOMATED_BACKUP_PREFERENCE: {}, + TSqlLexerAUTOMATIC: {}, + TSqlLexerAVAILABILITY_MODE: {}, + TSqlLexerBEFORE: {}, + TSqlLexerBLOCK: {}, + TSqlLexerBLOCKERS: {}, + TSqlLexerBLOCKSIZE: {}, + TSqlLexerBLOCKING_HIERARCHY: {}, + TSqlLexerBUFFER: {}, + TSqlLexerBUFFERCOUNT: {}, + TSqlLexerCACHE: {}, + TSqlLexerCALLED: {}, + TSqlLexerCERTIFICATE: {}, + TSqlLexerCHANGETABLE: {}, + TSqlLexerCHANGES: {}, + TSqlLexerCHECK_POLICY: {}, + TSqlLexerCHECK_EXPIRATION: {}, + TSqlLexerCLASSIFIER_FUNCTION: {}, + TSqlLexerCLUSTER: {}, + TSqlLexerCOMPRESS: {}, + TSqlLexerCOMPRESSION: {}, + TSqlLexerCONNECT: {}, + TSqlLexerCONNECTION: {}, + TSqlLexerCONFIGURATION: {}, + TSqlLexerCONNECTIONPROPERTY: {}, + TSqlLexerCONTAINMENT: {}, + TSqlLexerCONTEXT: {}, + TSqlLexerCONTEXT_INFO: {}, + TSqlLexerCONTINUE_AFTER_ERROR: {}, + TSqlLexerCONTRACT: {}, + TSqlLexerCONTRACT_NAME: {}, + TSqlLexerCONVERSATION: {}, + TSqlLexerCOPY_ONLY: {}, + TSqlLexerCURRENT_REQUEST_ID: {}, + TSqlLexerCURRENT_TRANSACTION_ID: {}, + TSqlLexerCYCLE: {}, + TSqlLexerDATA_COMPRESSION: {}, + TSqlLexerDATA_SOURCE: {}, + TSqlLexerDATABASE_MIRRORING: {}, + TSqlLexerDATASPACE: {}, + TSqlLexerDDL: {}, + TSqlLexerDECOMPRESS: {}, + TSqlLexerDEFAULT_DATABASE: {}, + TSqlLexerDEFAULT_SCHEMA: {}, + TSqlLexerDIAGNOSTICS: {}, + TSqlLexerDIFFERENTIAL: {}, + TSqlLexerDISTRIBUTION: {}, + TSqlLexerDTC_SUPPORT: {}, + TSqlLexerENABLED: {}, + TSqlLexerENDPOINT: {}, + TSqlLexerERROR: {}, + TSqlLexerERROR_LINE: {}, + TSqlLexerERROR_MESSAGE: {}, + TSqlLexerERROR_NUMBER: {}, + TSqlLexerERROR_PROCEDURE: {}, + TSqlLexerERROR_SEVERITY: {}, + TSqlLexerERROR_STATE: {}, + TSqlLexerEVENT: {}, + TSqlLexerEVENTDATA: {}, + TSqlLexerEVENT_RETENTION_MODE: {}, + TSqlLexerEXECUTABLE_FILE: {}, + TSqlLexerEXPIREDATE: {}, + TSqlLexerEXTENSION: {}, + TSqlLexerEXTERNAL_ACCESS: {}, + TSqlLexerFAILOVER: {}, + TSqlLexerFAILURECONDITIONLEVEL: {}, + TSqlLexerFAN_IN: {}, + TSqlLexerFILE_SNAPSHOT: {}, + TSqlLexerFORCESEEK: {}, + TSqlLexerFORCE_SERVICE_ALLOW_DATA_LOSS: {}, + TSqlLexerFORMATMESSAGE: {}, + TSqlLexerGET: {}, + TSqlLexerGET_FILESTREAM_TRANSACTION_CONTEXT: {}, + TSqlLexerGETANCESTOR: {}, + TSqlLexerGETANSINULL: {}, + TSqlLexerGETDESCENDANT: {}, + TSqlLexerGETLEVEL: {}, + TSqlLexerGETREPARENTEDVALUE: {}, + TSqlLexerGETROOT: {}, + TSqlLexerGOVERNOR: {}, + TSqlLexerHASHED: {}, + TSqlLexerHEALTHCHECKTIMEOUT: {}, + TSqlLexerHEAP: {}, + TSqlLexerHIERARCHYID: {}, + TSqlLexerHOST_ID: {}, + TSqlLexerHOST_NAME: {}, + TSqlLexerIIF: {}, + TSqlLexerIO: {}, + TSqlLexerINCLUDE: {}, + TSqlLexerINCREMENT: {}, + TSqlLexerINFINITE: {}, + TSqlLexerINIT: {}, + TSqlLexerINSTEAD: {}, + TSqlLexerISDESCENDANTOF: {}, + TSqlLexerISNULL: {}, + TSqlLexerISNUMERIC: {}, + TSqlLexerKERBEROS: {}, + TSqlLexerKEY_PATH: {}, + TSqlLexerKEY_STORE_PROVIDER_NAME: {}, + TSqlLexerLANGUAGE: {}, + TSqlLexerLIBRARY: {}, + TSqlLexerLIFETIME: {}, + TSqlLexerLINKED: {}, + TSqlLexerLINUX: {}, + TSqlLexerLISTENER_IP: {}, + TSqlLexerLISTENER_PORT: {}, + TSqlLexerLOCAL_SERVICE_NAME: {}, + TSqlLexerLOG: {}, + TSqlLexerMASK: {}, + TSqlLexerMATCHED: {}, + TSqlLexerMASTER: {}, + TSqlLexerMAX_MEMORY: {}, + TSqlLexerMAXTRANSFER: {}, + TSqlLexerMAXVALUE: {}, + TSqlLexerMAX_DISPATCH_LATENCY: {}, + TSqlLexerMAX_DURATION: {}, + TSqlLexerMAX_EVENT_SIZE: {}, + TSqlLexerMAX_SIZE: {}, + TSqlLexerMAX_OUTSTANDING_IO_PER_VOLUME: {}, + TSqlLexerMEDIADESCRIPTION: {}, + TSqlLexerMEDIANAME: {}, + TSqlLexerMEMBER: {}, + TSqlLexerMEMORY_PARTITION_MODE: {}, + TSqlLexerMESSAGE_FORWARDING: {}, + TSqlLexerMESSAGE_FORWARD_SIZE: {}, + TSqlLexerMINVALUE: {}, + TSqlLexerMIRROR: {}, + TSqlLexerMUST_CHANGE: {}, + TSqlLexerNEWID: {}, + TSqlLexerNEWSEQUENTIALID: {}, + TSqlLexerNOFORMAT: {}, + TSqlLexerNOINIT: {}, + TSqlLexerNONE: {}, + TSqlLexerNOREWIND: {}, + TSqlLexerNOSKIP: {}, + TSqlLexerNOUNLOAD: {}, + TSqlLexerNO_CHECKSUM: {}, + TSqlLexerNO_COMPRESSION: {}, + TSqlLexerNO_EVENT_LOSS: {}, + TSqlLexerNOTIFICATION: {}, + TSqlLexerNTLM: {}, + TSqlLexerOLD_PASSWORD: {}, + TSqlLexerON_FAILURE: {}, + TSqlLexerOPERATIONS: {}, + TSqlLexerPAGE: {}, + TSqlLexerPARAM_NODE: {}, + TSqlLexerPARTIAL: {}, + TSqlLexerPASSWORD: {}, + TSqlLexerPERMISSION_SET: {}, + TSqlLexerPER_CPU: {}, + TSqlLexerPER_DB: {}, + TSqlLexerPER_NODE: {}, + TSqlLexerPERSISTED: {}, + TSqlLexerPLATFORM: {}, + TSqlLexerPOLICY: {}, + TSqlLexerPREDICATE: {}, + TSqlLexerPROCESS: {}, + TSqlLexerPROFILE: {}, + TSqlLexerPYTHON: {}, + TSqlLexerR: {}, + TSqlLexerREAD_WRITE_FILEGROUPS: {}, + TSqlLexerREGENERATE: {}, + TSqlLexerRELATED_CONVERSATION: {}, + TSqlLexerRELATED_CONVERSATION_GROUP: {}, + TSqlLexerREQUIRED: {}, + TSqlLexerRESET: {}, + TSqlLexerRESOURCES: {}, + TSqlLexerRESTART: {}, + TSqlLexerRESUME: {}, + TSqlLexerRETAINDAYS: {}, + TSqlLexerRETURNS: {}, + TSqlLexerREWIND: {}, + TSqlLexerROLE: {}, + TSqlLexerROUND_ROBIN: {}, + TSqlLexerROWCOUNT_BIG: {}, + TSqlLexerRSA_512: {}, + TSqlLexerRSA_1024: {}, + TSqlLexerRSA_2048: {}, + TSqlLexerRSA_3072: {}, + TSqlLexerRSA_4096: {}, + TSqlLexerSAFETY: {}, + TSqlLexerSAFE: {}, + TSqlLexerSCHEDULER: {}, + TSqlLexerSCHEME: {}, + TSqlLexerSCRIPT: {}, + TSqlLexerSERVER: {}, + TSqlLexerSERVICE: {}, + TSqlLexerSERVICE_BROKER: {}, + TSqlLexerSERVICE_NAME: {}, + TSqlLexerSESSION: {}, + TSqlLexerSESSION_CONTEXT: {}, + TSqlLexerSETTINGS: {}, + TSqlLexerSHRINKLOG: {}, + TSqlLexerSID: {}, + TSqlLexerSKIP_KEYWORD: {}, + TSqlLexerSOFTNUMA: {}, + TSqlLexerSOURCE: {}, + TSqlLexerSPECIFICATION: {}, + TSqlLexerSPLIT: {}, + TSqlLexerSQL: {}, + TSqlLexerSQLDUMPERFLAGS: {}, + TSqlLexerSQLDUMPERPATH: {}, + TSqlLexerSQLDUMPERTIMEOUT: {}, + TSqlLexerSTATE: {}, + TSqlLexerSTATS: {}, + TSqlLexerSTART: {}, + TSqlLexerSTARTED: {}, + TSqlLexerSTARTUP_STATE: {}, + TSqlLexerSTOP: {}, + TSqlLexerSTOPPED: {}, + TSqlLexerSTOP_ON_ERROR: {}, + TSqlLexerSUPPORTED: {}, + TSqlLexerSWITCH: {}, + TSqlLexerTAPE: {}, + TSqlLexerTARGET: {}, + TSqlLexerTCP: {}, + TSqlLexerTOSTRING: {}, + TSqlLexerTRACE: {}, + TSqlLexerTRACK_CAUSALITY: {}, + TSqlLexerTRANSFER: {}, + TSqlLexerUNCHECKED: {}, + TSqlLexerUNLOCK: {}, + TSqlLexerUNSAFE: {}, + TSqlLexerURL: {}, + TSqlLexerUSED: {}, + TSqlLexerVERBOSELOGGING: {}, + TSqlLexerVISIBILITY: {}, + TSqlLexerWAIT_AT_LOW_PRIORITY: {}, + TSqlLexerWINDOWS: {}, + TSqlLexerWITHOUT: {}, + TSqlLexerWITNESS: {}, + TSqlLexerXACT_ABORT: {}, + TSqlLexerXACT_STATE: {}, + TSqlLexerABS: {}, + TSqlLexerACOS: {}, + TSqlLexerASIN: {}, + TSqlLexerATAN: {}, + TSqlLexerATN2: {}, + TSqlLexerCEILING: {}, + TSqlLexerCOS: {}, + TSqlLexerCOT: {}, + TSqlLexerDEGREES: {}, + TSqlLexerEXP: {}, + TSqlLexerFLOOR: {}, + TSqlLexerLOG10: {}, + TSqlLexerPI: {}, + TSqlLexerPOWER: {}, + TSqlLexerRADIANS: {}, + TSqlLexerRAND: {}, + TSqlLexerROUND: {}, + TSqlLexerSIGN: {}, + TSqlLexerSIN: {}, + TSqlLexerSQRT: {}, + TSqlLexerSQUARE: {}, + TSqlLexerTAN: {}, + TSqlLexerCURRENT_TIMEZONE: {}, + TSqlLexerCURRENT_TIMEZONE_ID: {}, + TSqlLexerDATE_BUCKET: {}, + TSqlLexerDATEDIFF_BIG: {}, + TSqlLexerDATEFROMPARTS: {}, + TSqlLexerDATETIME2FROMPARTS: {}, + TSqlLexerDATETIMEFROMPARTS: {}, + TSqlLexerDATETIMEOFFSETFROMPARTS: {}, + TSqlLexerDATETRUNC: {}, + TSqlLexerDAY: {}, + TSqlLexerEOMONTH: {}, + TSqlLexerISDATE: {}, + TSqlLexerMONTH: {}, + TSqlLexerSMALLDATETIMEFROMPARTS: {}, + TSqlLexerSWITCHOFFSET: {}, + TSqlLexerSYSDATETIME: {}, + TSqlLexerSYSDATETIMEOFFSET: {}, + TSqlLexerSYSUTCDATETIME: {}, + TSqlLexerTIMEFROMPARTS: {}, + TSqlLexerTODATETIMEOFFSET: {}, + TSqlLexerYEAR: {}, + TSqlLexerQUARTER: {}, + TSqlLexerDAYOFYEAR: {}, + TSqlLexerWEEK: {}, + TSqlLexerHOUR: {}, + TSqlLexerMINUTE: {}, + TSqlLexerSECOND: {}, + TSqlLexerMILLISECOND: {}, + TSqlLexerMICROSECOND: {}, + TSqlLexerNANOSECOND: {}, + TSqlLexerTZOFFSET: {}, + TSqlLexerISO_WEEK: {}, + TSqlLexerWEEKDAY: {}, + TSqlLexerYEAR_ABBR: {}, + TSqlLexerQUARTER_ABBR: {}, + TSqlLexerMONTH_ABBR: {}, + TSqlLexerDAYOFYEAR_ABBR: {}, + TSqlLexerDAY_ABBR: {}, + TSqlLexerWEEK_ABBR: {}, + TSqlLexerHOUR_ABBR: {}, + TSqlLexerMINUTE_ABBR: {}, + TSqlLexerSECOND_ABBR: {}, + TSqlLexerMILLISECOND_ABBR: {}, + TSqlLexerMICROSECOND_ABBR: {}, + TSqlLexerNANOSECOND_ABBR: {}, + TSqlLexerTZOFFSET_ABBR: {}, + TSqlLexerISO_WEEK_ABBR: {}, + TSqlLexerWEEKDAY_ABBR: {}, + TSqlLexerSP_EXECUTESQL: {}, + TSqlLexerVARCHAR: {}, + TSqlLexerNVARCHAR: {}, + TSqlLexerPRECISION: {}, + TSqlLexerFILESTREAM_ON: {}, +} \ No newline at end of file diff --git a/tsql/parser_test.go b/tsql/parser_test.go new file mode 100644 index 0000000..912f8af --- /dev/null +++ b/tsql/parser_test.go @@ -0,0 +1,151 @@ +package tsql_test + +import ( + "os" + "path" + "testing" + + "github.com/antlr4-go/antlr/v4" + tsql "github.com/bytebase/parser/tsql" + "github.com/stretchr/testify/require" +) + +type CustomErrorListener struct { + errors int +} + +func NewCustomErrorListener() *CustomErrorListener { + return new(CustomErrorListener) +} + +func (l *CustomErrorListener) SyntaxError(recognizer antlr.Recognizer, offendingSymbol interface{}, line, column int, msg string, e antlr.RecognitionException) { + l.errors += 1 + antlr.ConsoleErrorListenerINSTANCE.SyntaxError(recognizer, offendingSymbol, line, column, msg, e) +} + +func (l *CustomErrorListener) ReportAmbiguity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, exact bool, ambigAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) +} + +func (l *CustomErrorListener) ReportAttemptingFullContext(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, conflictingAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) +} + +func (l *CustomErrorListener) ReportContextSensitivity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex, prediction int, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) +} + +func TestTSQLParser(t *testing.T) { + examples, err := os.ReadDir("examples") + require.NoError(t, err) + + for _, file := range examples { + if file.Name() != "test.sql" { + continue + } + filePath := path.Join("examples", file.Name()) + t.Run(filePath, func(t *testing.T) { + t.Parallel() + input, err := antlr.NewFileStream(filePath) + require.NoError(t, err) + + lexer := tsql.NewTSqlLexer(input) + + stream := antlr.NewCommonTokenStream(lexer, 0) + p := tsql.NewTSqlParser(stream) + + lexerErrors := &CustomErrorListener{} + lexer.RemoveErrorListeners() + lexer.AddErrorListener(lexerErrors) + + parserErrors := &CustomErrorListener{} + p.RemoveErrorListeners() + p.AddErrorListener(parserErrors) + + p.BuildParseTrees = true + + _ = p.Tsql_file() + + require.Equal(t, 0, lexerErrors.errors) + require.Equal(t, 0, parserErrors.errors) + }) + } +} + +func TestSpatialIndexParser(t *testing.T) { + filePath := "examples/spatial_index.sql" + input, err := antlr.NewFileStream(filePath) + require.NoError(t, err) + + lexer := tsql.NewTSqlLexer(input) + + stream := antlr.NewCommonTokenStream(lexer, 0) + p := tsql.NewTSqlParser(stream) + + lexerErrors := &CustomErrorListener{} + lexer.RemoveErrorListeners() + lexer.AddErrorListener(lexerErrors) + + parserErrors := &CustomErrorListener{} + p.RemoveErrorListeners() + p.AddErrorListener(parserErrors) + + p.BuildParseTrees = true + + _ = p.Tsql_file() + + require.Equal(t, 0, lexerErrors.errors) + require.Equal(t, 0, parserErrors.errors) +} + +func TestDDLIndexParser(t *testing.T) { + filePath := "examples/ddl_index.sql" + input, err := antlr.NewFileStream(filePath) + require.NoError(t, err) + + lexer := tsql.NewTSqlLexer(input) + + stream := antlr.NewCommonTokenStream(lexer, 0) + p := tsql.NewTSqlParser(stream) + + lexerErrors := &CustomErrorListener{} + lexer.RemoveErrorListeners() + lexer.AddErrorListener(lexerErrors) + + parserErrors := &CustomErrorListener{} + p.RemoveErrorListeners() + p.AddErrorListener(parserErrors) + + p.BuildParseTrees = true + + _ = p.Tsql_file() + + require.Equal(t, 0, lexerErrors.errors) + require.Equal(t, 0, parserErrors.errors) +} + +func TestSpatialComprehensiveParser(t *testing.T) { + filePath := "examples/spatial_comprehensive.sql" + input, err := antlr.NewFileStream(filePath) + require.NoError(t, err) + + lexer := tsql.NewTSqlLexer(input) + + stream := antlr.NewCommonTokenStream(lexer, 0) + p := tsql.NewTSqlParser(stream) + + lexerErrors := &CustomErrorListener{} + lexer.RemoveErrorListeners() + lexer.AddErrorListener(lexerErrors) + + parserErrors := &CustomErrorListener{} + p.RemoveErrorListeners() + p.AddErrorListener(parserErrors) + + p.BuildParseTrees = true + + _ = p.Tsql_file() + + require.Equal(t, 0, lexerErrors.errors) + require.Equal(t, 0, parserErrors.errors) +} diff --git a/tsql/tsql_base_lexer.go b/tsql/tsql_base_lexer.go new file mode 100644 index 0000000..8b487ab --- /dev/null +++ b/tsql/tsql_base_lexer.go @@ -0,0 +1,33 @@ +package tsql + +import "github.com/antlr4-go/antlr/v4" + +type TSqlBaseLexer struct { + *antlr.BaseLexer +} + +func (l *TSqlBaseLexer) IsID_(tokenType int) bool { + switch tokenType { + case TSqlLexerID: + return true + case TSqlLexerTEMP_ID: + return true + case TSqlLexerDOUBLE_QUOTE_ID: + return true + case TSqlLexerDOUBLE_QUOTE_BLANK: + return true + case TSqlLexerSQUARE_BRACKET_ID: + return true + case TSqlLexerRAW: + return true + } + + return l.IsKeyword(tokenType) +} + +func (l *TSqlBaseLexer) IsKeyword(tokenType int) bool { + if _, ok := keywordMap[tokenType]; ok{ + return true + } + return false +} diff --git a/tsql/tsql_lexer.go b/tsql/tsql_lexer.go new file mode 100644 index 0000000..a2e236e --- /dev/null +++ b/tsql/tsql_lexer.go @@ -0,0 +1,8986 @@ +// Code generated from TSqlLexer.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package tsql + +import ( + "fmt" + "github.com/antlr4-go/antlr/v4" + "sync" + "unicode" +) + +// Suppress unused import error +var _ = fmt.Printf +var _ = sync.Once{} +var _ = unicode.IsLetter + +type TSqlLexer struct { + TSqlBaseLexer + channelNames []string + modeNames []string + // TODO: EOF string +} + +var TSqlLexerLexerStaticData struct { + once sync.Once + serializedATN []int32 + ChannelNames []string + ModeNames []string + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func tsqllexerLexerInit() { + staticData := &TSqlLexerLexerStaticData + staticData.ChannelNames = []string{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", + } + staticData.ModeNames = []string{ + "DEFAULT_MODE", + } + staticData.LiteralNames = []string{ + "", "'ABORT'", "'ABORT_AFTER_WAIT'", "'ABSENT'", "'ABSOLUTE'", "'ACCELERATED_DATABASE_RECOVERY'", + "'ACCENT_SENSITIVITY'", "'ACCESS'", "'ACTION'", "'ACTIVATION'", "'ACTIVE'", + "'ADD'", "'ADDRESS'", "'ADMINISTER'", "'AES'", "'AES_128'", "'AES_192'", + "'AES_256'", "'AFFINITY'", "'AFTER'", "'AGGREGATE'", "'ALGORITHM'", + "'ALL'", "'ALLOWED'", "'ALLOW_CONNECTIONS'", "'ALLOW_ENCRYPTED_VALUE_MODIFICATIONS'", + "'ALLOW_MULTIPLE_EVENT_LOSS'", "'ALLOW_PAGE_LOCKS'", "'ALLOW_ROW_LOCKS'", + "'ALLOW_SINGLE_EVENT_LOSS'", "'ALLOW_SNAPSHOT_ISOLATION'", "'ALL_CONSTRAINTS'", + "'ALL_ERRORMSGS'", "'ALL_INDEXES'", "'ALL_LEVELS'", "'ALTER'", "'ALWAYS'", + "'AND'", "'ANONYMOUS'", "'ANSI_DEFAULTS'", "'ANSI_NULLS'", "'ANSI_NULL_DEFAULT'", + "'ANSI_NULL_DFLT_OFF'", "'ANSI_NULL_DFLT_ON'", "'ANSI_PADDING'", "'ANSI_WARNINGS'", + "'ANY'", "'APPEND'", "'APPLICATION'", "'APPLICATION_LOG'", "'APPLOCK_MODE'", + "'APPLOCK_TEST'", "'APPLY'", "'APP_NAME'", "'ARITHABORT'", "'ARITHIGNORE'", + "'AS'", "'ASC'", "'ASCII'", "'ASSEMBLY'", "'ASSEMBLYPROPERTY'", "'ASYMMETRIC'", + "'ASYNCHRONOUS_COMMIT'", "'AT'", "'AUDIT'", "'AUDIT_GUID'", "'AUTHENTICATE'", + "'AUTHENTICATION'", "'AUTHORIZATION'", "'AUTO'", "'AUTOGROW_ALL_FILES'", + "'AUTOGROW_SINGLE_FILE'", "'AUTOMATED_BACKUP_PREFERENCE'", "'AUTOMATIC'", + "'AUTO_CLEANUP'", "'AUTO_CLOSE'", "'AUTO_CREATE_STATISTICS'", "'AUTO_DROP'", + "'AUTO_SHRINK'", "'AUTO_UPDATE_STATISTICS'", "'AUTO_UPDATE_STATISTICS_ASYNC'", + "'AVAILABILITY'", "'AVAILABILITY_MODE'", "'AVG'", "'\\'", "'BACKUP'", + "'BACKUP_CLONEDB'", "'BACKUP_PRIORITY'", "'BASE64'", "'BEFORE'", "'BEGIN'", + "'BEGIN_DIALOG'", "'BETWEEN'", "'BIGINT'", "'BINARY_CHECKSUM'", "'BINARY'", + "'BINDING'", "'BLOB_STORAGE'", "'BLOCK'", "'BLOCKERS'", "'BLOCKING_HIERARCHY'", + "'BLOCKSIZE'", "'BOUNDING_BOX'", "'BREAK'", "'BROKER'", "'BROKER_INSTANCE'", + "'BROWSE'", "'BUFFER'", "'BUFFERCOUNT'", "'BULK'", "'BULK_LOGGED'", + "'BY'", "'CACHE'", "'CALLED'", "'CALLER'", "'CAP_CPU_PERCENT'", "'CASCADE'", + "'CASE'", "'CAST'", "'CATALOG'", "'CATCH'", "'CELLS_PER_OBJECT'", "'CERTENCODED'", + "'CERTIFICATE'", "'CERTPRIVATEKEY'", "'CERT_ID'", "'CHANGE'", "'CHANGES'", + "'CHANGETABLE'", "'CHANGE_RETENTION'", "'CHANGE_TRACKING'", "'CHAR'", + "'CHARINDEX'", "'CHECK'", "'CHECKALLOC'", "'CHECKCATALOG'", "'CHECKCONSTRAINTS'", + "'CHECKDB'", "'CHECKFILEGROUP'", "'CHECKPOINT'", "'CHECKSUM'", "'CHECKSUM_AGG'", + "'CHECKTABLE'", "'CHECK_EXPIRATION'", "'CHECK_POLICY'", "'CLASSIFIER_FUNCTION'", + "'CLEANTABLE'", "'CLEANUP'", "'CLONEDATABASE'", "'CLOSE'", "'CLUSTER'", + "'CLUSTERED'", "'COALESCE'", "'COLLATE'", "'COLLECTION'", "'COLUMN'", + "'COLUMNPROPERTY'", "'COLUMNS'", "'COLUMNSTORE'", "'COLUMNSTORE_ARCHIVE'", + "'COLUMN_ENCRYPTION_KEY'", "'COLUMN_MASTER_KEY'", "'COL_LENGTH'", "'COL_NAME'", + "'COMMIT'", "'COMMITTED'", "'COMPATIBILITY_LEVEL'", "'COMPRESS'", "'COMPRESSION'", + "'COMPRESSION_DELAY'", "'COMPRESS_ALL_ROW_GROUPS'", "'COMPUTE'", "'CONCAT'", + "'CONCAT_NULL_YIELDS_NULL'", "'CONCAT_WS'", "'CONFIGURATION'", "'CONNECT'", + "'CONNECTION'", "'CONNECTIONPROPERTY'", "'CONSTRAINT'", "'CONTAINMENT'", + "'CONTAINS'", "'CONTAINSTABLE'", "'CONTENT'", "'CONTEXT'", "'CONTEXT_INFO'", + "'CONTINUE'", "'CONTINUE_AFTER_ERROR'", "'CONTRACT'", "'CONTRACT_NAME'", + "'CONTROL'", "'CONVERSATION'", "", "'COOKIE'", "'COPY_ONLY'", "'COUNT'", + "'COUNTER'", "'COUNT_BIG'", "'CPU'", "'CREATE'", "'CREATE_NEW'", "'CREATION_DISPOSITION'", + "'CREDENTIAL'", "'CROSS'", "'CRYPTOGRAPHIC'", "'CUME_DIST'", "'CURRENT'", + "'CURRENT_DATE'", "'CURRENT_REQUEST_ID'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", + "'CURRENT_TRANSACTION_ID'", "'CURRENT_USER'", "'CURSOR'", "'CURSOR_CLOSE_ON_COMMIT'", + "'CURSOR_DEFAULT'", "'CURSOR_STATUS'", "'CYCLE'", "'DATA'", "'DATABASE'", + "'DATABASEPROPERTYEX'", "'DATABASE_MIRRORING'", "'DATABASE_PRINCIPAL_ID'", + "'DATALENGTH'", "'DATASPACE'", "'DATA_COMPRESSION'", "'DATA_PURITY'", + "'DATA_SOURCE'", "'DATEADD'", "'DATEDIFF'", "'DATENAME'", "'DATEPART'", + "'DATE_CORRELATION_OPTIMIZATION'", "'DAYS'", "'DBCC'", "'DBREINDEX'", + "'DB_CHAINING'", "'DB_FAILOVER'", "'DB_ID'", "'DB_NAME'", "'DDL'", "'DEALLOCATE'", + "'DECLARE'", "'DECOMPRESS'", "'DECRYPTION'", "'DEFAULT'", "'DEFAULT_DATABASE'", + "", "'DEFAULT_FULLTEXT_LANGUAGE'", "'DEFAULT_LANGUAGE'", "'DEFAULT_SCHEMA'", + "'DEFINITION'", "'DELAY'", "'DELAYED_DURABILITY'", "'DELETE'", "'DELETED'", + "'DENSE_RANK'", "'DENY'", "'DEPENDENTS'", "'DES'", "'DESC'", "'DESCRIPTION'", + "'DESX'", "'DETERMINISTIC'", "'DHCP'", "'DIAGNOSTICS'", "'DIALOG'", + "'DIFFERENCE'", "'DIFFERENTIAL'", "'DIRECTORY_NAME'", "'DISABLE'", "'DISABLED'", + "'DISABLE_BROKER'", "'DISK'", "'DISTINCT'", "'DISTRIBUTED'", "'DISTRIBUTION'", + "'DOCUMENT'", "'$PARTITION'", "'DOUBLE'", "'\\\\'", "'//'", "'DROP'", + "'DROPCLEANBUFFERS'", "'DROP_EXISTING'", "'DTC_SUPPORT'", "'DUMP'", + "'DYNAMIC'", "'ELEMENTS'", "'ELSE'", "'EMERGENCY'", "'EMPTY'", "'ENABLE'", + "'ENABLED'", "'ENABLE_BROKER'", "'ENCRYPTED'", "'ENCRYPTED_VALUE'", + "'ENCRYPTION'", "'ENCRYPTION_TYPE'", "'END'", "'ENDPOINT'", "'ENDPOINT_URL'", + "'ERRLVL'", "'ERROR'", "'ERROR_BROKER_CONVERSATIONS'", "'ERROR_LINE'", + "'ERROR_MESSAGE'", "'ERROR_NUMBER'", "'ERROR_PROCEDURE'", "'ERROR_SEVERITY'", + "'ERROR_STATE'", "'ESCAPE'", "'ESTIMATEONLY'", "'EVENT'", "'EVENTDATA'", + "'EVENT_RETENTION_MODE'", "'EXCEPT'", "'EXCLUSIVE'", "'EXECUTABLE'", + "'EXECUTABLE_FILE'", "", "'EXIST'", "'EXISTS'", "'[EXIST]'", "'EXIT'", + "'EXPAND'", "'EXPIREDATE'", "'EXPIRY_DATE'", "'EXPLICIT'", "'EXTENDED_LOGICAL_CHECKS'", + "'EXTENSION'", "'EXTERNAL'", "'EXTERNAL_ACCESS'", "'FAILOVER'", "'FAILOVER_MODE'", + "'FAILURE'", "'FAILURECONDITIONLEVEL'", "'FAILURE_CONDITION_LEVEL'", + "'FAIL_OPERATION'", "'FAN_IN'", "'FAST'", "'FAST_FORWARD'", "'FETCH'", + "'FILE'", "'FILEGROUP'", "'FILEGROUPPROPERTY'", "'FILEGROUP_ID'", "'FILEGROUP_NAME'", + "'FILEGROWTH'", "'FILENAME'", "'FILEPATH'", "'FILEPROPERTY'", "'FILEPROPERTYEX'", + "'FILESTREAM'", "'FILESTREAM_ON'", "'FILE_ID'", "'FILE_IDEX'", "'FILE_NAME'", + "'FILE_SNAPSHOT'", "'FILLFACTOR'", "'FILTER'", "'FIRST'", "'FIRST_VALUE'", + "'FMTONLY'", "'FOLLOWING'", "'FOR'", "'FORCE'", "'FORCED'", "'FORCEPLAN'", + "'FORCESCAN'", "'FORCESEEK'", "'FORCE_FAILOVER_ALLOW_DATA_LOSS'", "'FORCE_SERVICE_ALLOW_DATA_LOSS'", + "'FOREIGN'", "'FORMAT'", "'FORMATMESSAGE'", "'FORWARD_ONLY'", "'FREE'", + "'FREETEXT'", "'FREETEXTTABLE'", "'FROM'", "'FULL'", "'FULLSCAN'", "'FULLTEXT'", + "'FULLTEXTCATALOGPROPERTY'", "'FULLTEXTSERVICEPROPERTY'", "'FUNCTION'", + "'GB'", "'GENERATED'", "'GEOGRAPHY'", "'GEOGRAPHY_AUTO_GRID'", "'GEOGRAPHY_GRID'", + "'GEOMETRY'", "'GEOMETRY_AUTO_GRID'", "'GEOMETRY_GRID'", "'GET'", "'GRIDS'", + "'GETANCESTOR'", "'GETANSINULL'", "'GETDATE'", "'GETDESCENDANT'", "'GETLEVEL'", + "'GETREPARENTEDVALUE'", "'GETROOT'", "'GETUTCDATE'", "'GET_FILESTREAM_TRANSACTION_CONTEXT'", + "'GLOBAL'", "'GO'", "'GOTO'", "'GOVERNOR'", "'GRANT'", "'GREATEST'", + "'GROUP'", "'GROUPING'", "'GROUPING_ID'", "'GROUP_MAX_REQUESTS'", "'HADR'", + "'HASH'", "'HASHED'", "'HAS_DBACCESS'", "'HAS_PERMS_BY_NAME'", "'HAVING'", + "'HEALTHCHECKTIMEOUT'", "'HEALTH_CHECK_TIMEOUT'", "'HEAP'", "'HIDDEN'", + "'HIERARCHYID'", "'HIGH'", "'HOLDLOCK'", "'HONOR_BROKER_PRIORITY'", + "'HOST_ID'", "'HOST_NAME'", "'HOURS'", "'IDENTITY'", "'IDENTITYCOL'", + "'IDENTITY_INSERT'", "'IDENTITY_VALUE'", "'IDENT_CURRENT'", "'IDENT_INCR'", + "'IDENT_SEED'", "'IF'", "'IGNORE_CONSTRAINTS'", "'IGNORE_DUP_KEY'", + "'IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX'", "'IGNORE_REPLICATED_TABLE_CACHE'", + "'IGNORE_TRIGGERS'", "'IIF'", "'IMMEDIATE'", "'IMPERSONATE'", "'IMPLICIT_TRANSACTIONS'", + "'IMPORTANCE'", "'IN'", "'INCLUDE'", "'INCLUDE_NULL_VALUES'", "'INCREMENT'", + "'INCREMENTAL'", "'INDEX'", "'INDEXKEY_PROPERTY'", "'INDEXPROPERTY'", + "'INDEX_COL'", "'INFINITE'", "'INIT'", "'INITIATOR'", "'INNER'", "'INPUT'", + "'INSENSITIVE'", "'INSERT'", "'INSERTED'", "'INSTEAD'", "'INT'", "'INTERSECT'", + "'INTO'", "'IO'", "'IP'", "'IS'", "'ISDESCENDANTOF'", "'ISJSON'", "'ISNULL'", + "'ISNUMERIC'", "'ISOLATION'", "'IS_MEMBER'", "'IS_ROLEMEMBER'", "'IS_SRVROLEMEMBER'", + "'JOB'", "'JOIN'", "'JSON'", "'JSON_ARRAY'", "'JSON_MODIFY'", "'JSON_OBJECT'", + "'JSON_PATH_EXISTS'", "'JSON_QUERY'", "'JSON_VALUE'", "'KB'", "'KEEP'", + "'KEEPDEFAULTS'", "'KEEPFIXED'", "'KEEPIDENTITY'", "'KERBEROS'", "'KEY'", + "'KEYS'", "'KEYSET'", "'KEY_PATH'", "'KEY_SOURCE'", "'KEY_STORE_PROVIDER_NAME'", + "'KILL'", "'LAG'", "'LANGUAGE'", "'LAST'", "'LAST_VALUE'", "'LEAD'", + "'LEAST'", "'LEFT'", "'LEN'", "'LEVEL'", "'LEVEL_1'", "'LEVEL_2'", "'LEVEL_3'", + "'LEVEL_4'", "'LIBRARY'", "'LIFETIME'", "'LIKE'", "'LINENO'", "'LINKED'", + "'LINUX'", "'LIST'", "'LISTENER'", "'LISTENER_IP'", "'LISTENER_PORT'", + "'LISTENER_URL'", "'LOAD'", "'LOB_COMPACTION'", "'LOCAL'", "'LOCAL_SERVICE_NAME'", + "'LOCATION'", "'LOCK'", "'LOCK_ESCALATION'", "'LOG'", "'LOGIN'", "'LOGINPROPERTY'", + "'LOOP'", "'LOW'", "'LOWER'", "'LTRIM'", "'MANUAL'", "'MARK'", "'MASK'", + "'MASKED'", "'MASTER'", "'MATCHED'", "'MATERIALIZED'", "'MAX'", "'MAXDOP'", + "'MAXRECURSION'", "'MAXSIZE'", "'MAXTRANSFER'", "'MAXVALUE'", "'MAX_CPU_PERCENT'", + "'MAX_DISPATCH_LATENCY'", "'MAX_DOP'", "'MAX_DURATION'", "'MAX_EVENT_SIZE'", + "'MAX_FILES'", "'MAX_IOPS_PER_VOLUME'", "'MAX_MEMORY'", "'MAX_MEMORY_PERCENT'", + "'MAX_OUTSTANDING_IO_PER_VOLUME'", "'MAX_PROCESSES'", "'MAX_QUEUE_READERS'", + "'MAX_ROLLOVER_FILES'", "'MAX_SIZE'", "'MB'", "'MEDIADESCRIPTION'", + "'MEDIANAME'", "'MEDIUM'", "'MEMBER'", "'MEMORY_OPTIMIZED_DATA'", "'MEMORY_PARTITION_MODE'", + "'MERGE'", "'MESSAGE'", "'MESSAGE_FORWARDING'", "'MESSAGE_FORWARD_SIZE'", + "'MIN'", "'MINUTES'", "'MINVALUE'", "'MIN_ACTIVE_ROWVERSION'", "'MIN_CPU_PERCENT'", + "'MIN_IOPS_PER_VOLUME'", "'MIN_MEMORY_PERCENT'", "'MIRROR'", "'MIRROR_ADDRESS'", + "'MIXED_PAGE_ALLOCATION'", "'MODE'", "'MODIFY'", "'[MODIFY]'", "'MOVE'", + "'MULTI_USER'", "'MUST_CHANGE'", "'NAME'", "'NATIONAL'", "'NCHAR'", + "'NEGOTIATE'", "'NESTED_TRIGGERS'", "'NEWID'", "'NEWNAME'", "'NEWSEQUENTIALID'", + "'NEW_ACCOUNT'", "'NEW_BROKER'", "'NEW_PASSWORD'", "'NEXT'", "'NO'", + "'NOCHECK'", "'NOCOUNT'", "'NODES'", "'NOEXEC'", "'NOEXPAND'", "'NOFORMAT'", + "'NOHOLDLOCK'", "'NOINDEX'", "'NOINIT'", "'NOLOCK'", "'NONCLUSTERED'", + "'NONE'", "'NON_TRANSACTED_ACCESS'", "'NORECOMPUTE'", "'NORECOVERY'", + "'NOREWIND'", "'NOSKIP'", "'NOT'", "'NOTIFICATION'", "'NOTIFICATIONS'", + "'NOUNLOAD'", "'NOWAIT'", "'NO_CHECKSUM'", "'NO_COMPRESSION'", "'NO_EVENT_LOSS'", + "'NO_INFOMSGS'", "'NO_QUERYSTORE'", "'NO_STATISTICS'", "'NO_TRUNCATE'", + "'NO_WAIT'", "'NTILE'", "'NTLM'", "'NULLIF'", "'NULL'", "", "'NUMANODE'", + "'NUMBER'", "'NUMERIC_ROUNDABORT'", "'OBJECT'", "'OBJECTPROPERTY'", + "'OBJECTPROPERTYEX'", "'OBJECT_DEFINITION'", "'OBJECT_ID'", "'OBJECT_NAME'", + "'OBJECT_SCHEMA_NAME'", "'OF'", "'OFF'", "'OFFLINE'", "'OFFSET'", "'OFFSETS'", + "'OLD_ACCOUNT'", "'OLD_PASSWORD'", "'ON'", "'ONLINE'", "'ONLY'", "'ON_FAILURE'", + "'OPEN'", "'OPENDATASOURCE'", "'OPENJSON'", "'OPENQUERY'", "'OPENROWSET'", + "'OPENXML'", "'OPEN_EXISTING'", "'OPERATIONS'", "'OPTIMISTIC'", "'OPTIMIZE'", + "'OPTIMIZE_FOR_SEQUENTIAL_KEY'", "'OPTION'", "'OR'", "'ORDER'", "'ORIGINAL_DB_NAME'", + "'ORIGINAL_LOGIN'", "'OUT'", "'OUTER'", "'OUTPUT'", "'OVER'", "'OVERRIDE'", + "'OWNER'", "'OWNERSHIP'", "'PAD_INDEX'", "'PAGE'", "'PAGECOUNT'", "'PAGE_VERIFY'", + "'PAGLOCK'", "'PARAMETERIZATION'", "'PARAM_NODE'", "", "'PARSENAME'", + "'PARSEONLY'", "'PARTIAL'", "'PARTITION'", "'PARTITIONS'", "'PARTNER'", + "'PASSWORD'", "'PATH'", "'PATINDEX'", "'PAUSE'", "'PDW_SHOWSPACEUSED'", + "'PERCENT'", "'PERCENTILE_CONT'", "'PERCENTILE_DISC'", "'PERCENT_RANK'", + "'PERMISSIONS'", "'PERMISSION_SET'", "'PERSISTED'", "'PERSIST_SAMPLE_PERCENT'", + "'PER_CPU'", "'PER_DB'", "'PER_NODE'", "'PHYSICAL_ONLY'", "'PIVOT'", + "'PLAN'", "'PLATFORM'", "'POISON_MESSAGE_HANDLING'", "'POLICY'", "'POOL'", + "'PORT'", "'PRECEDING'", "'PRECISION'", "'PREDICATE'", "'PRIMARY'", + "'PRIMARY_ROLE'", "'PRINT'", "'PRIOR'", "'PRIORITY'", "'PRIORITY_LEVEL'", + "'PRIVATE'", "'PRIVATE_KEY'", "'PRIVILEGES'", "'PROC'", "'PROCCACHE'", + "'PROCEDURE'", "'PROCEDURE_NAME'", "'PROCESS'", "'PROFILE'", "'PROPERTY'", + "'PROVIDER'", "'PROVIDER_KEY_NAME'", "'PUBLIC'", "'PWDCOMPARE'", "'PWDENCRYPT'", + "'PYTHON'", "'QUERY'", "'[QUERY]'", "'QUEUE'", "'QUEUE_DELAY'", "'QUOTED_IDENTIFIER'", + "'QUOTENAME'", "'R'", "'RAISERROR'", "'RANDOMIZED'", "'RANGE'", "'RANK'", + "'RAW'", "'RC2'", "'RC4'", "'RC4_128'", "'READ'", "'READCOMMITTED'", + "'READCOMMITTEDLOCK'", "'READONLY'", "'READPAST'", "'READTEXT'", "'READUNCOMMITTED'", + "'READWRITE'", "'READ_COMMITTED_SNAPSHOT'", "'READ_ONLY'", "'READ_ONLY_ROUTING_LIST'", + "'READ_WRITE'", "'READ_WRITE_FILEGROUPS'", "'REBUILD'", "'RECEIVE'", + "'RECOMPILE'", "'RECONFIGURE'", "'RECOVERY'", "'RECURSIVE_TRIGGERS'", + "'REFERENCES'", "'REGENERATE'", "'RELATED_CONVERSATION'", "'RELATED_CONVERSATION_GROUP'", + "'RELATIVE'", "'REMOTE'", "'REMOTE_PROC_TRANSACTIONS'", "'REMOTE_SERVICE_NAME'", + "'REMOVE'", "'REORGANIZE'", "'REPAIR_ALLOW_DATA_LOSS'", "'REPAIR_FAST'", + "'REPAIR_REBUILD'", "'REPEATABLE'", "'REPEATABLEREAD'", "'REPLACE'", + "'REPLICA'", "'REPLICATE'", "'REPLICATION'", "'REQUEST_MAX_CPU_TIME_SEC'", + "'REQUEST_MAX_MEMORY_GRANT_PERCENT'", "'REQUEST_MEMORY_GRANT_TIMEOUT_SEC'", + "'REQUIRED'", "'REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT'", "'RESAMPLE'", + "'RESERVE_DISK_SPACE'", "'RESET'", "'RESOURCE'", "'RESOURCES'", "'RESOURCE_MANAGER_LOCATION'", + "'RESTART'", "'RESTORE'", "'RESTRICT'", "'RESTRICTED_USER'", "'RESUMABLE'", + "'RESUME'", "'RETAINDAYS'", "'RETENTION'", "'RETURN'", "'RETURNS'", + "'REVERSE'", "'REVERT'", "'REVOKE'", "'REWIND'", "'RIGHT'", "'ROBUST'", + "'ROLE'", "'ROLLBACK'", "'ROOT'", "'ROUND_ROBIN'", "'ROUTE'", "'ROW'", + "'ROWCOUNT'", "'ROWCOUNT_BIG'", "'ROWGUID'", "'ROWGUIDCOL'", "'ROWLOCK'", + "'ROWS'", "'ROW_NUMBER'", "'RSA_1024'", "'RSA_2048'", "'RSA_3072'", + "'RSA_4096'", "'RSA_512'", "'RTRIM'", "'RULE'", "'SAFE'", "'SAFETY'", + "'SAMPLE'", "'SAVE'", "'SCHEDULER'", "'SCHEMA'", "'SCHEMABINDING'", + "'SCHEMA_ID'", "'SCHEMA_NAME'", "'SCHEME'", "'SCOPED'", "'SCOPE_IDENTITY'", + "'SCRIPT'", "'SCROLL'", "'SCROLL_LOCKS'", "'SEARCH'", "'SECONDARY'", + "'SECONDARY_ONLY'", "'SECONDARY_ROLE'", "'SECONDS'", "'SECRET'", "'SECURABLES'", + "'SECURITY'", "'SECURITYAUDIT'", "'SECURITY_LOG'", "'SEEDING_MODE'", + "'SELECT'", "'SELF'", "'SEMANTICKEYPHRASETABLE'", "'SEMANTICSIMILARITYDETAILSTABLE'", + "'SEMANTICSIMILARITYTABLE'", "'SEMI_SENSITIVE'", "'SEND'", "'SENT'", + "'SEQUENCE'", "'SEQUENCE_NUMBER'", "'SERIALIZABLE'", "'SERVER'", "'SERVERPROPERTY'", + "'SERVICE'", "'SERVICEBROKER'", "'SERVICE_BROKER'", "'SERVICE_NAME'", + "'SESSION'", "'SESSIONPROPERTY'", "'SESSION_CONTEXT'", "'SESSION_TIMEOUT'", + "'SESSION_USER'", "'SET'", "'SETERROR'", "'SETS'", "'SETTINGS'", "'SETUSER'", + "'SHARE'", "'SHARED'", "'SHOWCONTIG'", "'SHOWPLAN'", "'SHOWPLAN_ALL'", + "'SHOWPLAN_TEXT'", "'SHOWPLAN_XML'", "'SHRINKLOG'", "'SHUTDOWN'", "'SID'", + "'SIGNATURE'", "'SIMPLE'", "'SINGLE_USER'", "'SIZE'", "'SKIP'", "'SMALLINT'", + "'SNAPSHOT'", "'SOFTNUMA'", "'SOME'", "'SORT_IN_TEMPDB'", "'SOUNDEX'", + "'SOURCE'", "'SPACE'", "'SPARSE'", "'SPATIAL'", "'SPATIAL_WINDOW_MAX_CELLS'", + "'SPECIFICATION'", "'SPLIT'", "'SQL'", "'SQLDUMPERFLAGS'", "'SQLDUMPERPATH'", + "'SQLDUMPERTIMEOUT'", "'SQL_VARIANT_PROPERTY'", "'STANDBY'", "'START'", + "'STARTED'", "'STARTUP_STATE'", "'START_DATE'", "'STATE'", "'STATIC'", + "'STATISTICS'", "'STATISTICS_INCREMENTAL'", "'STATISTICS_NORECOMPUTE'", + "'STATS'", "'STATS_DATE'", "'STATS_STREAM'", "'STATUS'", "'STATUSONLY'", + "'STDEV'", "'STDEVP'", "'STOP'", "'STOPLIST'", "'STOPPED'", "'STOP_ON_ERROR'", + "'STR'", "'STRING_AGG'", "'STRING_ESCAPE'", "'STUFF'", "'SUBJECT'", + "'SUBSCRIBE'", "'SUBSCRIPTION'", "'SUBSTRING'", "'SUM'", "'SUPPORTED'", + "'SUSER_ID'", "'SUSER_NAME'", "'SUSER_SID'", "'SUSER_SNAME'", "'SUSPEND'", + "'SWITCH'", "'SYMMETRIC'", "'SYNCHRONOUS_COMMIT'", "'SYNONYM'", "'SYSTEM'", + "'SYSTEM_USER'", "'TABLE'", "'TABLERESULTS'", "'TABLESAMPLE'", "'TABLOCK'", + "'TABLOCKX'", "'TAKE'", "'TAPE'", "'TARGET'", "'TARGET_RECOVERY_TIME'", + "'TB'", "'TCP'", "'TEXTIMAGE_ON'", "'TEXTSIZE'", "'THEN'", "'THROW'", + "'TIES'", "'TIME'", "'TIMEOUT'", "'TIMER'", "'TINYINT'", "'TO'", "'TOP'", + "'TORN_PAGE_DETECTION'", "'TOSTRING'", "'TRACE'", "'TRACKING'", "'TRACK_CAUSALITY'", + "'TRAN'", "'TRANSACTION'", "'TRANSACTION_ID'", "'TRANSFER'", "'TRANSFORM_NOISE_WORDS'", + "'TRANSLATE'", "'TRIGGER'", "'TRIM'", "'TRIPLE_DES'", "'TRIPLE_DES_3KEY'", + "'TRUNCATE'", "'TRUSTWORTHY'", "'TRY'", "'TRY_CAST'", "'TSEQUAL'", "'TSQL'", + "'TWO_DIGIT_YEAR_CUTOFF'", "'TYPE'", "'TYPEPROPERTY'", "'TYPE_ID'", + "'TYPE_NAME'", "'TYPE_WARNING'", "'UNBOUNDED'", "'UNCHECKED'", "'UNCOMMITTED'", + "'UNICODE'", "'UNION'", "'UNIQUE'", "'UNKNOWN'", "'UNLIMITED'", "'UNLOCK'", + "'UNMASK'", "'UNPIVOT'", "'UNSAFE'", "'UOW'", "'UPDATE'", "'UPDATETEXT'", + "'UPDLOCK'", "'UPPER'", "'URL'", "'USE'", "'USED'", "'USER'", "'USER_ID'", + "'USER_NAME'", "'USING'", "'VALIDATION'", "'VALID_XML'", "'VALUE'", + "'VALUES'", "'[VALUE]'", "'VAR'", "'VARBINARY'", "'VARP'", "'VARYING'", + "'VERBOSELOGGING'", "'VERIFY_CLONEDB'", "'VERSION'", "'VIEW'", "'VIEWS'", + "'VIEW_METADATA'", "'VISIBILITY'", "'WAIT'", "'WAITFOR'", "'WAIT_AT_LOW_PRIORITY'", + "'WELL_FORMED_XML'", "'WHEN'", "'WHERE'", "'WHILE'", "'WINDOWS'", "'WITH'", + "'WITHIN'", "'WITHOUT'", "'WITHOUT_ARRAY_WRAPPER'", "'WITNESS'", "'WORK'", + "'WORKLOAD'", "'WRITETEXT'", "'XACT_ABORT'", "'XACT_STATE'", "'XLOCK'", + "'XML'", "'XMLDATA'", "'XMLNAMESPACES'", "'XMLSCHEMA'", "'XML_COMPRESSION'", + "'XSINIL'", "'ZONE'", "'ABS'", "'ACOS'", "'ASIN'", "'ATAN'", "'ATN2'", + "'CEILING'", "'COS'", "'COT'", "'DEGREES'", "'EXP'", "'FLOOR'", "'LOG10'", + "'PI'", "'POWER'", "'RADIANS'", "'RAND'", "'ROUND'", "'SIGN'", "'SIN'", + "'SQRT'", "'SQUARE'", "'TAN'", "'CURRENT_TIMEZONE'", "'CURRENT_TIMEZONE_ID'", + "'DATE_BUCKET'", "'DATEDIFF_BIG'", "'DATEFROMPARTS'", "'DATETIME2FROMPARTS'", + "'DATETIMEFROMPARTS'", "'DATETIMEOFFSETFROMPARTS'", "'DATETRUNC'", "'DAY'", + "'EOMONTH'", "'ISDATE'", "'MONTH'", "'SMALLDATETIMEFROMPARTS'", "'SWITCHOFFSET'", + "'SYSDATETIME'", "'SYSDATETIMEOFFSET'", "'SYSUTCDATETIME'", "'TIMEFROMPARTS'", + "'TODATETIMEOFFSET'", "'YEAR'", "'QUARTER'", "'DAYOFYEAR'", "'WEEK'", + "'HOUR'", "'MINUTE'", "'SECOND'", "'MILLISECOND'", "'MICROSECOND'", + "'NANOSECOND'", "'TZOFFSET'", "'ISO_WEEK'", "'WEEKDAY'", "", "", "", + "", "", "", "'hh'", "", "", "'ms'", "'mcs'", "'ns'", "'tz'", "", "'dw'", + "'SP_EXECUTESQL'", "'VARCHAR'", "'NVARCHAR'", "", "'$ACTION'", "'@@CURSOR_ROWS'", + "'@@FETCH_STATUS'", "", "", "", "", "", "'\"\"'", "'''", "", "", "", + "", "", "", "", "", "", "'='", "'>'", "'<'", "'!'", "'+='", "'-='", + "'*='", "'/='", "'%='", "'&='", "'^='", "'|='", "'||'", "'.'", "'_'", + "'@'", "'#'", "'$'", "'('", "')'", "','", "';'", "':'", "'::'", "'*'", + "'/'", "'%'", "'+'", "'-'", "'~'", "'|'", "'&'", "'^'", "'?'", + } + staticData.SymbolicNames = []string{ + "", "ABORT", "ABORT_AFTER_WAIT", "ABSENT", "ABSOLUTE", "ACCELERATED_DATABASE_RECOVERY", + "ACCENT_SENSITIVITY", "ACCESS", "ACTION", "ACTIVATION", "ACTIVE", "ADD", + "ADDRESS", "ADMINISTER", "AES", "AES_128", "AES_192", "AES_256", "AFFINITY", + "AFTER", "AGGREGATE", "ALGORITHM", "ALL", "ALLOWED", "ALLOW_CONNECTIONS", + "ALLOW_ENCRYPTED_VALUE_MODIFICATIONS", "ALLOW_MULTIPLE_EVENT_LOSS", + "ALLOW_PAGE_LOCKS", "ALLOW_ROW_LOCKS", "ALLOW_SINGLE_EVENT_LOSS", "ALLOW_SNAPSHOT_ISOLATION", + "ALL_CONSTRAINTS", "ALL_ERRORMSGS", "ALL_INDEXES", "ALL_LEVELS", "ALTER", + "ALWAYS", "AND", "ANONYMOUS", "ANSI_DEFAULTS", "ANSI_NULLS", "ANSI_NULL_DEFAULT", + "ANSI_NULL_DFLT_OFF", "ANSI_NULL_DFLT_ON", "ANSI_PADDING", "ANSI_WARNINGS", + "ANY", "APPEND", "APPLICATION", "APPLICATION_LOG", "APPLOCK_MODE", "APPLOCK_TEST", + "APPLY", "APP_NAME", "ARITHABORT", "ARITHIGNORE", "AS", "ASC", "ASCII", + "ASSEMBLY", "ASSEMBLYPROPERTY", "ASYMMETRIC", "ASYNCHRONOUS_COMMIT", + "AT_KEYWORD", "AUDIT", "AUDIT_GUID", "AUTHENTICATE", "AUTHENTICATION", + "AUTHORIZATION", "AUTO", "AUTOGROW_ALL_FILES", "AUTOGROW_SINGLE_FILE", + "AUTOMATED_BACKUP_PREFERENCE", "AUTOMATIC", "AUTO_CLEANUP", "AUTO_CLOSE", + "AUTO_CREATE_STATISTICS", "AUTO_DROP", "AUTO_SHRINK", "AUTO_UPDATE_STATISTICS", + "AUTO_UPDATE_STATISTICS_ASYNC", "AVAILABILITY", "AVAILABILITY_MODE", + "AVG", "BACKSLASH", "BACKUP", "BACKUP_CLONEDB", "BACKUP_PRIORITY", "BASE64", + "BEFORE", "BEGIN", "BEGIN_DIALOG", "BETWEEN", "BIGINT", "BINARY_CHECKSUM", + "BINARY_KEYWORD", "BINDING", "BLOB_STORAGE", "BLOCK", "BLOCKERS", "BLOCKING_HIERARCHY", + "BLOCKSIZE", "BOUNDING_BOX", "BREAK", "BROKER", "BROKER_INSTANCE", "BROWSE", + "BUFFER", "BUFFERCOUNT", "BULK", "BULK_LOGGED", "BY", "CACHE", "CALLED", + "CALLER", "CAP_CPU_PERCENT", "CASCADE", "CASE", "CAST", "CATALOG", "CATCH", + "CELLS_PER_OBJECT", "CERTENCODED", "CERTIFICATE", "CERTPRIVATEKEY", + "CERT_ID", "CHANGE", "CHANGES", "CHANGETABLE", "CHANGE_RETENTION", "CHANGE_TRACKING", + "CHAR", "CHARINDEX", "CHECK", "CHECKALLOC", "CHECKCATALOG", "CHECKCONSTRAINTS", + "CHECKDB", "CHECKFILEGROUP", "CHECKPOINT", "CHECKSUM", "CHECKSUM_AGG", + "CHECKTABLE", "CHECK_EXPIRATION", "CHECK_POLICY", "CLASSIFIER_FUNCTION", + "CLEANTABLE", "CLEANUP", "CLONEDATABASE", "CLOSE", "CLUSTER", "CLUSTERED", + "COALESCE", "COLLATE", "COLLECTION", "COLUMN", "COLUMNPROPERTY", "COLUMNS", + "COLUMNSTORE", "COLUMNSTORE_ARCHIVE", "COLUMN_ENCRYPTION_KEY", "COLUMN_MASTER_KEY", + "COL_LENGTH", "COL_NAME", "COMMIT", "COMMITTED", "COMPATIBILITY_LEVEL", + "COMPRESS", "COMPRESSION", "COMPRESSION_DELAY", "COMPRESS_ALL_ROW_GROUPS", + "COMPUTE", "CONCAT", "CONCAT_NULL_YIELDS_NULL", "CONCAT_WS", "CONFIGURATION", + "CONNECT", "CONNECTION", "CONNECTIONPROPERTY", "CONSTRAINT", "CONTAINMENT", + "CONTAINS", "CONTAINSTABLE", "CONTENT", "CONTEXT", "CONTEXT_INFO", "CONTINUE", + "CONTINUE_AFTER_ERROR", "CONTRACT", "CONTRACT_NAME", "CONTROL", "CONVERSATION", + "CONVERT", "COOKIE", "COPY_ONLY", "COUNT", "COUNTER", "COUNT_BIG", "CPU", + "CREATE", "CREATE_NEW", "CREATION_DISPOSITION", "CREDENTIAL", "CROSS", + "CRYPTOGRAPHIC", "CUME_DIST", "CURRENT", "CURRENT_DATE", "CURRENT_REQUEST_ID", + "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_TRANSACTION_ID", "CURRENT_USER", + "CURSOR", "CURSOR_CLOSE_ON_COMMIT", "CURSOR_DEFAULT", "CURSOR_STATUS", + "CYCLE", "DATA", "DATABASE", "DATABASEPROPERTYEX", "DATABASE_MIRRORING", + "DATABASE_PRINCIPAL_ID", "DATALENGTH", "DATASPACE", "DATA_COMPRESSION", + "DATA_PURITY", "DATA_SOURCE", "DATEADD", "DATEDIFF", "DATENAME", "DATEPART", + "DATE_CORRELATION_OPTIMIZATION", "DAYS", "DBCC", "DBREINDEX", "DB_CHAINING", + "DB_FAILOVER", "DB_ID", "DB_NAME", "DDL", "DEALLOCATE", "DECLARE", "DECOMPRESS", + "DECRYPTION", "DEFAULT", "DEFAULT_DATABASE", "DEFAULT_DOUBLE_QUOTE", + "DEFAULT_FULLTEXT_LANGUAGE", "DEFAULT_LANGUAGE", "DEFAULT_SCHEMA", "DEFINITION", + "DELAY", "DELAYED_DURABILITY", "DELETE", "DELETED", "DENSE_RANK", "DENY", + "DEPENDENTS", "DES", "DESC", "DESCRIPTION", "DESX", "DETERMINISTIC", + "DHCP", "DIAGNOSTICS", "DIALOG", "DIFFERENCE", "DIFFERENTIAL", "DIRECTORY_NAME", + "DISABLE", "DISABLED", "DISABLE_BROKER", "DISK", "DISTINCT", "DISTRIBUTED", + "DISTRIBUTION", "DOCUMENT", "DOLLAR_PARTITION", "DOUBLE", "DOUBLE_BACK_SLASH", + "DOUBLE_FORWARD_SLASH", "DROP", "DROPCLEANBUFFERS", "DROP_EXISTING", + "DTC_SUPPORT", "DUMP", "DYNAMIC", "ELEMENTS", "ELSE", "EMERGENCY", "EMPTY", + "ENABLE", "ENABLED", "ENABLE_BROKER", "ENCRYPTED", "ENCRYPTED_VALUE", + "ENCRYPTION", "ENCRYPTION_TYPE", "END", "ENDPOINT", "ENDPOINT_URL", + "ERRLVL", "ERROR", "ERROR_BROKER_CONVERSATIONS", "ERROR_LINE", "ERROR_MESSAGE", + "ERROR_NUMBER", "ERROR_PROCEDURE", "ERROR_SEVERITY", "ERROR_STATE", + "ESCAPE", "ESTIMATEONLY", "EVENT", "EVENTDATA", "EVENT_RETENTION_MODE", + "EXCEPT", "EXCLUSIVE", "EXECUTABLE", "EXECUTABLE_FILE", "EXECUTE", "EXIST", + "EXISTS", "EXIST_SQUARE_BRACKET", "EXIT", "EXPAND", "EXPIREDATE", "EXPIRY_DATE", + "EXPLICIT", "EXTENDED_LOGICAL_CHECKS", "EXTENSION", "EXTERNAL", "EXTERNAL_ACCESS", + "FAILOVER", "FAILOVER_MODE", "FAILURE", "FAILURECONDITIONLEVEL", "FAILURE_CONDITION_LEVEL", + "FAIL_OPERATION", "FAN_IN", "FAST", "FAST_FORWARD", "FETCH", "FILE", + "FILEGROUP", "FILEGROUPPROPERTY", "FILEGROUP_ID", "FILEGROUP_NAME", + "FILEGROWTH", "FILENAME", "FILEPATH", "FILEPROPERTY", "FILEPROPERTYEX", + "FILESTREAM", "FILESTREAM_ON", "FILE_ID", "FILE_IDEX", "FILE_NAME", + "FILE_SNAPSHOT", "FILLFACTOR", "FILTER", "FIRST", "FIRST_VALUE", "FMTONLY", + "FOLLOWING", "FOR", "FORCE", "FORCED", "FORCEPLAN", "FORCESCAN", "FORCESEEK", + "FORCE_FAILOVER_ALLOW_DATA_LOSS", "FORCE_SERVICE_ALLOW_DATA_LOSS", "FOREIGN", + "FORMAT", "FORMATMESSAGE", "FORWARD_ONLY", "FREE", "FREETEXT", "FREETEXTTABLE", + "FROM", "FULL", "FULLSCAN", "FULLTEXT", "FULLTEXTCATALOGPROPERTY", "FULLTEXTSERVICEPROPERTY", + "FUNCTION", "GB", "GENERATED", "GEOGRAPHY", "GEOGRAPHY_AUTO_GRID", "GEOGRAPHY_GRID", + "GEOMETRY", "GEOMETRY_AUTO_GRID", "GEOMETRY_GRID", "GET", "GRIDS", "GETANCESTOR", + "GETANSINULL", "GETDATE", "GETDESCENDANT", "GETLEVEL", "GETREPARENTEDVALUE", + "GETROOT", "GETUTCDATE", "GET_FILESTREAM_TRANSACTION_CONTEXT", "GLOBAL", + "GO", "GOTO", "GOVERNOR", "GRANT", "GREATEST", "GROUP", "GROUPING", + "GROUPING_ID", "GROUP_MAX_REQUESTS", "HADR", "HASH", "HASHED", "HAS_DBACCESS", + "HAS_PERMS_BY_NAME", "HAVING", "HEALTHCHECKTIMEOUT", "HEALTH_CHECK_TIMEOUT", + "HEAP", "HIDDEN_KEYWORD", "HIERARCHYID", "HIGH", "HOLDLOCK", "HONOR_BROKER_PRIORITY", + "HOST_ID", "HOST_NAME", "HOURS", "IDENTITY", "IDENTITYCOL", "IDENTITY_INSERT", + "IDENTITY_VALUE", "IDENT_CURRENT", "IDENT_INCR", "IDENT_SEED", "IF", + "IGNORE_CONSTRAINTS", "IGNORE_DUP_KEY", "IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX", + "IGNORE_REPLICATED_TABLE_CACHE", "IGNORE_TRIGGERS", "IIF", "IMMEDIATE", + "IMPERSONATE", "IMPLICIT_TRANSACTIONS", "IMPORTANCE", "IN", "INCLUDE", + "INCLUDE_NULL_VALUES", "INCREMENT", "INCREMENTAL", "INDEX", "INDEXKEY_PROPERTY", + "INDEXPROPERTY", "INDEX_COL", "INFINITE", "INIT", "INITIATOR", "INNER", + "INPUT", "INSENSITIVE", "INSERT", "INSERTED", "INSTEAD", "INT", "INTERSECT", + "INTO", "IO", "IP", "IS", "ISDESCENDANTOF", "ISJSON", "ISNULL", "ISNUMERIC", + "ISOLATION", "IS_MEMBER", "IS_ROLEMEMBER", "IS_SRVROLEMEMBER", "JOB", + "JOIN", "JSON", "JSON_ARRAY", "JSON_MODIFY", "JSON_OBJECT", "JSON_PATH_EXISTS", + "JSON_QUERY", "JSON_VALUE", "KB", "KEEP", "KEEPDEFAULTS", "KEEPFIXED", + "KEEPIDENTITY", "KERBEROS", "KEY", "KEYS", "KEYSET", "KEY_PATH", "KEY_SOURCE", + "KEY_STORE_PROVIDER_NAME", "KILL", "LAG", "LANGUAGE", "LAST", "LAST_VALUE", + "LEAD", "LEAST", "LEFT", "LEN", "LEVEL", "LEVEL_1", "LEVEL_2", "LEVEL_3", + "LEVEL_4", "LIBRARY", "LIFETIME", "LIKE", "LINENO", "LINKED", "LINUX", + "LIST", "LISTENER", "LISTENER_IP", "LISTENER_PORT", "LISTENER_URL", + "LOAD", "LOB_COMPACTION", "LOCAL", "LOCAL_SERVICE_NAME", "LOCATION", + "LOCK", "LOCK_ESCALATION", "LOG", "LOGIN", "LOGINPROPERTY", "LOOP", + "LOW", "LOWER", "LTRIM", "MANUAL", "MARK", "MASK", "MASKED", "MASTER", + "MATCHED", "MATERIALIZED", "MAX", "MAXDOP", "MAXRECURSION", "MAXSIZE", + "MAXTRANSFER", "MAXVALUE", "MAX_CPU_PERCENT", "MAX_DISPATCH_LATENCY", + "MAX_DOP", "MAX_DURATION", "MAX_EVENT_SIZE", "MAX_FILES", "MAX_IOPS_PER_VOLUME", + "MAX_MEMORY", "MAX_MEMORY_PERCENT", "MAX_OUTSTANDING_IO_PER_VOLUME", + "MAX_PROCESSES", "MAX_QUEUE_READERS", "MAX_ROLLOVER_FILES", "MAX_SIZE", + "MB", "MEDIADESCRIPTION", "MEDIANAME", "MEDIUM", "MEMBER", "MEMORY_OPTIMIZED_DATA", + "MEMORY_PARTITION_MODE", "MERGE", "MESSAGE", "MESSAGE_FORWARDING", "MESSAGE_FORWARD_SIZE", + "MIN", "MINUTES", "MINVALUE", "MIN_ACTIVE_ROWVERSION", "MIN_CPU_PERCENT", + "MIN_IOPS_PER_VOLUME", "MIN_MEMORY_PERCENT", "MIRROR", "MIRROR_ADDRESS", + "MIXED_PAGE_ALLOCATION", "MODE", "MODIFY", "MODIFY_SQUARE_BRACKET", + "MOVE", "MULTI_USER", "MUST_CHANGE", "NAME", "NATIONAL", "NCHAR", "NEGOTIATE", + "NESTED_TRIGGERS", "NEWID", "NEWNAME", "NEWSEQUENTIALID", "NEW_ACCOUNT", + "NEW_BROKER", "NEW_PASSWORD", "NEXT", "NO", "NOCHECK", "NOCOUNT", "NODES", + "NOEXEC", "NOEXPAND", "NOFORMAT", "NOHOLDLOCK", "NOINDEX", "NOINIT", + "NOLOCK", "NONCLUSTERED", "NONE", "NON_TRANSACTED_ACCESS", "NORECOMPUTE", + "NORECOVERY", "NOREWIND", "NOSKIP", "NOT", "NOTIFICATION", "NOTIFICATIONS", + "NOUNLOAD", "NOWAIT", "NO_CHECKSUM", "NO_COMPRESSION", "NO_EVENT_LOSS", + "NO_INFOMSGS", "NO_QUERYSTORE", "NO_STATISTICS", "NO_TRUNCATE", "NO_WAIT", + "NTILE", "NTLM", "NULLIF", "NULL_", "NULL_DOUBLE_QUOTE", "NUMANODE", + "NUMBER", "NUMERIC_ROUNDABORT", "OBJECT", "OBJECTPROPERTY", "OBJECTPROPERTYEX", + "OBJECT_DEFINITION", "OBJECT_ID", "OBJECT_NAME", "OBJECT_SCHEMA_NAME", + "OF", "OFF", "OFFLINE", "OFFSET", "OFFSETS", "OLD_ACCOUNT", "OLD_PASSWORD", + "ON", "ONLINE", "ONLY", "ON_FAILURE", "OPEN", "OPENDATASOURCE", "OPENJSON", + "OPENQUERY", "OPENROWSET", "OPENXML", "OPEN_EXISTING", "OPERATIONS", + "OPTIMISTIC", "OPTIMIZE", "OPTIMIZE_FOR_SEQUENTIAL_KEY", "OPTION", "OR", + "ORDER", "ORIGINAL_DB_NAME", "ORIGINAL_LOGIN", "OUT", "OUTER", "OUTPUT", + "OVER", "OVERRIDE", "OWNER", "OWNERSHIP", "PAD_INDEX", "PAGE", "PAGECOUNT", + "PAGE_VERIFY", "PAGLOCK", "PARAMETERIZATION", "PARAM_NODE", "PARSE", + "PARSENAME", "PARSEONLY", "PARTIAL", "PARTITION", "PARTITIONS", "PARTNER", + "PASSWORD", "PATH", "PATINDEX", "PAUSE", "PDW_SHOWSPACEUSED", "PERCENT", + "PERCENTILE_CONT", "PERCENTILE_DISC", "PERCENT_RANK", "PERMISSIONS", + "PERMISSION_SET", "PERSISTED", "PERSIST_SAMPLE_PERCENT", "PER_CPU", + "PER_DB", "PER_NODE", "PHYSICAL_ONLY", "PIVOT", "PLAN", "PLATFORM", + "POISON_MESSAGE_HANDLING", "POLICY", "POOL", "PORT", "PRECEDING", "PRECISION", + "PREDICATE", "PRIMARY", "PRIMARY_ROLE", "PRINT", "PRIOR", "PRIORITY", + "PRIORITY_LEVEL", "PRIVATE", "PRIVATE_KEY", "PRIVILEGES", "PROC", "PROCCACHE", + "PROCEDURE", "PROCEDURE_NAME", "PROCESS", "PROFILE", "PROPERTY", "PROVIDER", + "PROVIDER_KEY_NAME", "PUBLIC", "PWDCOMPARE", "PWDENCRYPT", "PYTHON", + "QUERY", "QUERY_SQUARE_BRACKET", "QUEUE", "QUEUE_DELAY", "QUOTED_IDENTIFIER", + "QUOTENAME", "R", "RAISERROR", "RANDOMIZED", "RANGE", "RANK", "RAW", + "RC2", "RC4", "RC4_128", "READ", "READCOMMITTED", "READCOMMITTEDLOCK", + "READONLY", "READPAST", "READTEXT", "READUNCOMMITTED", "READWRITE", + "READ_COMMITTED_SNAPSHOT", "READ_ONLY", "READ_ONLY_ROUTING_LIST", "READ_WRITE", + "READ_WRITE_FILEGROUPS", "REBUILD", "RECEIVE", "RECOMPILE", "RECONFIGURE", + "RECOVERY", "RECURSIVE_TRIGGERS", "REFERENCES", "REGENERATE", "RELATED_CONVERSATION", + "RELATED_CONVERSATION_GROUP", "RELATIVE", "REMOTE", "REMOTE_PROC_TRANSACTIONS", + "REMOTE_SERVICE_NAME", "REMOVE", "REORGANIZE", "REPAIR_ALLOW_DATA_LOSS", + "REPAIR_FAST", "REPAIR_REBUILD", "REPEATABLE", "REPEATABLEREAD", "REPLACE", + "REPLICA", "REPLICATE", "REPLICATION", "REQUEST_MAX_CPU_TIME_SEC", "REQUEST_MAX_MEMORY_GRANT_PERCENT", + "REQUEST_MEMORY_GRANT_TIMEOUT_SEC", "REQUIRED", "REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT", + "RESAMPLE", "RESERVE_DISK_SPACE", "RESET", "RESOURCE", "RESOURCES", + "RESOURCE_MANAGER_LOCATION", "RESTART", "RESTORE", "RESTRICT", "RESTRICTED_USER", + "RESUMABLE", "RESUME", "RETAINDAYS", "RETENTION", "RETURN", "RETURNS", + "REVERSE", "REVERT", "REVOKE", "REWIND", "RIGHT", "ROBUST", "ROLE", + "ROLLBACK", "ROOT", "ROUND_ROBIN", "ROUTE", "ROW", "ROWCOUNT", "ROWCOUNT_BIG", + "ROWGUID", "ROWGUIDCOL", "ROWLOCK", "ROWS", "ROW_NUMBER", "RSA_1024", + "RSA_2048", "RSA_3072", "RSA_4096", "RSA_512", "RTRIM", "RULE", "SAFE", + "SAFETY", "SAMPLE", "SAVE", "SCHEDULER", "SCHEMA", "SCHEMABINDING", + "SCHEMA_ID", "SCHEMA_NAME", "SCHEME", "SCOPED", "SCOPE_IDENTITY", "SCRIPT", + "SCROLL", "SCROLL_LOCKS", "SEARCH", "SECONDARY", "SECONDARY_ONLY", "SECONDARY_ROLE", + "SECONDS", "SECRET", "SECURABLES", "SECURITY", "SECURITYAUDIT", "SECURITY_LOG", + "SEEDING_MODE", "SELECT", "SELF", "SEMANTICKEYPHRASETABLE", "SEMANTICSIMILARITYDETAILSTABLE", + "SEMANTICSIMILARITYTABLE", "SEMI_SENSITIVE", "SEND", "SENT", "SEQUENCE", + "SEQUENCE_NUMBER", "SERIALIZABLE", "SERVER", "SERVERPROPERTY", "SERVICE", + "SERVICEBROKER", "SERVICE_BROKER", "SERVICE_NAME", "SESSION", "SESSIONPROPERTY", + "SESSION_CONTEXT", "SESSION_TIMEOUT", "SESSION_USER", "SET", "SETERROR", + "SETS", "SETTINGS", "SETUSER", "SHARE", "SHARED", "SHOWCONTIG", "SHOWPLAN", + "SHOWPLAN_ALL", "SHOWPLAN_TEXT", "SHOWPLAN_XML", "SHRINKLOG", "SHUTDOWN", + "SID", "SIGNATURE", "SIMPLE", "SINGLE_USER", "SIZE", "SKIP_KEYWORD", + "SMALLINT", "SNAPSHOT", "SOFTNUMA", "SOME", "SORT_IN_TEMPDB", "SOUNDEX", + "SOURCE", "SPACE_KEYWORD", "SPARSE", "SPATIAL", "SPATIAL_WINDOW_MAX_CELLS", + "SPECIFICATION", "SPLIT", "SQL", "SQLDUMPERFLAGS", "SQLDUMPERPATH", + "SQLDUMPERTIMEOUT", "SQL_VARIANT_PROPERTY", "STANDBY", "START", "STARTED", + "STARTUP_STATE", "START_DATE", "STATE", "STATIC", "STATISTICS", "STATISTICS_INCREMENTAL", + "STATISTICS_NORECOMPUTE", "STATS", "STATS_DATE", "STATS_STREAM", "STATUS", + "STATUSONLY", "STDEV", "STDEVP", "STOP", "STOPLIST", "STOPPED", "STOP_ON_ERROR", + "STR", "STRING_AGG", "STRING_ESCAPE", "STUFF", "SUBJECT", "SUBSCRIBE", + "SUBSCRIPTION", "SUBSTRING", "SUM", "SUPPORTED", "SUSER_ID", "SUSER_NAME", + "SUSER_SID", "SUSER_SNAME", "SUSPEND", "SWITCH", "SYMMETRIC", "SYNCHRONOUS_COMMIT", + "SYNONYM", "SYSTEM", "SYSTEM_USER", "TABLE", "TABLERESULTS", "TABLESAMPLE", + "TABLOCK", "TABLOCKX", "TAKE", "TAPE", "TARGET", "TARGET_RECOVERY_TIME", + "TB", "TCP", "TEXTIMAGE_ON", "TEXTSIZE", "THEN", "THROW", "TIES", "TIME", + "TIMEOUT", "TIMER", "TINYINT", "TO", "TOP", "TORN_PAGE_DETECTION", "TOSTRING", + "TRACE", "TRACKING", "TRACK_CAUSALITY", "TRAN", "TRANSACTION", "TRANSACTION_ID", + "TRANSFER", "TRANSFORM_NOISE_WORDS", "TRANSLATE", "TRIGGER", "TRIM", + "TRIPLE_DES", "TRIPLE_DES_3KEY", "TRUNCATE", "TRUSTWORTHY", "TRY", "TRY_CAST", + "TSEQUAL", "TSQL", "TWO_DIGIT_YEAR_CUTOFF", "TYPE", "TYPEPROPERTY", + "TYPE_ID", "TYPE_NAME", "TYPE_WARNING", "UNBOUNDED", "UNCHECKED", "UNCOMMITTED", + "UNICODE", "UNION", "UNIQUE", "UNKNOWN", "UNLIMITED", "UNLOCK", "UNMASK", + "UNPIVOT", "UNSAFE", "UOW", "UPDATE", "UPDATETEXT", "UPDLOCK", "UPPER", + "URL", "USE", "USED", "USER", "USER_ID", "USER_NAME", "USING", "VALIDATION", + "VALID_XML", "VALUE", "VALUES", "VALUE_SQUARE_BRACKET", "VAR", "VARBINARY_KEYWORD", + "VARP", "VARYING", "VERBOSELOGGING", "VERIFY_CLONEDB", "VERSION", "VIEW", + "VIEWS", "VIEW_METADATA", "VISIBILITY", "WAIT", "WAITFOR", "WAIT_AT_LOW_PRIORITY", + "WELL_FORMED_XML", "WHEN", "WHERE", "WHILE", "WINDOWS", "WITH", "WITHIN", + "WITHOUT", "WITHOUT_ARRAY_WRAPPER", "WITNESS", "WORK", "WORKLOAD", "WRITETEXT", + "XACT_ABORT", "XACT_STATE", "XLOCK", "XML", "XMLDATA", "XMLNAMESPACES", + "XMLSCHEMA", "XML_COMPRESSION", "XSINIL", "ZONE", "ABS", "ACOS", "ASIN", + "ATAN", "ATN2", "CEILING", "COS", "COT", "DEGREES", "EXP", "FLOOR", + "LOG10", "PI", "POWER", "RADIANS", "RAND", "ROUND", "SIGN", "SIN", "SQRT", + "SQUARE", "TAN", "CURRENT_TIMEZONE", "CURRENT_TIMEZONE_ID", "DATE_BUCKET", + "DATEDIFF_BIG", "DATEFROMPARTS", "DATETIME2FROMPARTS", "DATETIMEFROMPARTS", + "DATETIMEOFFSETFROMPARTS", "DATETRUNC", "DAY", "EOMONTH", "ISDATE", + "MONTH", "SMALLDATETIMEFROMPARTS", "SWITCHOFFSET", "SYSDATETIME", "SYSDATETIMEOFFSET", + "SYSUTCDATETIME", "TIMEFROMPARTS", "TODATETIMEOFFSET", "YEAR", "QUARTER", + "DAYOFYEAR", "WEEK", "HOUR", "MINUTE", "SECOND", "MILLISECOND", "MICROSECOND", + "NANOSECOND", "TZOFFSET", "ISO_WEEK", "WEEKDAY", "YEAR_ABBR", "QUARTER_ABBR", + "MONTH_ABBR", "DAYOFYEAR_ABBR", "DAY_ABBR", "WEEK_ABBR", "HOUR_ABBR", + "MINUTE_ABBR", "SECOND_ABBR", "MILLISECOND_ABBR", "MICROSECOND_ABBR", + "NANOSECOND_ABBR", "TZOFFSET_ABBR", "ISO_WEEK_ABBR", "WEEKDAY_ABBR", + "SP_EXECUTESQL", "VARCHAR", "NVARCHAR", "DISK_DRIVE", "DOLLAR_ACTION", + "CURSOR_ROWS", "FETCH_STATUS", "IPV4_ADDR", "SPACE", "COMMENT", "LINE_COMMENT", + "DOUBLE_QUOTE_ID", "DOUBLE_QUOTE_BLANK", "SINGLE_QUOTE", "SQUARE_BRACKET_ID", + "LOCAL_ID", "TEMP_ID", "DECIMAL", "ID", "STRING", "BINARY", "FLOAT", + "REAL", "EQUAL", "GREATER", "LESS", "EXCLAMATION", "PLUS_ASSIGN", "MINUS_ASSIGN", + "MULT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", + "OR_ASSIGN", "DOUBLE_BAR", "DOT", "UNDERLINE", "AT", "SHARP", "DOLLAR", + "LR_BRACKET", "RR_BRACKET", "COMMA", "SEMI", "COLON", "DOUBLE_COLON", + "STAR", "DIVIDE", "MODULE", "PLUS", "MINUS", "BIT_NOT", "BIT_OR", "BIT_AND", + "BIT_XOR", "PLACEHOLDER", + } + staticData.RuleNames = []string{ + "ABORT", "ABORT_AFTER_WAIT", "ABSENT", "ABSOLUTE", "ACCELERATED_DATABASE_RECOVERY", + "ACCENT_SENSITIVITY", "ACCESS", "ACTION", "ACTIVATION", "ACTIVE", "ADD", + "ADDRESS", "ADMINISTER", "AES", "AES_128", "AES_192", "AES_256", "AFFINITY", + "AFTER", "AGGREGATE", "ALGORITHM", "ALL", "ALLOWED", "ALLOW_CONNECTIONS", + "ALLOW_ENCRYPTED_VALUE_MODIFICATIONS", "ALLOW_MULTIPLE_EVENT_LOSS", + "ALLOW_PAGE_LOCKS", "ALLOW_ROW_LOCKS", "ALLOW_SINGLE_EVENT_LOSS", "ALLOW_SNAPSHOT_ISOLATION", + "ALL_CONSTRAINTS", "ALL_ERRORMSGS", "ALL_INDEXES", "ALL_LEVELS", "ALTER", + "ALWAYS", "AND", "ANONYMOUS", "ANSI_DEFAULTS", "ANSI_NULLS", "ANSI_NULL_DEFAULT", + "ANSI_NULL_DFLT_OFF", "ANSI_NULL_DFLT_ON", "ANSI_PADDING", "ANSI_WARNINGS", + "ANY", "APPEND", "APPLICATION", "APPLICATION_LOG", "APPLOCK_MODE", "APPLOCK_TEST", + "APPLY", "APP_NAME", "ARITHABORT", "ARITHIGNORE", "AS", "ASC", "ASCII", + "ASSEMBLY", "ASSEMBLYPROPERTY", "ASYMMETRIC", "ASYNCHRONOUS_COMMIT", + "AT_KEYWORD", "AUDIT", "AUDIT_GUID", "AUTHENTICATE", "AUTHENTICATION", + "AUTHORIZATION", "AUTO", "AUTOGROW_ALL_FILES", "AUTOGROW_SINGLE_FILE", + "AUTOMATED_BACKUP_PREFERENCE", "AUTOMATIC", "AUTO_CLEANUP", "AUTO_CLOSE", + "AUTO_CREATE_STATISTICS", "AUTO_DROP", "AUTO_SHRINK", "AUTO_UPDATE_STATISTICS", + "AUTO_UPDATE_STATISTICS_ASYNC", "AVAILABILITY", "AVAILABILITY_MODE", + "AVG", "BACKSLASH", "BACKUP", "BACKUP_CLONEDB", "BACKUP_PRIORITY", "BASE64", + "BEFORE", "BEGIN", "BEGIN_DIALOG", "BETWEEN", "BIGINT", "BINARY_CHECKSUM", + "BINARY_KEYWORD", "BINDING", "BLOB_STORAGE", "BLOCK", "BLOCKERS", "BLOCKING_HIERARCHY", + "BLOCKSIZE", "BOUNDING_BOX", "BREAK", "BROKER", "BROKER_INSTANCE", "BROWSE", + "BUFFER", "BUFFERCOUNT", "BULK", "BULK_LOGGED", "BY", "CACHE", "CALLED", + "CALLER", "CAP_CPU_PERCENT", "CASCADE", "CASE", "CAST", "CATALOG", "CATCH", + "CELLS_PER_OBJECT", "CERTENCODED", "CERTIFICATE", "CERTPRIVATEKEY", + "CERT_ID", "CHANGE", "CHANGES", "CHANGETABLE", "CHANGE_RETENTION", "CHANGE_TRACKING", + "CHAR", "CHARINDEX", "CHECK", "CHECKALLOC", "CHECKCATALOG", "CHECKCONSTRAINTS", + "CHECKDB", "CHECKFILEGROUP", "CHECKPOINT", "CHECKSUM", "CHECKSUM_AGG", + "CHECKTABLE", "CHECK_EXPIRATION", "CHECK_POLICY", "CLASSIFIER_FUNCTION", + "CLEANTABLE", "CLEANUP", "CLONEDATABASE", "CLOSE", "CLUSTER", "CLUSTERED", + "COALESCE", "COLLATE", "COLLECTION", "COLUMN", "COLUMNPROPERTY", "COLUMNS", + "COLUMNSTORE", "COLUMNSTORE_ARCHIVE", "COLUMN_ENCRYPTION_KEY", "COLUMN_MASTER_KEY", + "COL_LENGTH", "COL_NAME", "COMMIT", "COMMITTED", "COMPATIBILITY_LEVEL", + "COMPRESS", "COMPRESSION", "COMPRESSION_DELAY", "COMPRESS_ALL_ROW_GROUPS", + "COMPUTE", "CONCAT", "CONCAT_NULL_YIELDS_NULL", "CONCAT_WS", "CONFIGURATION", + "CONNECT", "CONNECTION", "CONNECTIONPROPERTY", "CONSTRAINT", "CONTAINMENT", + "CONTAINS", "CONTAINSTABLE", "CONTENT", "CONTEXT", "CONTEXT_INFO", "CONTINUE", + "CONTINUE_AFTER_ERROR", "CONTRACT", "CONTRACT_NAME", "CONTROL", "CONVERSATION", + "CONVERT", "COOKIE", "COPY_ONLY", "COUNT", "COUNTER", "COUNT_BIG", "CPU", + "CREATE", "CREATE_NEW", "CREATION_DISPOSITION", "CREDENTIAL", "CROSS", + "CRYPTOGRAPHIC", "CUME_DIST", "CURRENT", "CURRENT_DATE", "CURRENT_REQUEST_ID", + "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_TRANSACTION_ID", "CURRENT_USER", + "CURSOR", "CURSOR_CLOSE_ON_COMMIT", "CURSOR_DEFAULT", "CURSOR_STATUS", + "CYCLE", "DATA", "DATABASE", "DATABASEPROPERTYEX", "DATABASE_MIRRORING", + "DATABASE_PRINCIPAL_ID", "DATALENGTH", "DATASPACE", "DATA_COMPRESSION", + "DATA_PURITY", "DATA_SOURCE", "DATEADD", "DATEDIFF", "DATENAME", "DATEPART", + "DATE_CORRELATION_OPTIMIZATION", "DAYS", "DBCC", "DBREINDEX", "DB_CHAINING", + "DB_FAILOVER", "DB_ID", "DB_NAME", "DDL", "DEALLOCATE", "DECLARE", "DECOMPRESS", + "DECRYPTION", "DEFAULT", "DEFAULT_DATABASE", "DEFAULT_DOUBLE_QUOTE", + "DEFAULT_FULLTEXT_LANGUAGE", "DEFAULT_LANGUAGE", "DEFAULT_SCHEMA", "DEFINITION", + "DELAY", "DELAYED_DURABILITY", "DELETE", "DELETED", "DENSE_RANK", "DENY", + "DEPENDENTS", "DES", "DESC", "DESCRIPTION", "DESX", "DETERMINISTIC", + "DHCP", "DIAGNOSTICS", "DIALOG", "DIFFERENCE", "DIFFERENTIAL", "DIRECTORY_NAME", + "DISABLE", "DISABLED", "DISABLE_BROKER", "DISK", "DISTINCT", "DISTRIBUTED", + "DISTRIBUTION", "DOCUMENT", "DOLLAR_PARTITION", "DOUBLE", "DOUBLE_BACK_SLASH", + "DOUBLE_FORWARD_SLASH", "DROP", "DROPCLEANBUFFERS", "DROP_EXISTING", + "DTC_SUPPORT", "DUMP", "DYNAMIC", "ELEMENTS", "ELSE", "EMERGENCY", "EMPTY", + "ENABLE", "ENABLED", "ENABLE_BROKER", "ENCRYPTED", "ENCRYPTED_VALUE", + "ENCRYPTION", "ENCRYPTION_TYPE", "END", "ENDPOINT", "ENDPOINT_URL", + "ERRLVL", "ERROR", "ERROR_BROKER_CONVERSATIONS", "ERROR_LINE", "ERROR_MESSAGE", + "ERROR_NUMBER", "ERROR_PROCEDURE", "ERROR_SEVERITY", "ERROR_STATE", + "ESCAPE", "ESTIMATEONLY", "EVENT", "EVENTDATA", "EVENT_RETENTION_MODE", + "EXCEPT", "EXCLUSIVE", "EXECUTABLE", "EXECUTABLE_FILE", "EXECUTE", "EXIST", + "EXISTS", "EXIST_SQUARE_BRACKET", "EXIT", "EXPAND", "EXPIREDATE", "EXPIRY_DATE", + "EXPLICIT", "EXTENDED_LOGICAL_CHECKS", "EXTENSION", "EXTERNAL", "EXTERNAL_ACCESS", + "FAILOVER", "FAILOVER_MODE", "FAILURE", "FAILURECONDITIONLEVEL", "FAILURE_CONDITION_LEVEL", + "FAIL_OPERATION", "FAN_IN", "FAST", "FAST_FORWARD", "FETCH", "FILE", + "FILEGROUP", "FILEGROUPPROPERTY", "FILEGROUP_ID", "FILEGROUP_NAME", + "FILEGROWTH", "FILENAME", "FILEPATH", "FILEPROPERTY", "FILEPROPERTYEX", + "FILESTREAM", "FILESTREAM_ON", "FILE_ID", "FILE_IDEX", "FILE_NAME", + "FILE_SNAPSHOT", "FILLFACTOR", "FILTER", "FIRST", "FIRST_VALUE", "FMTONLY", + "FOLLOWING", "FOR", "FORCE", "FORCED", "FORCEPLAN", "FORCESCAN", "FORCESEEK", + "FORCE_FAILOVER_ALLOW_DATA_LOSS", "FORCE_SERVICE_ALLOW_DATA_LOSS", "FOREIGN", + "FORMAT", "FORMATMESSAGE", "FORWARD_ONLY", "FREE", "FREETEXT", "FREETEXTTABLE", + "FROM", "FULL", "FULLSCAN", "FULLTEXT", "FULLTEXTCATALOGPROPERTY", "FULLTEXTSERVICEPROPERTY", + "FUNCTION", "GB", "GENERATED", "GEOGRAPHY", "GEOGRAPHY_AUTO_GRID", "GEOGRAPHY_GRID", + "GEOMETRY", "GEOMETRY_AUTO_GRID", "GEOMETRY_GRID", "GET", "GRIDS", "GETANCESTOR", + "GETANSINULL", "GETDATE", "GETDESCENDANT", "GETLEVEL", "GETREPARENTEDVALUE", + "GETROOT", "GETUTCDATE", "GET_FILESTREAM_TRANSACTION_CONTEXT", "GLOBAL", + "GO", "GOTO", "GOVERNOR", "GRANT", "GREATEST", "GROUP", "GROUPING", + "GROUPING_ID", "GROUP_MAX_REQUESTS", "HADR", "HASH", "HASHED", "HAS_DBACCESS", + "HAS_PERMS_BY_NAME", "HAVING", "HEALTHCHECKTIMEOUT", "HEALTH_CHECK_TIMEOUT", + "HEAP", "HIDDEN_KEYWORD", "HIERARCHYID", "HIGH", "HOLDLOCK", "HONOR_BROKER_PRIORITY", + "HOST_ID", "HOST_NAME", "HOURS", "IDENTITY", "IDENTITYCOL", "IDENTITY_INSERT", + "IDENTITY_VALUE", "IDENT_CURRENT", "IDENT_INCR", "IDENT_SEED", "IF", + "IGNORE_CONSTRAINTS", "IGNORE_DUP_KEY", "IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX", + "IGNORE_REPLICATED_TABLE_CACHE", "IGNORE_TRIGGERS", "IIF", "IMMEDIATE", + "IMPERSONATE", "IMPLICIT_TRANSACTIONS", "IMPORTANCE", "IN", "INCLUDE", + "INCLUDE_NULL_VALUES", "INCREMENT", "INCREMENTAL", "INDEX", "INDEXKEY_PROPERTY", + "INDEXPROPERTY", "INDEX_COL", "INFINITE", "INIT", "INITIATOR", "INNER", + "INPUT", "INSENSITIVE", "INSERT", "INSERTED", "INSTEAD", "INT", "INTERSECT", + "INTO", "IO", "IP", "IS", "ISDESCENDANTOF", "ISJSON", "ISNULL", "ISNUMERIC", + "ISOLATION", "IS_MEMBER", "IS_ROLEMEMBER", "IS_SRVROLEMEMBER", "JOB", + "JOIN", "JSON", "JSON_ARRAY", "JSON_MODIFY", "JSON_OBJECT", "JSON_PATH_EXISTS", + "JSON_QUERY", "JSON_VALUE", "KB", "KEEP", "KEEPDEFAULTS", "KEEPFIXED", + "KEEPIDENTITY", "KERBEROS", "KEY", "KEYS", "KEYSET", "KEY_PATH", "KEY_SOURCE", + "KEY_STORE_PROVIDER_NAME", "KILL", "LAG", "LANGUAGE", "LAST", "LAST_VALUE", + "LEAD", "LEAST", "LEFT", "LEN", "LEVEL", "LEVEL_1", "LEVEL_2", "LEVEL_3", + "LEVEL_4", "LIBRARY", "LIFETIME", "LIKE", "LINENO", "LINKED", "LINUX", + "LIST", "LISTENER", "LISTENER_IP", "LISTENER_PORT", "LISTENER_URL", + "LOAD", "LOB_COMPACTION", "LOCAL", "LOCAL_SERVICE_NAME", "LOCATION", + "LOCK", "LOCK_ESCALATION", "LOG", "LOGIN", "LOGINPROPERTY", "LOOP", + "LOW", "LOWER", "LTRIM", "MANUAL", "MARK", "MASK", "MASKED", "MASTER", + "MATCHED", "MATERIALIZED", "MAX", "MAXDOP", "MAXRECURSION", "MAXSIZE", + "MAXTRANSFER", "MAXVALUE", "MAX_CPU_PERCENT", "MAX_DISPATCH_LATENCY", + "MAX_DOP", "MAX_DURATION", "MAX_EVENT_SIZE", "MAX_FILES", "MAX_IOPS_PER_VOLUME", + "MAX_MEMORY", "MAX_MEMORY_PERCENT", "MAX_OUTSTANDING_IO_PER_VOLUME", + "MAX_PROCESSES", "MAX_QUEUE_READERS", "MAX_ROLLOVER_FILES", "MAX_SIZE", + "MB", "MEDIADESCRIPTION", "MEDIANAME", "MEDIUM", "MEMBER", "MEMORY_OPTIMIZED_DATA", + "MEMORY_PARTITION_MODE", "MERGE", "MESSAGE", "MESSAGE_FORWARDING", "MESSAGE_FORWARD_SIZE", + "MIN", "MINUTES", "MINVALUE", "MIN_ACTIVE_ROWVERSION", "MIN_CPU_PERCENT", + "MIN_IOPS_PER_VOLUME", "MIN_MEMORY_PERCENT", "MIRROR", "MIRROR_ADDRESS", + "MIXED_PAGE_ALLOCATION", "MODE", "MODIFY", "MODIFY_SQUARE_BRACKET", + "MOVE", "MULTI_USER", "MUST_CHANGE", "NAME", "NATIONAL", "NCHAR", "NEGOTIATE", + "NESTED_TRIGGERS", "NEWID", "NEWNAME", "NEWSEQUENTIALID", "NEW_ACCOUNT", + "NEW_BROKER", "NEW_PASSWORD", "NEXT", "NO", "NOCHECK", "NOCOUNT", "NODES", + "NOEXEC", "NOEXPAND", "NOFORMAT", "NOHOLDLOCK", "NOINDEX", "NOINIT", + "NOLOCK", "NONCLUSTERED", "NONE", "NON_TRANSACTED_ACCESS", "NORECOMPUTE", + "NORECOVERY", "NOREWIND", "NOSKIP", "NOT", "NOTIFICATION", "NOTIFICATIONS", + "NOUNLOAD", "NOWAIT", "NO_CHECKSUM", "NO_COMPRESSION", "NO_EVENT_LOSS", + "NO_INFOMSGS", "NO_QUERYSTORE", "NO_STATISTICS", "NO_TRUNCATE", "NO_WAIT", + "NTILE", "NTLM", "NULLIF", "NULL_", "NULL_DOUBLE_QUOTE", "NUMANODE", + "NUMBER", "NUMERIC_ROUNDABORT", "OBJECT", "OBJECTPROPERTY", "OBJECTPROPERTYEX", + "OBJECT_DEFINITION", "OBJECT_ID", "OBJECT_NAME", "OBJECT_SCHEMA_NAME", + "OF", "OFF", "OFFLINE", "OFFSET", "OFFSETS", "OLD_ACCOUNT", "OLD_PASSWORD", + "ON", "ONLINE", "ONLY", "ON_FAILURE", "OPEN", "OPENDATASOURCE", "OPENJSON", + "OPENQUERY", "OPENROWSET", "OPENXML", "OPEN_EXISTING", "OPERATIONS", + "OPTIMISTIC", "OPTIMIZE", "OPTIMIZE_FOR_SEQUENTIAL_KEY", "OPTION", "OR", + "ORDER", "ORIGINAL_DB_NAME", "ORIGINAL_LOGIN", "OUT", "OUTER", "OUTPUT", + "OVER", "OVERRIDE", "OWNER", "OWNERSHIP", "PAD_INDEX", "PAGE", "PAGECOUNT", + "PAGE_VERIFY", "PAGLOCK", "PARAMETERIZATION", "PARAM_NODE", "PARSE", + "PARSENAME", "PARSEONLY", "PARTIAL", "PARTITION", "PARTITIONS", "PARTNER", + "PASSWORD", "PATH", "PATINDEX", "PAUSE", "PDW_SHOWSPACEUSED", "PERCENT", + "PERCENTILE_CONT", "PERCENTILE_DISC", "PERCENT_RANK", "PERMISSIONS", + "PERMISSION_SET", "PERSISTED", "PERSIST_SAMPLE_PERCENT", "PER_CPU", + "PER_DB", "PER_NODE", "PHYSICAL_ONLY", "PIVOT", "PLAN", "PLATFORM", + "POISON_MESSAGE_HANDLING", "POLICY", "POOL", "PORT", "PRECEDING", "PRECISION", + "PREDICATE", "PRIMARY", "PRIMARY_ROLE", "PRINT", "PRIOR", "PRIORITY", + "PRIORITY_LEVEL", "PRIVATE", "PRIVATE_KEY", "PRIVILEGES", "PROC", "PROCCACHE", + "PROCEDURE", "PROCEDURE_NAME", "PROCESS", "PROFILE", "PROPERTY", "PROVIDER", + "PROVIDER_KEY_NAME", "PUBLIC", "PWDCOMPARE", "PWDENCRYPT", "PYTHON", + "QUERY", "QUERY_SQUARE_BRACKET", "QUEUE", "QUEUE_DELAY", "QUOTED_IDENTIFIER", + "QUOTENAME", "R", "RAISERROR", "RANDOMIZED", "RANGE", "RANK", "RAW", + "RC2", "RC4", "RC4_128", "READ", "READCOMMITTED", "READCOMMITTEDLOCK", + "READONLY", "READPAST", "READTEXT", "READUNCOMMITTED", "READWRITE", + "READ_COMMITTED_SNAPSHOT", "READ_ONLY", "READ_ONLY_ROUTING_LIST", "READ_WRITE", + "READ_WRITE_FILEGROUPS", "REBUILD", "RECEIVE", "RECOMPILE", "RECONFIGURE", + "RECOVERY", "RECURSIVE_TRIGGERS", "REFERENCES", "REGENERATE", "RELATED_CONVERSATION", + "RELATED_CONVERSATION_GROUP", "RELATIVE", "REMOTE", "REMOTE_PROC_TRANSACTIONS", + "REMOTE_SERVICE_NAME", "REMOVE", "REORGANIZE", "REPAIR_ALLOW_DATA_LOSS", + "REPAIR_FAST", "REPAIR_REBUILD", "REPEATABLE", "REPEATABLEREAD", "REPLACE", + "REPLICA", "REPLICATE", "REPLICATION", "REQUEST_MAX_CPU_TIME_SEC", "REQUEST_MAX_MEMORY_GRANT_PERCENT", + "REQUEST_MEMORY_GRANT_TIMEOUT_SEC", "REQUIRED", "REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT", + "RESAMPLE", "RESERVE_DISK_SPACE", "RESET", "RESOURCE", "RESOURCES", + "RESOURCE_MANAGER_LOCATION", "RESTART", "RESTORE", "RESTRICT", "RESTRICTED_USER", + "RESUMABLE", "RESUME", "RETAINDAYS", "RETENTION", "RETURN", "RETURNS", + "REVERSE", "REVERT", "REVOKE", "REWIND", "RIGHT", "ROBUST", "ROLE", + "ROLLBACK", "ROOT", "ROUND_ROBIN", "ROUTE", "ROW", "ROWCOUNT", "ROWCOUNT_BIG", + "ROWGUID", "ROWGUIDCOL", "ROWLOCK", "ROWS", "ROW_NUMBER", "RSA_1024", + "RSA_2048", "RSA_3072", "RSA_4096", "RSA_512", "RTRIM", "RULE", "SAFE", + "SAFETY", "SAMPLE", "SAVE", "SCHEDULER", "SCHEMA", "SCHEMABINDING", + "SCHEMA_ID", "SCHEMA_NAME", "SCHEME", "SCOPED", "SCOPE_IDENTITY", "SCRIPT", + "SCROLL", "SCROLL_LOCKS", "SEARCH", "SECONDARY", "SECONDARY_ONLY", "SECONDARY_ROLE", + "SECONDS", "SECRET", "SECURABLES", "SECURITY", "SECURITYAUDIT", "SECURITY_LOG", + "SEEDING_MODE", "SELECT", "SELF", "SEMANTICKEYPHRASETABLE", "SEMANTICSIMILARITYDETAILSTABLE", + "SEMANTICSIMILARITYTABLE", "SEMI_SENSITIVE", "SEND", "SENT", "SEQUENCE", + "SEQUENCE_NUMBER", "SERIALIZABLE", "SERVER", "SERVERPROPERTY", "SERVICE", + "SERVICEBROKER", "SERVICE_BROKER", "SERVICE_NAME", "SESSION", "SESSIONPROPERTY", + "SESSION_CONTEXT", "SESSION_TIMEOUT", "SESSION_USER", "SET", "SETERROR", + "SETS", "SETTINGS", "SETUSER", "SHARE", "SHARED", "SHOWCONTIG", "SHOWPLAN", + "SHOWPLAN_ALL", "SHOWPLAN_TEXT", "SHOWPLAN_XML", "SHRINKLOG", "SHUTDOWN", + "SID", "SIGNATURE", "SIMPLE", "SINGLE_USER", "SIZE", "SKIP_KEYWORD", + "SMALLINT", "SNAPSHOT", "SOFTNUMA", "SOME", "SORT_IN_TEMPDB", "SOUNDEX", + "SOURCE", "SPACE_KEYWORD", "SPARSE", "SPATIAL", "SPATIAL_WINDOW_MAX_CELLS", + "SPECIFICATION", "SPLIT", "SQL", "SQLDUMPERFLAGS", "SQLDUMPERPATH", + "SQLDUMPERTIMEOUT", "SQL_VARIANT_PROPERTY", "STANDBY", "START", "STARTED", + "STARTUP_STATE", "START_DATE", "STATE", "STATIC", "STATISTICS", "STATISTICS_INCREMENTAL", + "STATISTICS_NORECOMPUTE", "STATS", "STATS_DATE", "STATS_STREAM", "STATUS", + "STATUSONLY", "STDEV", "STDEVP", "STOP", "STOPLIST", "STOPPED", "STOP_ON_ERROR", + "STR", "STRING_AGG", "STRING_ESCAPE", "STUFF", "SUBJECT", "SUBSCRIBE", + "SUBSCRIPTION", "SUBSTRING", "SUM", "SUPPORTED", "SUSER_ID", "SUSER_NAME", + "SUSER_SID", "SUSER_SNAME", "SUSPEND", "SWITCH", "SYMMETRIC", "SYNCHRONOUS_COMMIT", + "SYNONYM", "SYSTEM", "SYSTEM_USER", "TABLE", "TABLERESULTS", "TABLESAMPLE", + "TABLOCK", "TABLOCKX", "TAKE", "TAPE", "TARGET", "TARGET_RECOVERY_TIME", + "TB", "TCP", "TEXTIMAGE_ON", "TEXTSIZE", "THEN", "THROW", "TIES", "TIME", + "TIMEOUT", "TIMER", "TINYINT", "TO", "TOP", "TORN_PAGE_DETECTION", "TOSTRING", + "TRACE", "TRACKING", "TRACK_CAUSALITY", "TRAN", "TRANSACTION", "TRANSACTION_ID", + "TRANSFER", "TRANSFORM_NOISE_WORDS", "TRANSLATE", "TRIGGER", "TRIM", + "TRIPLE_DES", "TRIPLE_DES_3KEY", "TRUNCATE", "TRUSTWORTHY", "TRY", "TRY_CAST", + "TSEQUAL", "TSQL", "TWO_DIGIT_YEAR_CUTOFF", "TYPE", "TYPEPROPERTY", + "TYPE_ID", "TYPE_NAME", "TYPE_WARNING", "UNBOUNDED", "UNCHECKED", "UNCOMMITTED", + "UNICODE", "UNION", "UNIQUE", "UNKNOWN", "UNLIMITED", "UNLOCK", "UNMASK", + "UNPIVOT", "UNSAFE", "UOW", "UPDATE", "UPDATETEXT", "UPDLOCK", "UPPER", + "URL", "USE", "USED", "USER", "USER_ID", "USER_NAME", "USING", "VALIDATION", + "VALID_XML", "VALUE", "VALUES", "VALUE_SQUARE_BRACKET", "VAR", "VARBINARY_KEYWORD", + "VARP", "VARYING", "VERBOSELOGGING", "VERIFY_CLONEDB", "VERSION", "VIEW", + "VIEWS", "VIEW_METADATA", "VISIBILITY", "WAIT", "WAITFOR", "WAIT_AT_LOW_PRIORITY", + "WELL_FORMED_XML", "WHEN", "WHERE", "WHILE", "WINDOWS", "WITH", "WITHIN", + "WITHOUT", "WITHOUT_ARRAY_WRAPPER", "WITNESS", "WORK", "WORKLOAD", "WRITETEXT", + "XACT_ABORT", "XACT_STATE", "XLOCK", "XML", "XMLDATA", "XMLNAMESPACES", + "XMLSCHEMA", "XML_COMPRESSION", "XSINIL", "ZONE", "ABS", "ACOS", "ASIN", + "ATAN", "ATN2", "CEILING", "COS", "COT", "DEGREES", "EXP", "FLOOR", + "LOG10", "PI", "POWER", "RADIANS", "RAND", "ROUND", "SIGN", "SIN", "SQRT", + "SQUARE", "TAN", "CURRENT_TIMEZONE", "CURRENT_TIMEZONE_ID", "DATE_BUCKET", + "DATEDIFF_BIG", "DATEFROMPARTS", "DATETIME2FROMPARTS", "DATETIMEFROMPARTS", + "DATETIMEOFFSETFROMPARTS", "DATETRUNC", "DAY", "EOMONTH", "ISDATE", + "MONTH", "SMALLDATETIMEFROMPARTS", "SWITCHOFFSET", "SYSDATETIME", "SYSDATETIMEOFFSET", + "SYSUTCDATETIME", "TIMEFROMPARTS", "TODATETIMEOFFSET", "YEAR", "QUARTER", + "DAYOFYEAR", "WEEK", "HOUR", "MINUTE", "SECOND", "MILLISECOND", "MICROSECOND", + "NANOSECOND", "TZOFFSET", "ISO_WEEK", "WEEKDAY", "YEAR_ABBR", "QUARTER_ABBR", + "MONTH_ABBR", "DAYOFYEAR_ABBR", "DAY_ABBR", "WEEK_ABBR", "HOUR_ABBR", + "MINUTE_ABBR", "SECOND_ABBR", "MILLISECOND_ABBR", "MICROSECOND_ABBR", + "NANOSECOND_ABBR", "TZOFFSET_ABBR", "ISO_WEEK_ABBR", "WEEKDAY_ABBR", + "SP_EXECUTESQL", "VARCHAR", "NVARCHAR", "DISK_DRIVE", "DOLLAR_ACTION", + "CURSOR_ROWS", "FETCH_STATUS", "IPV4_ADDR", "SPACE", "COMMENT", "LINE_COMMENT", + "DOUBLE_QUOTE_ID", "DOUBLE_QUOTE_BLANK", "SINGLE_QUOTE", "SQUARE_BRACKET_ID", + "LOCAL_ID", "TEMP_ID", "DECIMAL", "ID", "STRING", "BINARY", "FLOAT", + "REAL", "EQUAL", "GREATER", "LESS", "EXCLAMATION", "PLUS_ASSIGN", "MINUS_ASSIGN", + "MULT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", + "OR_ASSIGN", "DOUBLE_BAR", "DOT", "UNDERLINE", "AT", "SHARP", "DOLLAR", + "LR_BRACKET", "RR_BRACKET", "COMMA", "SEMI", "COLON", "DOUBLE_COLON", + "STAR", "DIVIDE", "MODULE", "PLUS", "MINUS", "BIT_NOT", "BIT_OR", "BIT_AND", + "BIT_XOR", "PLACEHOLDER", "LETTER", "DEC_DOT_DEC", "HEX_DIGIT", "DEC_DIGIT", + "FullWidthLetter", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 0, 1221, 15044, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, + 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, + 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, + 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, + 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, + 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, + 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, + 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, + 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, + 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, + 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, + 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, + 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, + 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, + 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, + 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, + 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, + 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, + 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, + 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, + 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, + 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, + 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, + 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, + 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, + 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, + 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, + 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, + 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, + 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, + 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, + 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, + 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, + 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, + 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, + 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, + 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, + 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, + 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, + 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, + 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, + 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, + 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, + 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, + 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, + 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, + 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, + 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, + 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, + 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, + 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, + 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, + 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, + 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, + 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, + 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, + 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, + 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, + 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, + 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, + 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, + 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, + 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, + 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, + 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, + 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, + 310, 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, + 315, 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, + 319, 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, + 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, + 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, + 333, 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, + 337, 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, + 342, 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, + 346, 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, + 351, 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, + 355, 2, 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, + 360, 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, + 364, 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, + 369, 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, + 373, 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, + 378, 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, + 382, 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, + 387, 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, + 391, 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, + 396, 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, + 400, 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, + 405, 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, + 409, 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, + 414, 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, + 418, 2, 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, + 423, 7, 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, + 427, 2, 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, + 432, 7, 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, + 436, 2, 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, + 441, 7, 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, + 445, 2, 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, + 450, 7, 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, + 454, 2, 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, + 459, 7, 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, + 463, 2, 464, 7, 464, 2, 465, 7, 465, 2, 466, 7, 466, 2, 467, 7, 467, 2, + 468, 7, 468, 2, 469, 7, 469, 2, 470, 7, 470, 2, 471, 7, 471, 2, 472, 7, + 472, 2, 473, 7, 473, 2, 474, 7, 474, 2, 475, 7, 475, 2, 476, 7, 476, 2, + 477, 7, 477, 2, 478, 7, 478, 2, 479, 7, 479, 2, 480, 7, 480, 2, 481, 7, + 481, 2, 482, 7, 482, 2, 483, 7, 483, 2, 484, 7, 484, 2, 485, 7, 485, 2, + 486, 7, 486, 2, 487, 7, 487, 2, 488, 7, 488, 2, 489, 7, 489, 2, 490, 7, + 490, 2, 491, 7, 491, 2, 492, 7, 492, 2, 493, 7, 493, 2, 494, 7, 494, 2, + 495, 7, 495, 2, 496, 7, 496, 2, 497, 7, 497, 2, 498, 7, 498, 2, 499, 7, + 499, 2, 500, 7, 500, 2, 501, 7, 501, 2, 502, 7, 502, 2, 503, 7, 503, 2, + 504, 7, 504, 2, 505, 7, 505, 2, 506, 7, 506, 2, 507, 7, 507, 2, 508, 7, + 508, 2, 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 2, + 513, 7, 513, 2, 514, 7, 514, 2, 515, 7, 515, 2, 516, 7, 516, 2, 517, 7, + 517, 2, 518, 7, 518, 2, 519, 7, 519, 2, 520, 7, 520, 2, 521, 7, 521, 2, + 522, 7, 522, 2, 523, 7, 523, 2, 524, 7, 524, 2, 525, 7, 525, 2, 526, 7, + 526, 2, 527, 7, 527, 2, 528, 7, 528, 2, 529, 7, 529, 2, 530, 7, 530, 2, + 531, 7, 531, 2, 532, 7, 532, 2, 533, 7, 533, 2, 534, 7, 534, 2, 535, 7, + 535, 2, 536, 7, 536, 2, 537, 7, 537, 2, 538, 7, 538, 2, 539, 7, 539, 2, + 540, 7, 540, 2, 541, 7, 541, 2, 542, 7, 542, 2, 543, 7, 543, 2, 544, 7, + 544, 2, 545, 7, 545, 2, 546, 7, 546, 2, 547, 7, 547, 2, 548, 7, 548, 2, + 549, 7, 549, 2, 550, 7, 550, 2, 551, 7, 551, 2, 552, 7, 552, 2, 553, 7, + 553, 2, 554, 7, 554, 2, 555, 7, 555, 2, 556, 7, 556, 2, 557, 7, 557, 2, + 558, 7, 558, 2, 559, 7, 559, 2, 560, 7, 560, 2, 561, 7, 561, 2, 562, 7, + 562, 2, 563, 7, 563, 2, 564, 7, 564, 2, 565, 7, 565, 2, 566, 7, 566, 2, + 567, 7, 567, 2, 568, 7, 568, 2, 569, 7, 569, 2, 570, 7, 570, 2, 571, 7, + 571, 2, 572, 7, 572, 2, 573, 7, 573, 2, 574, 7, 574, 2, 575, 7, 575, 2, + 576, 7, 576, 2, 577, 7, 577, 2, 578, 7, 578, 2, 579, 7, 579, 2, 580, 7, + 580, 2, 581, 7, 581, 2, 582, 7, 582, 2, 583, 7, 583, 2, 584, 7, 584, 2, + 585, 7, 585, 2, 586, 7, 586, 2, 587, 7, 587, 2, 588, 7, 588, 2, 589, 7, + 589, 2, 590, 7, 590, 2, 591, 7, 591, 2, 592, 7, 592, 2, 593, 7, 593, 2, + 594, 7, 594, 2, 595, 7, 595, 2, 596, 7, 596, 2, 597, 7, 597, 2, 598, 7, + 598, 2, 599, 7, 599, 2, 600, 7, 600, 2, 601, 7, 601, 2, 602, 7, 602, 2, + 603, 7, 603, 2, 604, 7, 604, 2, 605, 7, 605, 2, 606, 7, 606, 2, 607, 7, + 607, 2, 608, 7, 608, 2, 609, 7, 609, 2, 610, 7, 610, 2, 611, 7, 611, 2, + 612, 7, 612, 2, 613, 7, 613, 2, 614, 7, 614, 2, 615, 7, 615, 2, 616, 7, + 616, 2, 617, 7, 617, 2, 618, 7, 618, 2, 619, 7, 619, 2, 620, 7, 620, 2, + 621, 7, 621, 2, 622, 7, 622, 2, 623, 7, 623, 2, 624, 7, 624, 2, 625, 7, + 625, 2, 626, 7, 626, 2, 627, 7, 627, 2, 628, 7, 628, 2, 629, 7, 629, 2, + 630, 7, 630, 2, 631, 7, 631, 2, 632, 7, 632, 2, 633, 7, 633, 2, 634, 7, + 634, 2, 635, 7, 635, 2, 636, 7, 636, 2, 637, 7, 637, 2, 638, 7, 638, 2, + 639, 7, 639, 2, 640, 7, 640, 2, 641, 7, 641, 2, 642, 7, 642, 2, 643, 7, + 643, 2, 644, 7, 644, 2, 645, 7, 645, 2, 646, 7, 646, 2, 647, 7, 647, 2, + 648, 7, 648, 2, 649, 7, 649, 2, 650, 7, 650, 2, 651, 7, 651, 2, 652, 7, + 652, 2, 653, 7, 653, 2, 654, 7, 654, 2, 655, 7, 655, 2, 656, 7, 656, 2, + 657, 7, 657, 2, 658, 7, 658, 2, 659, 7, 659, 2, 660, 7, 660, 2, 661, 7, + 661, 2, 662, 7, 662, 2, 663, 7, 663, 2, 664, 7, 664, 2, 665, 7, 665, 2, + 666, 7, 666, 2, 667, 7, 667, 2, 668, 7, 668, 2, 669, 7, 669, 2, 670, 7, + 670, 2, 671, 7, 671, 2, 672, 7, 672, 2, 673, 7, 673, 2, 674, 7, 674, 2, + 675, 7, 675, 2, 676, 7, 676, 2, 677, 7, 677, 2, 678, 7, 678, 2, 679, 7, + 679, 2, 680, 7, 680, 2, 681, 7, 681, 2, 682, 7, 682, 2, 683, 7, 683, 2, + 684, 7, 684, 2, 685, 7, 685, 2, 686, 7, 686, 2, 687, 7, 687, 2, 688, 7, + 688, 2, 689, 7, 689, 2, 690, 7, 690, 2, 691, 7, 691, 2, 692, 7, 692, 2, + 693, 7, 693, 2, 694, 7, 694, 2, 695, 7, 695, 2, 696, 7, 696, 2, 697, 7, + 697, 2, 698, 7, 698, 2, 699, 7, 699, 2, 700, 7, 700, 2, 701, 7, 701, 2, + 702, 7, 702, 2, 703, 7, 703, 2, 704, 7, 704, 2, 705, 7, 705, 2, 706, 7, + 706, 2, 707, 7, 707, 2, 708, 7, 708, 2, 709, 7, 709, 2, 710, 7, 710, 2, + 711, 7, 711, 2, 712, 7, 712, 2, 713, 7, 713, 2, 714, 7, 714, 2, 715, 7, + 715, 2, 716, 7, 716, 2, 717, 7, 717, 2, 718, 7, 718, 2, 719, 7, 719, 2, + 720, 7, 720, 2, 721, 7, 721, 2, 722, 7, 722, 2, 723, 7, 723, 2, 724, 7, + 724, 2, 725, 7, 725, 2, 726, 7, 726, 2, 727, 7, 727, 2, 728, 7, 728, 2, + 729, 7, 729, 2, 730, 7, 730, 2, 731, 7, 731, 2, 732, 7, 732, 2, 733, 7, + 733, 2, 734, 7, 734, 2, 735, 7, 735, 2, 736, 7, 736, 2, 737, 7, 737, 2, + 738, 7, 738, 2, 739, 7, 739, 2, 740, 7, 740, 2, 741, 7, 741, 2, 742, 7, + 742, 2, 743, 7, 743, 2, 744, 7, 744, 2, 745, 7, 745, 2, 746, 7, 746, 2, + 747, 7, 747, 2, 748, 7, 748, 2, 749, 7, 749, 2, 750, 7, 750, 2, 751, 7, + 751, 2, 752, 7, 752, 2, 753, 7, 753, 2, 754, 7, 754, 2, 755, 7, 755, 2, + 756, 7, 756, 2, 757, 7, 757, 2, 758, 7, 758, 2, 759, 7, 759, 2, 760, 7, + 760, 2, 761, 7, 761, 2, 762, 7, 762, 2, 763, 7, 763, 2, 764, 7, 764, 2, + 765, 7, 765, 2, 766, 7, 766, 2, 767, 7, 767, 2, 768, 7, 768, 2, 769, 7, + 769, 2, 770, 7, 770, 2, 771, 7, 771, 2, 772, 7, 772, 2, 773, 7, 773, 2, + 774, 7, 774, 2, 775, 7, 775, 2, 776, 7, 776, 2, 777, 7, 777, 2, 778, 7, + 778, 2, 779, 7, 779, 2, 780, 7, 780, 2, 781, 7, 781, 2, 782, 7, 782, 2, + 783, 7, 783, 2, 784, 7, 784, 2, 785, 7, 785, 2, 786, 7, 786, 2, 787, 7, + 787, 2, 788, 7, 788, 2, 789, 7, 789, 2, 790, 7, 790, 2, 791, 7, 791, 2, + 792, 7, 792, 2, 793, 7, 793, 2, 794, 7, 794, 2, 795, 7, 795, 2, 796, 7, + 796, 2, 797, 7, 797, 2, 798, 7, 798, 2, 799, 7, 799, 2, 800, 7, 800, 2, + 801, 7, 801, 2, 802, 7, 802, 2, 803, 7, 803, 2, 804, 7, 804, 2, 805, 7, + 805, 2, 806, 7, 806, 2, 807, 7, 807, 2, 808, 7, 808, 2, 809, 7, 809, 2, + 810, 7, 810, 2, 811, 7, 811, 2, 812, 7, 812, 2, 813, 7, 813, 2, 814, 7, + 814, 2, 815, 7, 815, 2, 816, 7, 816, 2, 817, 7, 817, 2, 818, 7, 818, 2, + 819, 7, 819, 2, 820, 7, 820, 2, 821, 7, 821, 2, 822, 7, 822, 2, 823, 7, + 823, 2, 824, 7, 824, 2, 825, 7, 825, 2, 826, 7, 826, 2, 827, 7, 827, 2, + 828, 7, 828, 2, 829, 7, 829, 2, 830, 7, 830, 2, 831, 7, 831, 2, 832, 7, + 832, 2, 833, 7, 833, 2, 834, 7, 834, 2, 835, 7, 835, 2, 836, 7, 836, 2, + 837, 7, 837, 2, 838, 7, 838, 2, 839, 7, 839, 2, 840, 7, 840, 2, 841, 7, + 841, 2, 842, 7, 842, 2, 843, 7, 843, 2, 844, 7, 844, 2, 845, 7, 845, 2, + 846, 7, 846, 2, 847, 7, 847, 2, 848, 7, 848, 2, 849, 7, 849, 2, 850, 7, + 850, 2, 851, 7, 851, 2, 852, 7, 852, 2, 853, 7, 853, 2, 854, 7, 854, 2, + 855, 7, 855, 2, 856, 7, 856, 2, 857, 7, 857, 2, 858, 7, 858, 2, 859, 7, + 859, 2, 860, 7, 860, 2, 861, 7, 861, 2, 862, 7, 862, 2, 863, 7, 863, 2, + 864, 7, 864, 2, 865, 7, 865, 2, 866, 7, 866, 2, 867, 7, 867, 2, 868, 7, + 868, 2, 869, 7, 869, 2, 870, 7, 870, 2, 871, 7, 871, 2, 872, 7, 872, 2, + 873, 7, 873, 2, 874, 7, 874, 2, 875, 7, 875, 2, 876, 7, 876, 2, 877, 7, + 877, 2, 878, 7, 878, 2, 879, 7, 879, 2, 880, 7, 880, 2, 881, 7, 881, 2, + 882, 7, 882, 2, 883, 7, 883, 2, 884, 7, 884, 2, 885, 7, 885, 2, 886, 7, + 886, 2, 887, 7, 887, 2, 888, 7, 888, 2, 889, 7, 889, 2, 890, 7, 890, 2, + 891, 7, 891, 2, 892, 7, 892, 2, 893, 7, 893, 2, 894, 7, 894, 2, 895, 7, + 895, 2, 896, 7, 896, 2, 897, 7, 897, 2, 898, 7, 898, 2, 899, 7, 899, 2, + 900, 7, 900, 2, 901, 7, 901, 2, 902, 7, 902, 2, 903, 7, 903, 2, 904, 7, + 904, 2, 905, 7, 905, 2, 906, 7, 906, 2, 907, 7, 907, 2, 908, 7, 908, 2, + 909, 7, 909, 2, 910, 7, 910, 2, 911, 7, 911, 2, 912, 7, 912, 2, 913, 7, + 913, 2, 914, 7, 914, 2, 915, 7, 915, 2, 916, 7, 916, 2, 917, 7, 917, 2, + 918, 7, 918, 2, 919, 7, 919, 2, 920, 7, 920, 2, 921, 7, 921, 2, 922, 7, + 922, 2, 923, 7, 923, 2, 924, 7, 924, 2, 925, 7, 925, 2, 926, 7, 926, 2, + 927, 7, 927, 2, 928, 7, 928, 2, 929, 7, 929, 2, 930, 7, 930, 2, 931, 7, + 931, 2, 932, 7, 932, 2, 933, 7, 933, 2, 934, 7, 934, 2, 935, 7, 935, 2, + 936, 7, 936, 2, 937, 7, 937, 2, 938, 7, 938, 2, 939, 7, 939, 2, 940, 7, + 940, 2, 941, 7, 941, 2, 942, 7, 942, 2, 943, 7, 943, 2, 944, 7, 944, 2, + 945, 7, 945, 2, 946, 7, 946, 2, 947, 7, 947, 2, 948, 7, 948, 2, 949, 7, + 949, 2, 950, 7, 950, 2, 951, 7, 951, 2, 952, 7, 952, 2, 953, 7, 953, 2, + 954, 7, 954, 2, 955, 7, 955, 2, 956, 7, 956, 2, 957, 7, 957, 2, 958, 7, + 958, 2, 959, 7, 959, 2, 960, 7, 960, 2, 961, 7, 961, 2, 962, 7, 962, 2, + 963, 7, 963, 2, 964, 7, 964, 2, 965, 7, 965, 2, 966, 7, 966, 2, 967, 7, + 967, 2, 968, 7, 968, 2, 969, 7, 969, 2, 970, 7, 970, 2, 971, 7, 971, 2, + 972, 7, 972, 2, 973, 7, 973, 2, 974, 7, 974, 2, 975, 7, 975, 2, 976, 7, + 976, 2, 977, 7, 977, 2, 978, 7, 978, 2, 979, 7, 979, 2, 980, 7, 980, 2, + 981, 7, 981, 2, 982, 7, 982, 2, 983, 7, 983, 2, 984, 7, 984, 2, 985, 7, + 985, 2, 986, 7, 986, 2, 987, 7, 987, 2, 988, 7, 988, 2, 989, 7, 989, 2, + 990, 7, 990, 2, 991, 7, 991, 2, 992, 7, 992, 2, 993, 7, 993, 2, 994, 7, + 994, 2, 995, 7, 995, 2, 996, 7, 996, 2, 997, 7, 997, 2, 998, 7, 998, 2, + 999, 7, 999, 2, 1000, 7, 1000, 2, 1001, 7, 1001, 2, 1002, 7, 1002, 2, 1003, + 7, 1003, 2, 1004, 7, 1004, 2, 1005, 7, 1005, 2, 1006, 7, 1006, 2, 1007, + 7, 1007, 2, 1008, 7, 1008, 2, 1009, 7, 1009, 2, 1010, 7, 1010, 2, 1011, + 7, 1011, 2, 1012, 7, 1012, 2, 1013, 7, 1013, 2, 1014, 7, 1014, 2, 1015, + 7, 1015, 2, 1016, 7, 1016, 2, 1017, 7, 1017, 2, 1018, 7, 1018, 2, 1019, + 7, 1019, 2, 1020, 7, 1020, 2, 1021, 7, 1021, 2, 1022, 7, 1022, 2, 1023, + 7, 1023, 2, 1024, 7, 1024, 2, 1025, 7, 1025, 2, 1026, 7, 1026, 2, 1027, + 7, 1027, 2, 1028, 7, 1028, 2, 1029, 7, 1029, 2, 1030, 7, 1030, 2, 1031, + 7, 1031, 2, 1032, 7, 1032, 2, 1033, 7, 1033, 2, 1034, 7, 1034, 2, 1035, + 7, 1035, 2, 1036, 7, 1036, 2, 1037, 7, 1037, 2, 1038, 7, 1038, 2, 1039, + 7, 1039, 2, 1040, 7, 1040, 2, 1041, 7, 1041, 2, 1042, 7, 1042, 2, 1043, + 7, 1043, 2, 1044, 7, 1044, 2, 1045, 7, 1045, 2, 1046, 7, 1046, 2, 1047, + 7, 1047, 2, 1048, 7, 1048, 2, 1049, 7, 1049, 2, 1050, 7, 1050, 2, 1051, + 7, 1051, 2, 1052, 7, 1052, 2, 1053, 7, 1053, 2, 1054, 7, 1054, 2, 1055, + 7, 1055, 2, 1056, 7, 1056, 2, 1057, 7, 1057, 2, 1058, 7, 1058, 2, 1059, + 7, 1059, 2, 1060, 7, 1060, 2, 1061, 7, 1061, 2, 1062, 7, 1062, 2, 1063, + 7, 1063, 2, 1064, 7, 1064, 2, 1065, 7, 1065, 2, 1066, 7, 1066, 2, 1067, + 7, 1067, 2, 1068, 7, 1068, 2, 1069, 7, 1069, 2, 1070, 7, 1070, 2, 1071, + 7, 1071, 2, 1072, 7, 1072, 2, 1073, 7, 1073, 2, 1074, 7, 1074, 2, 1075, + 7, 1075, 2, 1076, 7, 1076, 2, 1077, 7, 1077, 2, 1078, 7, 1078, 2, 1079, + 7, 1079, 2, 1080, 7, 1080, 2, 1081, 7, 1081, 2, 1082, 7, 1082, 2, 1083, + 7, 1083, 2, 1084, 7, 1084, 2, 1085, 7, 1085, 2, 1086, 7, 1086, 2, 1087, + 7, 1087, 2, 1088, 7, 1088, 2, 1089, 7, 1089, 2, 1090, 7, 1090, 2, 1091, + 7, 1091, 2, 1092, 7, 1092, 2, 1093, 7, 1093, 2, 1094, 7, 1094, 2, 1095, + 7, 1095, 2, 1096, 7, 1096, 2, 1097, 7, 1097, 2, 1098, 7, 1098, 2, 1099, + 7, 1099, 2, 1100, 7, 1100, 2, 1101, 7, 1101, 2, 1102, 7, 1102, 2, 1103, + 7, 1103, 2, 1104, 7, 1104, 2, 1105, 7, 1105, 2, 1106, 7, 1106, 2, 1107, + 7, 1107, 2, 1108, 7, 1108, 2, 1109, 7, 1109, 2, 1110, 7, 1110, 2, 1111, + 7, 1111, 2, 1112, 7, 1112, 2, 1113, 7, 1113, 2, 1114, 7, 1114, 2, 1115, + 7, 1115, 2, 1116, 7, 1116, 2, 1117, 7, 1117, 2, 1118, 7, 1118, 2, 1119, + 7, 1119, 2, 1120, 7, 1120, 2, 1121, 7, 1121, 2, 1122, 7, 1122, 2, 1123, + 7, 1123, 2, 1124, 7, 1124, 2, 1125, 7, 1125, 2, 1126, 7, 1126, 2, 1127, + 7, 1127, 2, 1128, 7, 1128, 2, 1129, 7, 1129, 2, 1130, 7, 1130, 2, 1131, + 7, 1131, 2, 1132, 7, 1132, 2, 1133, 7, 1133, 2, 1134, 7, 1134, 2, 1135, + 7, 1135, 2, 1136, 7, 1136, 2, 1137, 7, 1137, 2, 1138, 7, 1138, 2, 1139, + 7, 1139, 2, 1140, 7, 1140, 2, 1141, 7, 1141, 2, 1142, 7, 1142, 2, 1143, + 7, 1143, 2, 1144, 7, 1144, 2, 1145, 7, 1145, 2, 1146, 7, 1146, 2, 1147, + 7, 1147, 2, 1148, 7, 1148, 2, 1149, 7, 1149, 2, 1150, 7, 1150, 2, 1151, + 7, 1151, 2, 1152, 7, 1152, 2, 1153, 7, 1153, 2, 1154, 7, 1154, 2, 1155, + 7, 1155, 2, 1156, 7, 1156, 2, 1157, 7, 1157, 2, 1158, 7, 1158, 2, 1159, + 7, 1159, 2, 1160, 7, 1160, 2, 1161, 7, 1161, 2, 1162, 7, 1162, 2, 1163, + 7, 1163, 2, 1164, 7, 1164, 2, 1165, 7, 1165, 2, 1166, 7, 1166, 2, 1167, + 7, 1167, 2, 1168, 7, 1168, 2, 1169, 7, 1169, 2, 1170, 7, 1170, 2, 1171, + 7, 1171, 2, 1172, 7, 1172, 2, 1173, 7, 1173, 2, 1174, 7, 1174, 2, 1175, + 7, 1175, 2, 1176, 7, 1176, 2, 1177, 7, 1177, 2, 1178, 7, 1178, 2, 1179, + 7, 1179, 2, 1180, 7, 1180, 2, 1181, 7, 1181, 2, 1182, 7, 1182, 2, 1183, + 7, 1183, 2, 1184, 7, 1184, 2, 1185, 7, 1185, 2, 1186, 7, 1186, 2, 1187, + 7, 1187, 2, 1188, 7, 1188, 2, 1189, 7, 1189, 2, 1190, 7, 1190, 2, 1191, + 7, 1191, 2, 1192, 7, 1192, 2, 1193, 7, 1193, 2, 1194, 7, 1194, 2, 1195, + 7, 1195, 2, 1196, 7, 1196, 2, 1197, 7, 1197, 2, 1198, 7, 1198, 2, 1199, + 7, 1199, 2, 1200, 7, 1200, 2, 1201, 7, 1201, 2, 1202, 7, 1202, 2, 1203, + 7, 1203, 2, 1204, 7, 1204, 2, 1205, 7, 1205, 2, 1206, 7, 1206, 2, 1207, + 7, 1207, 2, 1208, 7, 1208, 2, 1209, 7, 1209, 2, 1210, 7, 1210, 2, 1211, + 7, 1211, 2, 1212, 7, 1212, 2, 1213, 7, 1213, 2, 1214, 7, 1214, 2, 1215, + 7, 1215, 2, 1216, 7, 1216, 2, 1217, 7, 1217, 2, 1218, 7, 1218, 2, 1219, + 7, 1219, 2, 1220, 7, 1220, 2, 1221, 7, 1221, 2, 1222, 7, 1222, 2, 1223, + 7, 1223, 2, 1224, 7, 1224, 2, 1225, 7, 1225, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, + 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, + 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, + 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, + 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, + 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, + 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, + 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, + 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, + 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, + 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, + 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, + 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, + 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, + 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, + 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, + 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, + 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, + 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, + 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, + 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, + 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, + 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, + 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, + 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, + 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, + 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, + 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, + 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, + 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, + 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, + 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, + 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, + 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, + 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, + 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, + 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, + 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, + 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, + 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, + 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, + 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, + 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, + 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, + 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, + 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, + 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, + 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, + 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, + 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, + 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, + 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, + 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, + 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, + 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, + 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, + 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, + 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, + 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, + 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, + 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, + 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, + 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, + 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, + 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, + 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, + 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, + 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, + 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, + 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, + 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, + 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, + 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, + 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, + 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, + 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, + 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, + 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, + 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, + 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, + 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, + 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, + 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, + 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, + 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, + 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, + 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, + 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, + 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, + 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, + 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, + 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, + 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, + 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, + 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, + 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, + 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, + 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, + 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, + 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, + 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, + 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, + 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, + 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, + 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, + 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, + 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, + 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, + 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, + 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, + 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, + 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, + 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, + 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, + 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, + 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, + 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, + 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, + 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, + 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, + 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, + 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, + 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, + 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, + 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, + 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, + 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, + 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, + 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, + 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, + 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, + 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, + 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, + 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, + 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, + 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, + 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, + 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, + 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, + 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, + 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, + 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, + 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, + 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, + 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, + 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, + 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, + 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, + 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, + 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, + 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, + 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, + 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, + 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, + 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, + 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, + 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, + 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, + 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, + 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, + 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, + 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, + 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, + 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, + 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, + 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, + 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, + 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, + 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, + 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, + 1, 157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, + 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, + 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, + 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, + 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, + 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, + 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, + 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, + 1, 161, 1, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, + 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, + 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, + 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, + 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, + 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, + 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, + 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, + 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, + 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, + 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, + 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, + 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, + 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, + 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, + 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, + 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, + 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, + 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, + 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, + 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, + 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, + 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, + 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, + 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, + 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, + 1, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, + 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, + 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 182, 1, 182, 1, 182, + 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, + 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, + 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, + 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 186, + 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, + 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, + 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, + 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, + 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, + 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, + 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, + 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 3, 191, 4691, 8, 191, 1, 191, 1, + 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, + 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, + 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, + 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, + 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, + 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, + 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, + 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, + 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, + 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, + 200, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, + 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, + 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, + 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, + 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, 1, + 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, 1, + 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, + 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, + 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, + 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, + 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, + 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, + 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, + 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, + 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, + 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, + 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, + 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, + 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, + 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, + 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, + 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, + 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, + 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, + 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, + 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, + 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, + 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, + 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, + 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, + 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, + 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, + 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, + 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, + 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, + 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, + 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, + 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, + 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, + 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, + 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, + 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, + 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, + 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, + 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, + 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, + 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, + 233, 1, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, + 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, + 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, + 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, + 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 1, + 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, + 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, + 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, + 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, + 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, + 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, + 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, + 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, + 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, + 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, + 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, + 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, + 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, + 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, + 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, + 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, + 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, + 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 252, 1, + 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, + 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, + 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 1, + 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, 1, + 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, + 256, 1, 256, 1, 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, + 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, 258, 1, + 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, + 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, + 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, + 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, + 262, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, + 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, + 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, + 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, + 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, + 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, + 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, + 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, + 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 272, 1, 272, 1, 272, 1, + 272, 1, 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, + 273, 1, 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, + 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 275, 1, + 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, + 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, + 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, + 277, 1, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, + 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, 1, 281, 1, + 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, + 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, + 282, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, + 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 1, + 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, + 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, 286, 1, + 286, 1, 286, 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, + 287, 1, 287, 1, 287, 1, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, + 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, + 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 291, 1, 291, 1, + 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, 292, 1, + 292, 1, 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, + 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, + 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, + 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, + 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 296, 1, + 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, + 296, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, + 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 298, 1, + 298, 1, 298, 1, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, + 299, 1, 299, 1, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, + 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, + 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, + 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, + 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, + 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, + 303, 1, 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, + 304, 1, 304, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, + 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, + 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, + 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, + 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, + 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, + 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, + 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, + 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, + 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, + 311, 1, 311, 1, 311, 1, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, + 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, + 313, 1, 313, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, + 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, + 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 315, 1, + 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, + 316, 1, 316, 1, 316, 1, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, + 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 318, 1, 318, 1, 318, 1, + 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, + 318, 1, 318, 1, 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, + 319, 1, 319, 1, 319, 3, 319, 6110, 8, 319, 1, 320, 1, 320, 1, 320, 1, 320, + 1, 320, 1, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, + 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 323, + 1, 323, 1, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, + 1, 324, 1, 324, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, + 1, 325, 1, 325, 1, 325, 1, 325, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, + 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 327, 1, 327, + 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 328, 1, 328, + 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, + 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, + 1, 328, 1, 328, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, + 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 1, 330, 1, 330, 1, 330, + 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, + 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, + 1, 331, 1, 331, 1, 331, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, + 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, + 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 334, + 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 335, 1, 335, + 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, + 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, + 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, + 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, + 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 337, + 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, + 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 338, 1, 338, 1, 338, 1, 338, + 1, 338, 1, 338, 1, 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 340, + 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, + 1, 340, 1, 340, 1, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, + 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 343, 1, 343, 1, 343, 1, 343, + 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 344, 1, 344, 1, 344, + 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, + 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 345, 1, 345, 1, 345, + 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, + 1, 345, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, + 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, 1, 347, + 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, + 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, + 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, + 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, + 1, 350, 1, 350, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, + 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, + 1, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, + 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, + 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 354, + 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 355, 1, 355, + 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 356, + 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, + 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, + 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 358, 1, 358, 1, 358, 1, 358, + 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 359, 1, 359, + 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 360, 1, 360, 1, 360, 1, 360, + 1, 360, 1, 360, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, + 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 1, 362, + 1, 362, 1, 362, 1, 362, 1, 362, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, + 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 364, 1, 364, 1, 364, 1, 364, + 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 366, 1, 366, 1, 366, + 1, 366, 1, 366, 1, 366, 1, 366, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, + 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 368, 1, 368, + 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 369, 1, 369, 1, 369, + 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 370, 1, 370, + 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, + 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, + 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, + 1, 370, 1, 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, + 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, + 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, + 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, 1, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 1, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, + 1, 373, 1, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, + 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, + 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, + 1, 375, 1, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 377, 1, 377, + 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 378, 1, 378, + 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, + 1, 378, 1, 378, 1, 378, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 380, + 1, 380, 1, 380, 1, 380, 1, 380, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, + 1, 381, 1, 381, 1, 381, 1, 381, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, + 1, 382, 1, 382, 1, 382, 1, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, + 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, + 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, + 1, 383, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, + 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, + 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 385, 1, 385, + 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 386, 1, 386, + 1, 386, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, + 1, 387, 1, 387, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, + 1, 388, 1, 388, 1, 388, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, + 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, + 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 390, 1, 390, 1, 390, 1, 390, + 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, + 1, 390, 1, 390, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, + 1, 391, 1, 391, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, + 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, + 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, + 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 394, + 1, 394, 1, 394, 1, 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, + 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, + 1, 396, 1, 396, 1, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, + 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, + 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 399, 1, 399, 1, 399, 1, 399, + 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, + 1, 399, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, + 1, 400, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, + 1, 402, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, + 1, 403, 1, 403, 1, 403, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, + 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, + 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, + 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, + 1, 404, 1, 404, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, + 1, 406, 1, 406, 1, 406, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 408, + 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 409, + 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 410, 1, 410, 1, 410, 1, 410, + 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 411, 1, 411, 1, 411, 1, 411, + 1, 411, 1, 411, 1, 412, 1, 412, 1, 412, 1, 412, 1, 412, 1, 412, 1, 412, + 1, 412, 1, 412, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, + 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 414, 1, 414, 1, 414, 1, 414, + 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, + 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, + 1, 415, 1, 415, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 417, 1, 417, + 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 418, 1, 418, 1, 418, 1, 418, + 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, + 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, + 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, + 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 421, 1, 421, + 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, + 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 422, + 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, + 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, + 1, 422, 1, 422, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 424, 1, 424, + 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 425, 1, 425, 1, 425, 1, 425, + 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 426, + 1, 426, 1, 426, 1, 426, 1, 426, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, + 1, 427, 1, 427, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, + 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, + 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 429, + 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 430, 1, 430, + 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 431, + 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 432, 1, 432, 1, 432, 1, 432, + 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 433, 1, 433, 1, 433, 1, 433, + 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 434, + 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, + 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 435, 1, 435, 1, 435, + 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, + 1, 435, 1, 435, 1, 435, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, + 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 437, + 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, + 1, 437, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, + 1, 438, 1, 438, 1, 438, 1, 439, 1, 439, 1, 439, 1, 440, 1, 440, 1, 440, + 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, + 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 441, 1, 441, + 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, + 1, 441, 1, 441, 1, 441, 1, 441, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, + 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, + 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, + 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, + 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, + 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, + 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 445, 1, 445, + 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, + 1, 446, 1, 446, 1, 446, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, + 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 448, 1, 448, 1, 448, + 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, + 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, + 1, 448, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, + 1, 449, 1, 449, 1, 449, 1, 450, 1, 450, 1, 450, 1, 451, 1, 451, 1, 451, + 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 452, 1, 452, 1, 452, 1, 452, + 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, + 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 453, 1, 453, + 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 454, + 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, + 1, 454, 1, 454, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 456, + 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, + 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 457, + 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, + 1, 457, 1, 457, 1, 457, 1, 457, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, + 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 459, 1, 459, 1, 459, 1, 459, + 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 460, 1, 460, 1, 460, 1, 460, + 1, 460, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, + 1, 461, 1, 461, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 463, + 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 464, 1, 464, 1, 464, 1, 464, + 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 465, + 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 466, 1, 466, 1, 466, + 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 467, 1, 467, 1, 467, + 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 468, 1, 468, 1, 468, 1, 468, + 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, + 1, 469, 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, 1, 471, 1, 471, 1, 471, + 1, 472, 1, 472, 1, 472, 1, 473, 1, 473, 1, 473, 1, 474, 1, 474, 1, 474, + 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, + 1, 474, 1, 474, 1, 474, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, + 1, 475, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 477, + 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, + 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, + 1, 478, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, + 1, 479, 1, 479, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, + 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 481, 1, 481, + 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, + 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 482, 1, 482, 1, 482, + 1, 482, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 484, 1, 484, 1, 484, + 1, 484, 1, 484, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, + 1, 485, 1, 485, 1, 485, 1, 485, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, + 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 487, 1, 487, + 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, + 1, 487, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, + 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, + 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, + 1, 489, 1, 489, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, + 1, 490, 1, 490, 1, 490, 1, 490, 1, 491, 1, 491, 1, 491, 1, 492, 1, 492, + 1, 492, 1, 492, 1, 492, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, + 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 494, 1, 494, + 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 495, + 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, + 1, 495, 1, 495, 1, 495, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, + 1, 496, 1, 496, 1, 496, 1, 497, 1, 497, 1, 497, 1, 497, 1, 498, 1, 498, + 1, 498, 1, 498, 1, 498, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, + 1, 499, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, + 1, 500, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, + 1, 501, 1, 501, 1, 501, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, + 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, + 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, + 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 504, 1, 504, 1, 504, 1, 504, + 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, + 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 507, 1, 507, 1, 507, 1, 507, + 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 508, 1, 508, + 1, 508, 1, 508, 1, 508, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, + 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 511, 1, 511, 1, 511, 1, 511, + 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 513, 1, 513, 1, 513, + 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 514, 1, 514, 1, 514, 1, 514, + 1, 514, 1, 514, 1, 514, 1, 514, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, + 1, 515, 1, 515, 1, 515, 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, + 1, 516, 1, 516, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, + 1, 517, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, + 1, 518, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 520, 1, 520, 1, 520, + 1, 520, 1, 520, 1, 520, 1, 520, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, + 1, 521, 1, 521, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 523, + 1, 523, 1, 523, 1, 523, 1, 523, 1, 524, 1, 524, 1, 524, 1, 524, 1, 524, + 1, 524, 1, 524, 1, 524, 1, 524, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, + 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 526, 1, 526, + 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, + 1, 526, 1, 526, 1, 526, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, + 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 528, 1, 528, + 1, 528, 1, 528, 1, 528, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, + 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, + 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 531, 1, 531, 1, 531, + 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, + 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 533, 1, 533, + 1, 533, 1, 533, 1, 533, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, + 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, + 1, 534, 1, 535, 1, 535, 1, 535, 1, 535, 1, 536, 1, 536, 1, 536, 1, 536, + 1, 536, 1, 536, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, + 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 538, 1, 538, + 1, 538, 1, 538, 1, 538, 1, 539, 1, 539, 1, 539, 1, 539, 1, 540, 1, 540, + 1, 540, 1, 540, 1, 540, 1, 540, 1, 541, 1, 541, 1, 541, 1, 541, 1, 541, + 1, 541, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 543, + 1, 543, 1, 543, 1, 543, 1, 543, 1, 544, 1, 544, 1, 544, 1, 544, 1, 544, + 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 546, 1, 546, + 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 547, 1, 547, 1, 547, 1, 547, + 1, 547, 1, 547, 1, 547, 1, 547, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, + 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 549, + 1, 549, 1, 549, 1, 549, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, + 1, 550, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, + 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 552, 1, 552, 1, 552, 1, 552, + 1, 552, 1, 552, 1, 552, 1, 552, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, + 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 554, 1, 554, + 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 555, 1, 555, + 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, + 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 556, 1, 556, 1, 556, 1, 556, + 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, + 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 557, + 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 558, 1, 558, + 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, + 1, 558, 1, 558, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, + 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 560, + 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, + 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, + 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, + 1, 561, 1, 561, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, + 1, 562, 1, 562, 1, 562, 1, 562, 1, 563, 1, 563, 1, 563, 1, 563, 1, 563, + 1, 563, 1, 563, 1, 563, 1, 563, 1, 563, 1, 563, 1, 563, 1, 563, 1, 563, + 1, 563, 1, 563, 1, 563, 1, 563, 1, 563, 1, 564, 1, 564, 1, 564, 1, 564, + 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, + 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, + 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 565, + 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, + 1, 565, 1, 565, 1, 565, 1, 565, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, + 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, + 1, 566, 1, 566, 1, 566, 1, 566, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, + 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, + 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 568, 1, 568, 1, 568, 1, 568, + 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 569, 1, 569, 1, 569, 1, 570, + 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, + 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 571, 1, 571, + 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 572, + 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 1, 573, 1, 573, 1, 573, + 1, 573, 1, 573, 1, 573, 1, 573, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, + 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, + 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 575, + 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, + 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, + 1, 575, 1, 575, 1, 575, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, + 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 578, + 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, + 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, + 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, + 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, + 1, 579, 1, 579, 1, 579, 1, 580, 1, 580, 1, 580, 1, 580, 1, 581, 1, 581, + 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 582, 1, 582, 1, 582, + 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 583, 1, 583, 1, 583, + 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, + 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, + 1, 583, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, + 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 585, + 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, + 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, + 1, 585, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, + 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, + 1, 586, 1, 586, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, + 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, + 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 589, 1, 589, 1, 589, + 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, + 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, + 1, 589, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 591, 1, 591, 1, 591, + 1, 591, 1, 591, 1, 591, 1, 591, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, + 1, 592, 1, 592, 1, 592, 1, 592, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, + 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, + 1, 594, 1, 594, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, + 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 596, 1, 596, 1, 596, 1, 596, + 1, 596, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, + 1, 597, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 599, 1, 599, + 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 600, + 1, 600, 1, 600, 1, 600, 1, 600, 1, 600, 1, 600, 1, 600, 1, 600, 1, 600, + 1, 600, 1, 600, 1, 600, 1, 600, 1, 600, 1, 600, 1, 601, 1, 601, 1, 601, + 1, 601, 1, 601, 1, 601, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, + 1, 602, 1, 602, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, + 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, + 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, + 1, 604, 1, 604, 1, 604, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, + 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 606, 1, 606, 1, 606, 1, 606, + 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, + 1, 607, 1, 607, 1, 607, 1, 607, 1, 607, 1, 608, 1, 608, 1, 608, 1, 609, + 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 610, 1, 610, + 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 611, 1, 611, 1, 611, + 1, 611, 1, 611, 1, 611, 1, 612, 1, 612, 1, 612, 1, 612, 1, 612, 1, 612, + 1, 612, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, + 1, 613, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, + 1, 614, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, + 1, 615, 1, 615, 1, 615, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, + 1, 616, 1, 616, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, + 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 619, 1, 619, + 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, + 1, 619, 1, 619, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 621, 1, 621, + 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, + 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, + 1, 621, 1, 621, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, + 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 623, 1, 623, 1, 623, 1, 623, + 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 624, 1, 624, + 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 625, 1, 625, + 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 626, 1, 626, 1, 626, 1, 626, + 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, + 1, 627, 1, 627, 1, 627, 1, 627, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, + 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, + 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, + 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 631, 1, 631, + 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, + 1, 631, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, + 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 633, 1, 633, + 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, + 1, 633, 1, 633, 1, 633, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, + 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 635, 1, 635, 1, 635, + 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, + 1, 635, 1, 635, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, + 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 637, 1, 637, + 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, + 1, 637, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, + 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 640, 1, 640, 1, 640, + 1, 640, 1, 640, 1, 641, 1, 641, 1, 641, 1, 641, 1, 641, 1, 641, 1, 641, + 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 643, 1, 643, 1, 643, 1, 643, + 1, 643, 1, 643, 1, 643, 1, 643, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, + 1, 644, 1, 644, 1, 644, 1, 644, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, + 1, 645, 1, 645, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, + 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, + 1, 646, 1, 646, 1, 646, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, + 1, 647, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, + 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 649, 1, 649, + 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, + 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 650, 1, 650, 1, 650, + 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, + 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, 1, 650, 1, 651, 1, 651, 1, 651, + 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 652, 1, 652, + 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, + 1, 652, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, + 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, + 1, 653, 1, 653, 1, 654, 1, 654, 1, 654, 1, 655, 1, 655, 1, 655, 1, 655, + 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 657, + 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 658, 1, 658, 1, 658, + 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 659, 1, 659, 1, 659, 1, 659, + 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 660, + 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, + 1, 660, 1, 660, 1, 660, 1, 661, 1, 661, 1, 661, 1, 662, 1, 662, 1, 662, + 1, 662, 1, 662, 1, 662, 1, 662, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, + 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, + 1, 664, 1, 664, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 666, 1, 666, + 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, + 1, 666, 1, 666, 1, 666, 1, 666, 1, 667, 1, 667, 1, 667, 1, 667, 1, 667, + 1, 667, 1, 667, 1, 667, 1, 667, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, + 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, 669, 1, 669, 1, 669, 1, 669, + 1, 669, 1, 669, 1, 669, 1, 669, 1, 669, 1, 669, 1, 669, 1, 670, 1, 670, + 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 1, 671, 1, 671, 1, 671, + 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, + 1, 671, 1, 671, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, + 1, 672, 1, 672, 1, 672, 1, 672, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, + 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 674, 1, 674, 1, 674, + 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 675, 1, 675, 1, 675, + 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, + 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, + 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 676, 1, 676, + 1, 676, 1, 676, 1, 676, 1, 676, 1, 676, 1, 677, 1, 677, 1, 677, 1, 678, + 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 679, 1, 679, 1, 679, 1, 679, + 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, + 1, 679, 1, 679, 1, 679, 1, 679, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, + 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, + 1, 680, 1, 681, 1, 681, 1, 681, 1, 681, 1, 682, 1, 682, 1, 682, 1, 682, + 1, 682, 1, 682, 1, 683, 1, 683, 1, 683, 1, 683, 1, 683, 1, 683, 1, 683, + 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 685, 1, 685, 1, 685, 1, 685, + 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 686, 1, 686, 1, 686, 1, 686, + 1, 686, 1, 686, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, + 1, 687, 1, 687, 1, 687, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, + 1, 688, 1, 688, 1, 688, 1, 688, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, + 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, + 1, 690, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, + 1, 691, 1, 691, 1, 691, 1, 691, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, + 1, 692, 1, 692, 1, 692, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, + 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, + 1, 693, 1, 693, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, + 1, 694, 1, 694, 1, 694, 1, 694, 1, 695, 1, 695, 1, 695, 1, 695, 3, 695, + 10066, 8, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 696, + 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, + 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, + 1, 697, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, + 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, + 1, 699, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, + 1, 700, 1, 700, 1, 700, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, + 1, 701, 1, 701, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, + 1, 702, 1, 702, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 704, 1, 704, + 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 705, 1, 705, + 1, 705, 1, 705, 1, 705, 1, 705, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, + 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, + 1, 706, 1, 706, 1, 706, 1, 706, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, + 1, 707, 1, 707, 1, 707, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, + 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, + 1, 708, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, + 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 710, + 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, 1, 710, + 1, 710, 1, 710, 1, 710, 1, 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, 711, + 1, 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, 712, 1, 712, 1, 712, + 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, + 1, 712, 1, 712, 1, 712, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, + 1, 713, 1, 713, 1, 713, 1, 713, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, + 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, + 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, + 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 716, + 1, 716, 1, 716, 1, 716, 1, 716, 1, 716, 1, 716, 1, 717, 1, 717, 1, 717, + 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, 718, 1, 718, 1, 718, + 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, + 1, 718, 1, 718, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 720, + 1, 720, 1, 720, 1, 720, 1, 720, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, + 1, 721, 1, 721, 1, 721, 1, 721, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, + 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, + 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, + 1, 722, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 724, + 1, 724, 1, 724, 1, 724, 1, 724, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, + 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, + 1, 726, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, + 1, 727, 1, 727, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, + 1, 728, 1, 728, 1, 728, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, + 1, 729, 1, 729, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, + 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 731, 1, 731, 1, 731, + 1, 731, 1, 731, 1, 731, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, + 1, 733, 1, 733, 1, 733, 1, 733, 1, 733, 1, 733, 1, 733, 1, 733, 1, 733, + 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, + 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, 1, 735, 1, 735, 1, 735, + 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 736, 1, 736, 1, 736, 1, 736, + 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 737, + 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, + 1, 737, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 739, 1, 739, 1, 739, + 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 740, 1, 740, + 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 741, + 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, + 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 742, 1, 742, 1, 742, 1, 742, + 1, 742, 1, 742, 1, 742, 1, 742, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, + 1, 743, 1, 743, 1, 743, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, + 1, 744, 1, 744, 1, 744, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, + 1, 745, 1, 745, 1, 745, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, + 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, + 1, 746, 1, 746, 1, 746, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, + 1, 747, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, + 1, 748, 1, 748, 1, 748, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, + 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 750, 1, 750, 1, 750, 1, 750, + 1, 750, 1, 750, 1, 750, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, + 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 753, + 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 754, 1, 754, 1, 754, 1, 754, + 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 755, + 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, + 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 756, + 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, + 1, 757, 1, 757, 1, 758, 1, 758, 1, 758, 1, 758, 1, 758, 1, 758, 1, 758, + 1, 758, 1, 758, 1, 758, 1, 759, 1, 759, 1, 759, 1, 759, 1, 759, 1, 759, + 1, 759, 1, 759, 1, 759, 1, 759, 1, 759, 1, 760, 1, 760, 1, 760, 1, 760, + 1, 760, 1, 760, 1, 761, 1, 761, 1, 761, 1, 761, 1, 761, 1, 762, 1, 762, + 1, 762, 1, 762, 1, 763, 1, 763, 1, 763, 1, 763, 1, 764, 1, 764, 1, 764, + 1, 764, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, + 1, 766, 1, 766, 1, 766, 1, 766, 1, 766, 1, 767, 1, 767, 1, 767, 1, 767, + 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, + 1, 767, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, + 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, + 1, 768, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, + 1, 769, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, + 1, 770, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, 1, 771, + 1, 771, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, + 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 773, + 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, + 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, + 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, + 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 775, 1, 775, 1, 775, + 1, 775, 1, 775, 1, 775, 1, 775, 1, 775, 1, 775, 1, 775, 1, 776, 1, 776, + 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, + 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, + 1, 776, 1, 776, 1, 776, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, + 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 778, 1, 778, 1, 778, 1, 778, + 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, + 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, + 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 780, + 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 781, 1, 781, + 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 782, + 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, + 1, 782, 1, 782, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, + 1, 783, 1, 783, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, + 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, + 1, 784, 1, 784, 1, 784, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, + 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 786, 1, 786, 1, 786, 1, 786, + 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 787, 1, 787, + 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, + 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, + 1, 787, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, + 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, + 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, + 1, 788, 1, 789, 1, 789, 1, 789, 1, 789, 1, 789, 1, 789, 1, 789, 1, 789, + 1, 789, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 791, + 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, + 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, + 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 792, 1, 792, 1, 792, + 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, + 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 793, + 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 794, 1, 794, 1, 794, + 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 795, + 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, + 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, + 1, 795, 1, 795, 1, 795, 1, 795, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, + 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 797, 1, 797, + 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, + 1, 797, 1, 797, 1, 797, 1, 797, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, + 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 799, 1, 799, 1, 799, + 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, + 1, 799, 1, 799, 1, 799, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, + 1, 800, 1, 800, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, + 1, 801, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, + 1, 802, 1, 802, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, + 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 804, 1, 804, 1, 804, 1, 804, + 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, + 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, + 1, 804, 1, 804, 1, 804, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, + 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, + 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, + 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, + 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, + 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, + 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, + 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 807, 1, 807, 1, 807, + 1, 807, 1, 807, 1, 807, 1, 807, 1, 807, 1, 807, 1, 808, 1, 808, 1, 808, + 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, + 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, + 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, + 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, + 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 809, 1, 809, 1, 809, 1, 809, + 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 810, 1, 810, 1, 810, 1, 810, + 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, + 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 811, 1, 811, 1, 811, + 1, 811, 1, 811, 1, 811, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, + 1, 812, 1, 812, 1, 812, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, + 1, 813, 1, 813, 1, 813, 1, 813, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, + 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, + 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, + 1, 814, 1, 814, 1, 814, 1, 815, 1, 815, 1, 815, 1, 815, 1, 815, 1, 815, + 1, 815, 1, 815, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, + 1, 816, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, + 1, 817, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, + 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 819, + 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, + 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 821, 1, 821, + 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, + 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, + 1, 822, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 824, + 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 825, 1, 825, + 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 826, 1, 826, 1, 826, + 1, 826, 1, 826, 1, 826, 1, 826, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, + 1, 827, 1, 827, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, + 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 830, 1, 830, 1, 830, + 1, 830, 1, 830, 1, 830, 1, 830, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, + 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, + 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 834, 1, 834, 1, 834, 1, 834, + 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 835, + 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 836, 1, 836, 1, 836, 1, 836, + 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, + 1, 838, 1, 838, 1, 838, 1, 838, 1, 838, 1, 838, 1, 838, 1, 838, 1, 838, + 1, 838, 1, 838, 1, 838, 1, 838, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, + 1, 839, 1, 839, 1, 839, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, + 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 841, 1, 841, 1, 841, 1, 841, + 1, 841, 1, 841, 1, 841, 1, 841, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, + 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, + 1, 843, 1, 843, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, + 1, 844, 1, 844, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, + 1, 845, 1, 845, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, + 1, 846, 1, 846, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, + 1, 847, 1, 847, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, + 1, 848, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 850, 1, 850, + 1, 850, 1, 850, 1, 850, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 852, + 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 853, 1, 853, 1, 853, + 1, 853, 1, 853, 1, 853, 1, 853, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, + 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, + 1, 855, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 857, + 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, + 1, 857, 1, 857, 1, 857, 1, 857, 1, 858, 1, 858, 1, 858, 1, 858, 1, 858, + 1, 858, 1, 858, 1, 858, 1, 858, 1, 858, 1, 859, 1, 859, 1, 859, 1, 859, + 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 860, + 1, 860, 1, 860, 1, 860, 1, 860, 1, 860, 1, 860, 1, 861, 1, 861, 1, 861, + 1, 861, 1, 861, 1, 861, 1, 861, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, + 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, + 1, 862, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 864, + 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 865, 1, 865, 1, 865, + 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, + 1, 865, 1, 866, 1, 866, 1, 866, 1, 866, 1, 866, 1, 866, 1, 866, 1, 867, + 1, 867, 1, 867, 1, 867, 1, 867, 1, 867, 1, 867, 1, 867, 1, 867, 1, 867, + 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, + 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 869, 1, 869, 1, 869, + 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, + 1, 869, 1, 869, 1, 869, 1, 870, 1, 870, 1, 870, 1, 870, 1, 870, 1, 870, + 1, 870, 1, 870, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, + 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, + 1, 872, 1, 872, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, + 1, 873, 1, 873, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, + 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 875, 1, 875, + 1, 875, 1, 875, 1, 875, 1, 875, 1, 875, 1, 875, 1, 875, 1, 875, 1, 875, + 1, 875, 1, 875, 1, 876, 1, 876, 1, 876, 1, 876, 1, 876, 1, 876, 1, 876, + 1, 876, 1, 876, 1, 876, 1, 876, 1, 876, 1, 876, 1, 877, 1, 877, 1, 877, + 1, 877, 1, 877, 1, 877, 1, 877, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, + 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, + 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, + 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, 1, 880, 1, 880, 1, 880, 1, 880, + 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, + 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, + 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, + 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, + 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, + 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 882, 1, 882, 1, 882, + 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, + 1, 882, 1, 882, 1, 882, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 884, + 1, 884, 1, 884, 1, 884, 1, 884, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, + 1, 885, 1, 885, 1, 885, 1, 885, 1, 886, 1, 886, 1, 886, 1, 886, 1, 886, + 1, 886, 1, 886, 1, 886, 1, 886, 1, 886, 1, 886, 1, 886, 1, 886, 1, 886, + 1, 886, 1, 886, 1, 887, 1, 887, 1, 887, 1, 887, 1, 887, 1, 887, 1, 887, + 1, 887, 1, 887, 1, 887, 1, 887, 1, 887, 1, 887, 1, 888, 1, 888, 1, 888, + 1, 888, 1, 888, 1, 888, 1, 888, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, + 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, + 1, 889, 1, 890, 1, 890, 1, 890, 1, 890, 1, 890, 1, 890, 1, 890, 1, 890, + 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, + 1, 891, 1, 891, 1, 891, 1, 891, 1, 891, 1, 892, 1, 892, 1, 892, 1, 892, + 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, + 1, 892, 1, 892, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, + 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 894, 1, 894, 1, 894, + 1, 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, 895, 1, 895, 1, 895, 1, 895, + 1, 895, 1, 895, 1, 895, 1, 895, 1, 895, 1, 895, 1, 895, 1, 895, 1, 895, + 1, 895, 1, 895, 1, 895, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, + 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, + 1, 896, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, + 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 898, + 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, + 1, 898, 1, 898, 1, 898, 1, 899, 1, 899, 1, 899, 1, 899, 1, 900, 1, 900, + 1, 900, 1, 900, 1, 900, 1, 900, 1, 900, 1, 900, 1, 900, 1, 901, 1, 901, + 1, 901, 1, 901, 1, 901, 1, 902, 1, 902, 1, 902, 1, 902, 1, 902, 1, 902, + 1, 902, 1, 902, 1, 902, 1, 903, 1, 903, 1, 903, 1, 903, 1, 903, 1, 903, + 1, 903, 1, 903, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 905, + 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 906, 1, 906, 1, 906, + 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 907, + 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 908, + 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, + 1, 908, 1, 908, 1, 908, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, + 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 910, + 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, + 1, 910, 1, 910, 1, 910, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, + 1, 911, 1, 911, 1, 911, 1, 911, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, + 1, 912, 1, 912, 1, 912, 1, 912, 1, 913, 1, 913, 1, 913, 1, 913, 1, 914, + 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, + 1, 915, 1, 915, 1, 915, 1, 915, 1, 915, 1, 915, 1, 915, 1, 916, 1, 916, + 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, + 1, 916, 1, 917, 1, 917, 1, 917, 1, 917, 1, 917, 1, 918, 1, 918, 1, 918, + 1, 918, 1, 918, 1, 919, 1, 919, 1, 919, 1, 919, 1, 919, 1, 919, 1, 919, + 1, 919, 1, 919, 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, + 1, 920, 1, 920, 1, 921, 1, 921, 1, 921, 1, 921, 1, 921, 1, 921, 1, 921, + 1, 921, 1, 921, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 923, 1, 923, + 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, + 1, 923, 1, 923, 1, 923, 1, 923, 1, 924, 1, 924, 1, 924, 1, 924, 1, 924, + 1, 924, 1, 924, 1, 924, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, + 1, 925, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 927, 1, 927, + 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 928, 1, 928, 1, 928, 1, 928, + 1, 928, 1, 928, 1, 928, 1, 928, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, + 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, + 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, + 1, 929, 1, 929, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, + 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 931, 1, 931, + 1, 931, 1, 931, 1, 931, 1, 931, 1, 932, 1, 932, 1, 932, 1, 932, 1, 933, + 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, + 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 934, 1, 934, 1, 934, 1, 934, + 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, + 1, 934, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, + 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, + 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, + 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, + 1, 936, 1, 936, 1, 936, 1, 937, 1, 937, 1, 937, 1, 937, 1, 937, 1, 937, + 1, 937, 1, 937, 1, 938, 1, 938, 1, 938, 1, 938, 1, 938, 1, 938, 1, 939, + 1, 939, 1, 939, 1, 939, 1, 939, 1, 939, 1, 939, 1, 939, 1, 940, 1, 940, + 1, 940, 1, 940, 1, 940, 1, 940, 1, 940, 1, 940, 1, 940, 1, 940, 1, 940, + 1, 940, 1, 940, 1, 940, 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, + 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 942, 1, 942, 1, 942, 1, 942, + 1, 942, 1, 942, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, + 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, + 1, 944, 1, 944, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, + 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, + 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 946, 1, 946, + 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, + 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, + 1, 946, 1, 946, 1, 946, 1, 947, 1, 947, 1, 947, 1, 947, 1, 947, 1, 947, + 1, 948, 1, 948, 1, 948, 1, 948, 1, 948, 1, 948, 1, 948, 1, 948, 1, 948, + 1, 948, 1, 948, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, + 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 950, 1, 950, 1, 950, + 1, 950, 1, 950, 1, 950, 1, 950, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, + 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 952, 1, 952, 1, 952, + 1, 952, 1, 952, 1, 952, 1, 953, 1, 953, 1, 953, 1, 953, 1, 953, 1, 953, + 1, 953, 1, 954, 1, 954, 1, 954, 1, 954, 1, 954, 1, 955, 1, 955, 1, 955, + 1, 955, 1, 955, 1, 955, 1, 955, 1, 955, 1, 955, 1, 956, 1, 956, 1, 956, + 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 957, 1, 957, 1, 957, 1, 957, + 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, + 1, 957, 1, 958, 1, 958, 1, 958, 1, 958, 1, 959, 1, 959, 1, 959, 1, 959, + 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 960, 1, 960, + 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, + 1, 960, 1, 960, 1, 960, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, + 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 963, + 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, + 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, + 1, 964, 1, 964, 1, 964, 1, 964, 1, 965, 1, 965, 1, 965, 1, 965, 1, 965, + 1, 965, 1, 965, 1, 965, 1, 965, 1, 965, 1, 966, 1, 966, 1, 966, 1, 966, + 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, + 1, 967, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, + 1, 968, 1, 969, 1, 969, 1, 969, 1, 969, 1, 969, 1, 969, 1, 969, 1, 969, + 1, 969, 1, 969, 1, 969, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, + 1, 970, 1, 970, 1, 970, 1, 970, 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, + 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 972, 1, 972, + 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 973, 1, 973, 1, 973, + 1, 973, 1, 973, 1, 973, 1, 973, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, + 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 975, 1, 975, 1, 975, 1, 975, + 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, + 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 976, 1, 976, 1, 976, + 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 977, 1, 977, 1, 977, 1, 977, + 1, 977, 1, 977, 1, 977, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, + 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 979, 1, 979, 1, 979, + 1, 979, 1, 979, 1, 979, 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, + 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, 981, 1, 981, + 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, + 1, 981, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, + 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, + 1, 984, 1, 984, 1, 984, 1, 984, 1, 984, 1, 985, 1, 985, 1, 985, 1, 985, + 1, 985, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 987, + 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, + 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, + 1, 987, 1, 987, 1, 988, 1, 988, 1, 988, 1, 989, 1, 989, 1, 989, 1, 989, + 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, + 1, 990, 1, 990, 1, 990, 1, 990, 1, 991, 1, 991, 1, 991, 1, 991, 1, 991, + 1, 991, 1, 991, 1, 991, 1, 991, 1, 992, 1, 992, 1, 992, 1, 992, 1, 992, + 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 994, 1, 994, 1, 994, + 1, 994, 1, 994, 1, 995, 1, 995, 1, 995, 1, 995, 1, 995, 1, 996, 1, 996, + 1, 996, 1, 996, 1, 996, 1, 996, 1, 996, 1, 996, 1, 997, 1, 997, 1, 997, + 1, 997, 1, 997, 1, 997, 1, 998, 1, 998, 1, 998, 1, 998, 1, 998, 1, 998, + 1, 998, 1, 998, 1, 999, 1, 999, 1, 999, 1, 1000, 1, 1000, 1, 1000, 1, 1000, + 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, + 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, + 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1002, 1, 1002, 1, 1002, 1, 1002, + 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1003, 1, 1003, 1, 1003, + 1, 1003, 1, 1003, 1, 1003, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, + 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1005, 1, 1005, 1, 1005, 1, 1005, + 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, + 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1006, 1, 1006, 1, 1006, 1, 1006, + 1, 1006, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, + 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1008, 1, 1008, 1, 1008, + 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1008, + 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1009, 1, 1009, 1, 1009, 1, 1009, + 1, 1009, 1, 1009, 1, 1009, 1, 1009, 1, 1009, 1, 1010, 1, 1010, 1, 1010, + 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, + 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, + 1, 1010, 1, 1010, 1, 1010, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, + 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1012, 1, 1012, 1, 1012, + 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1013, 1, 1013, 1, 1013, + 1, 1013, 1, 1013, 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, + 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1015, 1, 1015, 1, 1015, + 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, + 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1016, 1, 1016, 1, 1016, + 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1017, 1, 1017, + 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, + 1, 1017, 1, 1017, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1019, 1, 1019, + 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1020, + 1, 1020, 1, 1020, 1, 1020, 1, 1020, 1, 1020, 1, 1020, 1, 1020, 1, 1021, + 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1022, 1, 1022, 1, 1022, 1, 1022, + 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, + 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, + 1, 1022, 1, 1022, 1, 1023, 1, 1023, 1, 1023, 1, 1023, 1, 1023, 1, 1024, + 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1024, + 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1025, 1, 1025, 1, 1025, 1, 1025, + 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1026, 1, 1026, 1, 1026, 1, 1026, + 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1027, 1, 1027, + 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, + 1, 1027, 1, 1027, 1, 1027, 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, + 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1029, 1, 1029, 1, 1029, + 1, 1029, 1, 1029, 1, 1029, 1, 1029, 1, 1029, 1, 1029, 1, 1029, 1, 1030, + 1, 1030, 1, 1030, 1, 1030, 1, 1030, 1, 1030, 1, 1030, 1, 1030, 1, 1030, + 1, 1030, 1, 1030, 1, 1030, 1, 1031, 1, 1031, 1, 1031, 1, 1031, 1, 1031, + 1, 1031, 1, 1031, 1, 1031, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, + 1, 1032, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, + 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, + 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, + 1, 1035, 1, 1035, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, + 1, 1036, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, + 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, + 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1040, + 1, 1040, 1, 1040, 1, 1040, 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1041, + 1, 1041, 1, 1041, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, + 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1043, 1, 1043, 1, 1043, + 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1044, 1, 1044, 1, 1044, + 1, 1044, 1, 1044, 1, 1044, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1046, + 1, 1046, 1, 1046, 1, 1046, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, + 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1049, 1, 1049, 1, 1049, + 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1050, 1, 1050, 1, 1050, + 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1051, + 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1052, 1, 1052, 1, 1052, + 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, + 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, + 1, 1053, 1, 1053, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, + 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1056, + 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1057, + 1, 1057, 1, 1057, 1, 1057, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, + 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1059, 1, 1059, 1, 1059, + 1, 1059, 1, 1059, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, + 1, 1060, 1, 1060, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, + 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, + 1, 1061, 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, + 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, + 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, + 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1065, 1, 1065, 1, 1065, + 1, 1065, 1, 1065, 1, 1065, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, + 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, + 1, 1066, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, + 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1068, 1, 1068, 1, 1068, 1, 1068, + 1, 1068, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, + 1, 1069, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, + 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, + 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1071, 1, 1071, + 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, + 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1072, 1, 1072, + 1, 1072, 1, 1072, 1, 1072, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, + 1, 1073, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1075, + 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1076, + 1, 1076, 1, 1076, 1, 1076, 1, 1076, 1, 1077, 1, 1077, 1, 1077, 1, 1077, + 1, 1077, 1, 1077, 1, 1077, 1, 1078, 1, 1078, 1, 1078, 1, 1078, 1, 1078, + 1, 1078, 1, 1078, 1, 1078, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, + 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, + 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, + 1, 1079, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, + 1, 1080, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1082, 1, 1082, + 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1083, + 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, + 1, 1083, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, + 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1085, 1, 1085, 1, 1085, 1, 1085, + 1, 1085, 1, 1085, 1, 1085, 1, 1085, 1, 1085, 1, 1085, 1, 1085, 1, 1086, + 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1087, 1, 1087, 1, 1087, + 1, 1087, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1088, + 1, 1088, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, + 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1090, + 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1090, + 1, 1090, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, + 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, + 1, 1091, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, + 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1094, 1, 1094, 1, 1094, + 1, 1094, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1096, 1, 1096, + 1, 1096, 1, 1096, 1, 1096, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, + 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1099, 1, 1099, 1, 1099, + 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1100, 1, 1100, 1, 1100, + 1, 1100, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1102, 1, 1102, 1, 1102, + 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1103, 1, 1103, 1, 1103, + 1, 1103, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1105, + 1, 1105, 1, 1105, 1, 1105, 1, 1105, 1, 1105, 1, 1106, 1, 1106, 1, 1106, + 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1108, 1, 1108, + 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1109, 1, 1109, + 1, 1109, 1, 1109, 1, 1109, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, + 1, 1110, 1, 1111, 1, 1111, 1, 1111, 1, 1111, 1, 1111, 1, 1112, 1, 1112, + 1, 1112, 1, 1112, 1, 1113, 1, 1113, 1, 1113, 1, 1113, 1, 1113, 1, 1114, + 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1115, 1, 1115, + 1, 1115, 1, 1115, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, + 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, + 1, 1116, 1, 1116, 1, 1116, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, + 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, + 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1118, + 1, 1118, 1, 1118, 1, 1118, 1, 1118, 1, 1118, 1, 1118, 1, 1118, 1, 1118, + 1, 1118, 1, 1118, 1, 1118, 1, 1119, 1, 1119, 1, 1119, 1, 1119, 1, 1119, + 1, 1119, 1, 1119, 1, 1119, 1, 1119, 1, 1119, 1, 1119, 1, 1119, 1, 1119, + 1, 1120, 1, 1120, 1, 1120, 1, 1120, 1, 1120, 1, 1120, 1, 1120, 1, 1120, + 1, 1120, 1, 1120, 1, 1120, 1, 1120, 1, 1120, 1, 1120, 1, 1121, 1, 1121, + 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, + 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, + 1, 1121, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, + 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, + 1, 1122, 1, 1122, 1, 1122, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, + 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, + 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, + 1, 1123, 1, 1123, 1, 1123, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, + 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1125, 1, 1125, 1, 1125, + 1, 1125, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, + 1, 1126, 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1127, + 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1129, 1, 1129, + 1, 1129, 1, 1129, 1, 1129, 1, 1129, 1, 1129, 1, 1129, 1, 1129, 1, 1129, + 1, 1129, 1, 1129, 1, 1129, 1, 1129, 1, 1129, 1, 1129, 1, 1129, 1, 1129, + 1, 1129, 1, 1129, 1, 1129, 1, 1129, 1, 1129, 1, 1130, 1, 1130, 1, 1130, + 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, + 1, 1130, 1, 1130, 1, 1131, 1, 1131, 1, 1131, 1, 1131, 1, 1131, 1, 1131, + 1, 1131, 1, 1131, 1, 1131, 1, 1131, 1, 1131, 1, 1131, 1, 1132, 1, 1132, + 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, + 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, + 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, + 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1134, + 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, + 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1135, 1, 1135, 1, 1135, + 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, + 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1136, 1, 1136, + 1, 1136, 1, 1136, 1, 1136, 1, 1137, 1, 1137, 1, 1137, 1, 1137, 1, 1137, + 1, 1137, 1, 1137, 1, 1137, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, + 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1139, 1, 1139, 1, 1139, + 1, 1139, 1, 1139, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1141, + 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1142, 1, 1142, + 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 1143, 1, 1143, 1, 1143, + 1, 1143, 1, 1143, 1, 1143, 1, 1143, 1, 1143, 1, 1143, 1, 1143, 1, 1143, + 1, 1143, 1, 1144, 1, 1144, 1, 1144, 1, 1144, 1, 1144, 1, 1144, 1, 1144, + 1, 1144, 1, 1144, 1, 1144, 1, 1144, 1, 1144, 1, 1145, 1, 1145, 1, 1145, + 1, 1145, 1, 1145, 1, 1145, 1, 1145, 1, 1145, 1, 1145, 1, 1145, 1, 1145, + 1, 1146, 1, 1146, 1, 1146, 1, 1146, 1, 1146, 1, 1146, 1, 1146, 1, 1146, + 1, 1146, 1, 1147, 1, 1147, 1, 1147, 1, 1147, 1, 1147, 1, 1147, 1, 1147, + 1, 1147, 1, 1147, 1, 1148, 1, 1148, 1, 1148, 1, 1148, 1, 1148, 1, 1148, + 1, 1148, 1, 1148, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, + 3, 1149, 14647, 8, 1149, 1, 1150, 1, 1150, 1, 1150, 3, 1150, 14652, 8, + 1150, 1, 1151, 1, 1151, 1, 1151, 3, 1151, 14657, 8, 1151, 1, 1152, 1, 1152, + 1, 1152, 3, 1152, 14662, 8, 1152, 1, 1153, 1, 1153, 1, 1153, 3, 1153, 14667, + 8, 1153, 1, 1154, 1, 1154, 1, 1154, 1, 1154, 3, 1154, 14673, 8, 1154, 1, + 1155, 1, 1155, 1, 1155, 1, 1156, 1, 1156, 1, 1156, 3, 1156, 14681, 8, 1156, + 1, 1157, 1, 1157, 1, 1157, 3, 1157, 14686, 8, 1157, 1, 1158, 1, 1158, 1, + 1158, 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 1160, 1, 1160, 1, 1160, 1, + 1161, 1, 1161, 1, 1161, 1, 1162, 1, 1162, 1, 1162, 1, 1162, 1, 1162, 1, + 1162, 1, 1162, 1, 1162, 1, 1162, 1, 1162, 3, 1162, 14711, 8, 1162, 1, 1163, + 1, 1163, 1, 1163, 1, 1164, 1, 1164, 1, 1164, 1, 1164, 1, 1164, 1, 1164, + 1, 1164, 1, 1164, 1, 1164, 1, 1164, 1, 1164, 1, 1164, 1, 1164, 1, 1164, + 1, 1165, 1, 1165, 1, 1165, 1, 1165, 1, 1165, 1, 1165, 1, 1165, 1, 1165, + 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1166, + 1, 1166, 1, 1167, 1, 1167, 1, 1167, 1, 1168, 1, 1168, 1, 1168, 1, 1168, + 1, 1168, 1, 1168, 1, 1168, 1, 1168, 1, 1169, 1, 1169, 1, 1169, 1, 1169, + 1, 1169, 1, 1169, 1, 1169, 1, 1169, 1, 1169, 1, 1169, 1, 1169, 1, 1169, + 1, 1169, 1, 1169, 1, 1170, 1, 1170, 1, 1170, 1, 1170, 1, 1170, 1, 1170, + 1, 1170, 1, 1170, 1, 1170, 1, 1170, 1, 1170, 1, 1170, 1, 1170, 1, 1170, + 1, 1170, 1, 1171, 4, 1171, 14788, 8, 1171, 11, 1171, 12, 1171, 14789, 1, + 1171, 1, 1171, 4, 1171, 14794, 8, 1171, 11, 1171, 12, 1171, 14795, 1, 1171, + 1, 1171, 4, 1171, 14800, 8, 1171, 11, 1171, 12, 1171, 14801, 1, 1171, 1, + 1171, 4, 1171, 14806, 8, 1171, 11, 1171, 12, 1171, 14807, 1, 1172, 1, 1172, + 1, 1172, 1, 1172, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 5, 1173, + 14819, 8, 1173, 10, 1173, 12, 1173, 14822, 9, 1173, 1, 1173, 1, 1173, 1, + 1173, 1, 1173, 1, 1173, 1, 1174, 1, 1174, 1, 1174, 1, 1174, 5, 1174, 14833, + 8, 1174, 10, 1174, 12, 1174, 14836, 9, 1174, 1, 1174, 1, 1174, 1, 1175, + 1, 1175, 4, 1175, 14842, 8, 1175, 11, 1175, 12, 1175, 14843, 1, 1175, 1, + 1175, 1, 1176, 1, 1176, 1, 1176, 1, 1177, 1, 1177, 1, 1178, 1, 1178, 1, + 1178, 1, 1178, 5, 1178, 14857, 8, 1178, 10, 1178, 12, 1178, 14860, 9, 1178, + 1, 1178, 1, 1178, 1, 1179, 1, 1179, 1, 1179, 5, 1179, 14867, 8, 1179, 10, + 1179, 12, 1179, 14870, 9, 1179, 1, 1180, 1, 1180, 1, 1180, 5, 1180, 14875, + 8, 1180, 10, 1180, 12, 1180, 14878, 9, 1180, 1, 1181, 4, 1181, 14881, 8, + 1181, 11, 1181, 12, 1181, 14882, 1, 1182, 1, 1182, 3, 1182, 14887, 8, 1182, + 1, 1182, 1, 1182, 5, 1182, 14891, 8, 1182, 10, 1182, 12, 1182, 14894, 9, + 1182, 1, 1183, 3, 1183, 14897, 8, 1183, 1, 1183, 1, 1183, 1, 1183, 1, 1183, + 5, 1183, 14903, 8, 1183, 10, 1183, 12, 1183, 14906, 9, 1183, 1, 1183, 1, + 1183, 1, 1184, 1, 1184, 1, 1184, 5, 1184, 14913, 8, 1184, 10, 1184, 12, + 1184, 14916, 9, 1184, 1, 1185, 1, 1185, 1, 1186, 1, 1186, 3, 1186, 14922, + 8, 1186, 1, 1186, 1, 1186, 3, 1186, 14926, 8, 1186, 1, 1186, 4, 1186, 14929, + 8, 1186, 11, 1186, 12, 1186, 14930, 1, 1187, 1, 1187, 1, 1188, 1, 1188, + 1, 1189, 1, 1189, 1, 1190, 1, 1190, 1, 1191, 1, 1191, 1, 1191, 1, 1192, + 1, 1192, 1, 1192, 1, 1193, 1, 1193, 1, 1193, 1, 1194, 1, 1194, 1, 1194, + 1, 1195, 1, 1195, 1, 1195, 1, 1196, 1, 1196, 1, 1196, 1, 1197, 1, 1197, + 1, 1197, 1, 1198, 1, 1198, 1, 1198, 1, 1199, 1, 1199, 1, 1199, 1, 1200, + 1, 1200, 1, 1201, 1, 1201, 1, 1202, 1, 1202, 1, 1203, 1, 1203, 1, 1204, + 1, 1204, 1, 1205, 1, 1205, 1, 1206, 1, 1206, 1, 1207, 1, 1207, 1, 1208, + 1, 1208, 1, 1209, 1, 1209, 1, 1210, 1, 1210, 1, 1210, 1, 1211, 1, 1211, + 1, 1212, 1, 1212, 1, 1213, 1, 1213, 1, 1214, 1, 1214, 1, 1215, 1, 1215, + 1, 1216, 1, 1216, 1, 1217, 1, 1217, 1, 1218, 1, 1218, 1, 1219, 1, 1219, + 1, 1220, 1, 1220, 1, 1221, 1, 1221, 1, 1222, 4, 1222, 15014, 8, 1222, 11, + 1222, 12, 1222, 15015, 1, 1222, 1, 1222, 4, 1222, 15020, 8, 1222, 11, 1222, + 12, 1222, 15021, 1, 1222, 4, 1222, 15025, 8, 1222, 11, 1222, 12, 1222, + 15026, 1, 1222, 1, 1222, 1, 1222, 1, 1222, 4, 1222, 15033, 8, 1222, 11, + 1222, 12, 1222, 15034, 3, 1222, 15037, 8, 1222, 1, 1223, 1, 1223, 1, 1224, + 1, 1224, 1, 1225, 1, 1225, 1, 14820, 0, 1226, 1, 1, 3, 2, 5, 3, 7, 4, 9, + 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, + 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, + 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, + 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, + 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, + 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, + 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, 131, 66, + 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, 73, 147, 74, + 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80, 161, 81, 163, 82, + 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88, 177, 89, 179, 90, + 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96, 193, 97, 195, 98, + 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207, 104, 209, 105, 211, + 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111, 223, 112, 225, 113, + 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, 237, 119, 239, 120, 241, + 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, 126, 253, 127, 255, 128, + 257, 129, 259, 130, 261, 131, 263, 132, 265, 133, 267, 134, 269, 135, 271, + 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, 141, 283, 142, 285, 143, + 287, 144, 289, 145, 291, 146, 293, 147, 295, 148, 297, 149, 299, 150, 301, + 151, 303, 152, 305, 153, 307, 154, 309, 155, 311, 156, 313, 157, 315, 158, + 317, 159, 319, 160, 321, 161, 323, 162, 325, 163, 327, 164, 329, 165, 331, + 166, 333, 167, 335, 168, 337, 169, 339, 170, 341, 171, 343, 172, 345, 173, + 347, 174, 349, 175, 351, 176, 353, 177, 355, 178, 357, 179, 359, 180, 361, + 181, 363, 182, 365, 183, 367, 184, 369, 185, 371, 186, 373, 187, 375, 188, + 377, 189, 379, 190, 381, 191, 383, 192, 385, 193, 387, 194, 389, 195, 391, + 196, 393, 197, 395, 198, 397, 199, 399, 200, 401, 201, 403, 202, 405, 203, + 407, 204, 409, 205, 411, 206, 413, 207, 415, 208, 417, 209, 419, 210, 421, + 211, 423, 212, 425, 213, 427, 214, 429, 215, 431, 216, 433, 217, 435, 218, + 437, 219, 439, 220, 441, 221, 443, 222, 445, 223, 447, 224, 449, 225, 451, + 226, 453, 227, 455, 228, 457, 229, 459, 230, 461, 231, 463, 232, 465, 233, + 467, 234, 469, 235, 471, 236, 473, 237, 475, 238, 477, 239, 479, 240, 481, + 241, 483, 242, 485, 243, 487, 244, 489, 245, 491, 246, 493, 247, 495, 248, + 497, 249, 499, 250, 501, 251, 503, 252, 505, 253, 507, 254, 509, 255, 511, + 256, 513, 257, 515, 258, 517, 259, 519, 260, 521, 261, 523, 262, 525, 263, + 527, 264, 529, 265, 531, 266, 533, 267, 535, 268, 537, 269, 539, 270, 541, + 271, 543, 272, 545, 273, 547, 274, 549, 275, 551, 276, 553, 277, 555, 278, + 557, 279, 559, 280, 561, 281, 563, 282, 565, 283, 567, 284, 569, 285, 571, + 286, 573, 287, 575, 288, 577, 289, 579, 290, 581, 291, 583, 292, 585, 293, + 587, 294, 589, 295, 591, 296, 593, 297, 595, 298, 597, 299, 599, 300, 601, + 301, 603, 302, 605, 303, 607, 304, 609, 305, 611, 306, 613, 307, 615, 308, + 617, 309, 619, 310, 621, 311, 623, 312, 625, 313, 627, 314, 629, 315, 631, + 316, 633, 317, 635, 318, 637, 319, 639, 320, 641, 321, 643, 322, 645, 323, + 647, 324, 649, 325, 651, 326, 653, 327, 655, 328, 657, 329, 659, 330, 661, + 331, 663, 332, 665, 333, 667, 334, 669, 335, 671, 336, 673, 337, 675, 338, + 677, 339, 679, 340, 681, 341, 683, 342, 685, 343, 687, 344, 689, 345, 691, + 346, 693, 347, 695, 348, 697, 349, 699, 350, 701, 351, 703, 352, 705, 353, + 707, 354, 709, 355, 711, 356, 713, 357, 715, 358, 717, 359, 719, 360, 721, + 361, 723, 362, 725, 363, 727, 364, 729, 365, 731, 366, 733, 367, 735, 368, + 737, 369, 739, 370, 741, 371, 743, 372, 745, 373, 747, 374, 749, 375, 751, + 376, 753, 377, 755, 378, 757, 379, 759, 380, 761, 381, 763, 382, 765, 383, + 767, 384, 769, 385, 771, 386, 773, 387, 775, 388, 777, 389, 779, 390, 781, + 391, 783, 392, 785, 393, 787, 394, 789, 395, 791, 396, 793, 397, 795, 398, + 797, 399, 799, 400, 801, 401, 803, 402, 805, 403, 807, 404, 809, 405, 811, + 406, 813, 407, 815, 408, 817, 409, 819, 410, 821, 411, 823, 412, 825, 413, + 827, 414, 829, 415, 831, 416, 833, 417, 835, 418, 837, 419, 839, 420, 841, + 421, 843, 422, 845, 423, 847, 424, 849, 425, 851, 426, 853, 427, 855, 428, + 857, 429, 859, 430, 861, 431, 863, 432, 865, 433, 867, 434, 869, 435, 871, + 436, 873, 437, 875, 438, 877, 439, 879, 440, 881, 441, 883, 442, 885, 443, + 887, 444, 889, 445, 891, 446, 893, 447, 895, 448, 897, 449, 899, 450, 901, + 451, 903, 452, 905, 453, 907, 454, 909, 455, 911, 456, 913, 457, 915, 458, + 917, 459, 919, 460, 921, 461, 923, 462, 925, 463, 927, 464, 929, 465, 931, + 466, 933, 467, 935, 468, 937, 469, 939, 470, 941, 471, 943, 472, 945, 473, + 947, 474, 949, 475, 951, 476, 953, 477, 955, 478, 957, 479, 959, 480, 961, + 481, 963, 482, 965, 483, 967, 484, 969, 485, 971, 486, 973, 487, 975, 488, + 977, 489, 979, 490, 981, 491, 983, 492, 985, 493, 987, 494, 989, 495, 991, + 496, 993, 497, 995, 498, 997, 499, 999, 500, 1001, 501, 1003, 502, 1005, + 503, 1007, 504, 1009, 505, 1011, 506, 1013, 507, 1015, 508, 1017, 509, + 1019, 510, 1021, 511, 1023, 512, 1025, 513, 1027, 514, 1029, 515, 1031, + 516, 1033, 517, 1035, 518, 1037, 519, 1039, 520, 1041, 521, 1043, 522, + 1045, 523, 1047, 524, 1049, 525, 1051, 526, 1053, 527, 1055, 528, 1057, + 529, 1059, 530, 1061, 531, 1063, 532, 1065, 533, 1067, 534, 1069, 535, + 1071, 536, 1073, 537, 1075, 538, 1077, 539, 1079, 540, 1081, 541, 1083, + 542, 1085, 543, 1087, 544, 1089, 545, 1091, 546, 1093, 547, 1095, 548, + 1097, 549, 1099, 550, 1101, 551, 1103, 552, 1105, 553, 1107, 554, 1109, + 555, 1111, 556, 1113, 557, 1115, 558, 1117, 559, 1119, 560, 1121, 561, + 1123, 562, 1125, 563, 1127, 564, 1129, 565, 1131, 566, 1133, 567, 1135, + 568, 1137, 569, 1139, 570, 1141, 571, 1143, 572, 1145, 573, 1147, 574, + 1149, 575, 1151, 576, 1153, 577, 1155, 578, 1157, 579, 1159, 580, 1161, + 581, 1163, 582, 1165, 583, 1167, 584, 1169, 585, 1171, 586, 1173, 587, + 1175, 588, 1177, 589, 1179, 590, 1181, 591, 1183, 592, 1185, 593, 1187, + 594, 1189, 595, 1191, 596, 1193, 597, 1195, 598, 1197, 599, 1199, 600, + 1201, 601, 1203, 602, 1205, 603, 1207, 604, 1209, 605, 1211, 606, 1213, + 607, 1215, 608, 1217, 609, 1219, 610, 1221, 611, 1223, 612, 1225, 613, + 1227, 614, 1229, 615, 1231, 616, 1233, 617, 1235, 618, 1237, 619, 1239, + 620, 1241, 621, 1243, 622, 1245, 623, 1247, 624, 1249, 625, 1251, 626, + 1253, 627, 1255, 628, 1257, 629, 1259, 630, 1261, 631, 1263, 632, 1265, + 633, 1267, 634, 1269, 635, 1271, 636, 1273, 637, 1275, 638, 1277, 639, + 1279, 640, 1281, 641, 1283, 642, 1285, 643, 1287, 644, 1289, 645, 1291, + 646, 1293, 647, 1295, 648, 1297, 649, 1299, 650, 1301, 651, 1303, 652, + 1305, 653, 1307, 654, 1309, 655, 1311, 656, 1313, 657, 1315, 658, 1317, + 659, 1319, 660, 1321, 661, 1323, 662, 1325, 663, 1327, 664, 1329, 665, + 1331, 666, 1333, 667, 1335, 668, 1337, 669, 1339, 670, 1341, 671, 1343, + 672, 1345, 673, 1347, 674, 1349, 675, 1351, 676, 1353, 677, 1355, 678, + 1357, 679, 1359, 680, 1361, 681, 1363, 682, 1365, 683, 1367, 684, 1369, + 685, 1371, 686, 1373, 687, 1375, 688, 1377, 689, 1379, 690, 1381, 691, + 1383, 692, 1385, 693, 1387, 694, 1389, 695, 1391, 696, 1393, 697, 1395, + 698, 1397, 699, 1399, 700, 1401, 701, 1403, 702, 1405, 703, 1407, 704, + 1409, 705, 1411, 706, 1413, 707, 1415, 708, 1417, 709, 1419, 710, 1421, + 711, 1423, 712, 1425, 713, 1427, 714, 1429, 715, 1431, 716, 1433, 717, + 1435, 718, 1437, 719, 1439, 720, 1441, 721, 1443, 722, 1445, 723, 1447, + 724, 1449, 725, 1451, 726, 1453, 727, 1455, 728, 1457, 729, 1459, 730, + 1461, 731, 1463, 732, 1465, 733, 1467, 734, 1469, 735, 1471, 736, 1473, + 737, 1475, 738, 1477, 739, 1479, 740, 1481, 741, 1483, 742, 1485, 743, + 1487, 744, 1489, 745, 1491, 746, 1493, 747, 1495, 748, 1497, 749, 1499, + 750, 1501, 751, 1503, 752, 1505, 753, 1507, 754, 1509, 755, 1511, 756, + 1513, 757, 1515, 758, 1517, 759, 1519, 760, 1521, 761, 1523, 762, 1525, + 763, 1527, 764, 1529, 765, 1531, 766, 1533, 767, 1535, 768, 1537, 769, + 1539, 770, 1541, 771, 1543, 772, 1545, 773, 1547, 774, 1549, 775, 1551, + 776, 1553, 777, 1555, 778, 1557, 779, 1559, 780, 1561, 781, 1563, 782, + 1565, 783, 1567, 784, 1569, 785, 1571, 786, 1573, 787, 1575, 788, 1577, + 789, 1579, 790, 1581, 791, 1583, 792, 1585, 793, 1587, 794, 1589, 795, + 1591, 796, 1593, 797, 1595, 798, 1597, 799, 1599, 800, 1601, 801, 1603, + 802, 1605, 803, 1607, 804, 1609, 805, 1611, 806, 1613, 807, 1615, 808, + 1617, 809, 1619, 810, 1621, 811, 1623, 812, 1625, 813, 1627, 814, 1629, + 815, 1631, 816, 1633, 817, 1635, 818, 1637, 819, 1639, 820, 1641, 821, + 1643, 822, 1645, 823, 1647, 824, 1649, 825, 1651, 826, 1653, 827, 1655, + 828, 1657, 829, 1659, 830, 1661, 831, 1663, 832, 1665, 833, 1667, 834, + 1669, 835, 1671, 836, 1673, 837, 1675, 838, 1677, 839, 1679, 840, 1681, + 841, 1683, 842, 1685, 843, 1687, 844, 1689, 845, 1691, 846, 1693, 847, + 1695, 848, 1697, 849, 1699, 850, 1701, 851, 1703, 852, 1705, 853, 1707, + 854, 1709, 855, 1711, 856, 1713, 857, 1715, 858, 1717, 859, 1719, 860, + 1721, 861, 1723, 862, 1725, 863, 1727, 864, 1729, 865, 1731, 866, 1733, + 867, 1735, 868, 1737, 869, 1739, 870, 1741, 871, 1743, 872, 1745, 873, + 1747, 874, 1749, 875, 1751, 876, 1753, 877, 1755, 878, 1757, 879, 1759, + 880, 1761, 881, 1763, 882, 1765, 883, 1767, 884, 1769, 885, 1771, 886, + 1773, 887, 1775, 888, 1777, 889, 1779, 890, 1781, 891, 1783, 892, 1785, + 893, 1787, 894, 1789, 895, 1791, 896, 1793, 897, 1795, 898, 1797, 899, + 1799, 900, 1801, 901, 1803, 902, 1805, 903, 1807, 904, 1809, 905, 1811, + 906, 1813, 907, 1815, 908, 1817, 909, 1819, 910, 1821, 911, 1823, 912, + 1825, 913, 1827, 914, 1829, 915, 1831, 916, 1833, 917, 1835, 918, 1837, + 919, 1839, 920, 1841, 921, 1843, 922, 1845, 923, 1847, 924, 1849, 925, + 1851, 926, 1853, 927, 1855, 928, 1857, 929, 1859, 930, 1861, 931, 1863, + 932, 1865, 933, 1867, 934, 1869, 935, 1871, 936, 1873, 937, 1875, 938, + 1877, 939, 1879, 940, 1881, 941, 1883, 942, 1885, 943, 1887, 944, 1889, + 945, 1891, 946, 1893, 947, 1895, 948, 1897, 949, 1899, 950, 1901, 951, + 1903, 952, 1905, 953, 1907, 954, 1909, 955, 1911, 956, 1913, 957, 1915, + 958, 1917, 959, 1919, 960, 1921, 961, 1923, 962, 1925, 963, 1927, 964, + 1929, 965, 1931, 966, 1933, 967, 1935, 968, 1937, 969, 1939, 970, 1941, + 971, 1943, 972, 1945, 973, 1947, 974, 1949, 975, 1951, 976, 1953, 977, + 1955, 978, 1957, 979, 1959, 980, 1961, 981, 1963, 982, 1965, 983, 1967, + 984, 1969, 985, 1971, 986, 1973, 987, 1975, 988, 1977, 989, 1979, 990, + 1981, 991, 1983, 992, 1985, 993, 1987, 994, 1989, 995, 1991, 996, 1993, + 997, 1995, 998, 1997, 999, 1999, 1000, 2001, 1001, 2003, 1002, 2005, 1003, + 2007, 1004, 2009, 1005, 2011, 1006, 2013, 1007, 2015, 1008, 2017, 1009, + 2019, 1010, 2021, 1011, 2023, 1012, 2025, 1013, 2027, 1014, 2029, 1015, + 2031, 1016, 2033, 1017, 2035, 1018, 2037, 1019, 2039, 1020, 2041, 1021, + 2043, 1022, 2045, 1023, 2047, 1024, 2049, 1025, 2051, 1026, 2053, 1027, + 2055, 1028, 2057, 1029, 2059, 1030, 2061, 1031, 2063, 1032, 2065, 1033, + 2067, 1034, 2069, 1035, 2071, 1036, 2073, 1037, 2075, 1038, 2077, 1039, + 2079, 1040, 2081, 1041, 2083, 1042, 2085, 1043, 2087, 1044, 2089, 1045, + 2091, 1046, 2093, 1047, 2095, 1048, 2097, 1049, 2099, 1050, 2101, 1051, + 2103, 1052, 2105, 1053, 2107, 1054, 2109, 1055, 2111, 1056, 2113, 1057, + 2115, 1058, 2117, 1059, 2119, 1060, 2121, 1061, 2123, 1062, 2125, 1063, + 2127, 1064, 2129, 1065, 2131, 1066, 2133, 1067, 2135, 1068, 2137, 1069, + 2139, 1070, 2141, 1071, 2143, 1072, 2145, 1073, 2147, 1074, 2149, 1075, + 2151, 1076, 2153, 1077, 2155, 1078, 2157, 1079, 2159, 1080, 2161, 1081, + 2163, 1082, 2165, 1083, 2167, 1084, 2169, 1085, 2171, 1086, 2173, 1087, + 2175, 1088, 2177, 1089, 2179, 1090, 2181, 1091, 2183, 1092, 2185, 1093, + 2187, 1094, 2189, 1095, 2191, 1096, 2193, 1097, 2195, 1098, 2197, 1099, + 2199, 1100, 2201, 1101, 2203, 1102, 2205, 1103, 2207, 1104, 2209, 1105, + 2211, 1106, 2213, 1107, 2215, 1108, 2217, 1109, 2219, 1110, 2221, 1111, + 2223, 1112, 2225, 1113, 2227, 1114, 2229, 1115, 2231, 1116, 2233, 1117, + 2235, 1118, 2237, 1119, 2239, 1120, 2241, 1121, 2243, 1122, 2245, 1123, + 2247, 1124, 2249, 1125, 2251, 1126, 2253, 1127, 2255, 1128, 2257, 1129, + 2259, 1130, 2261, 1131, 2263, 1132, 2265, 1133, 2267, 1134, 2269, 1135, + 2271, 1136, 2273, 1137, 2275, 1138, 2277, 1139, 2279, 1140, 2281, 1141, + 2283, 1142, 2285, 1143, 2287, 1144, 2289, 1145, 2291, 1146, 2293, 1147, + 2295, 1148, 2297, 1149, 2299, 1150, 2301, 1151, 2303, 1152, 2305, 1153, + 2307, 1154, 2309, 1155, 2311, 1156, 2313, 1157, 2315, 1158, 2317, 1159, + 2319, 1160, 2321, 1161, 2323, 1162, 2325, 1163, 2327, 1164, 2329, 1165, + 2331, 1166, 2333, 1167, 2335, 1168, 2337, 1169, 2339, 1170, 2341, 1171, + 2343, 1172, 2345, 1173, 2347, 1174, 2349, 1175, 2351, 1176, 2353, 1177, + 2355, 1178, 2357, 1179, 2359, 1180, 2361, 1181, 2363, 1182, 2365, 1183, + 2367, 1184, 2369, 1185, 2371, 1186, 2373, 1187, 2375, 1188, 2377, 1189, + 2379, 1190, 2381, 1191, 2383, 1192, 2385, 1193, 2387, 1194, 2389, 1195, + 2391, 1196, 2393, 1197, 2395, 1198, 2397, 1199, 2399, 1200, 2401, 1201, + 2403, 1202, 2405, 1203, 2407, 1204, 2409, 1205, 2411, 1206, 2413, 1207, + 2415, 1208, 2417, 1209, 2419, 1210, 2421, 1211, 2423, 1212, 2425, 1213, + 2427, 1214, 2429, 1215, 2431, 1216, 2433, 1217, 2435, 1218, 2437, 1219, + 2439, 1220, 2441, 1221, 2443, 0, 2445, 0, 2447, 0, 2449, 0, 2451, 0, 1, + 0, 40, 2, 0, 65, 65, 97, 97, 2, 0, 66, 66, 98, 98, 2, 0, 79, 79, 111, 111, + 2, 0, 82, 82, 114, 114, 2, 0, 84, 84, 116, 116, 2, 0, 70, 70, 102, 102, + 2, 0, 69, 69, 101, 101, 2, 0, 87, 87, 119, 119, 2, 0, 73, 73, 105, 105, + 2, 0, 83, 83, 115, 115, 2, 0, 78, 78, 110, 110, 2, 0, 76, 76, 108, 108, + 2, 0, 85, 85, 117, 117, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, 2, + 0, 86, 86, 118, 118, 2, 0, 89, 89, 121, 121, 2, 0, 77, 77, 109, 109, 2, + 0, 71, 71, 103, 103, 2, 0, 72, 72, 104, 104, 2, 0, 80, 80, 112, 112, 2, + 0, 75, 75, 107, 107, 2, 0, 88, 88, 120, 120, 2, 0, 90, 90, 122, 122, 2, + 0, 74, 74, 106, 106, 2, 0, 81, 81, 113, 113, 1, 0, 34, 34, 2, 0, 65, 90, + 97, 122, 1, 0, 58, 58, 3, 0, 9, 10, 13, 13, 32, 32, 2, 0, 10, 10, 13, 13, + 1, 0, 93, 93, 5, 0, 35, 36, 48, 57, 64, 90, 95, 95, 97, 122, 4, 0, 35, + 35, 65, 90, 95, 95, 97, 122, 1, 0, 39, 39, 2, 0, 43, 43, 45, 45, 3, 0, + 65, 90, 95, 95, 97, 122, 3, 0, 48, 57, 65, 70, 97, 102, 1, 0, 48, 57, 10, + 0, 192, 214, 216, 246, 248, 8191, 11264, 12287, 12352, 12687, 13056, 13183, + 13312, 16383, 19968, 55295, 63744, 64255, 65280, 65520, 15081, 0, 1, 1, + 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, + 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, + 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, + 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, + 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, + 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, + 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, + 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, + 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, + 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, + 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, + 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, + 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, + 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, + 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, + 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, + 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, + 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, + 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, + 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, + 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, + 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, + 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, + 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, + 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, + 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, + 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, + 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, + 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, + 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, + 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, + 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, + 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, + 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, + 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, + 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, 0, + 267, 1, 0, 0, 0, 0, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, 1, 0, + 0, 0, 0, 275, 1, 0, 0, 0, 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, 281, + 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, 285, 1, 0, 0, 0, 0, 287, 1, 0, 0, 0, + 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, 1, + 0, 0, 0, 0, 297, 1, 0, 0, 0, 0, 299, 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, 0, + 303, 1, 0, 0, 0, 0, 305, 1, 0, 0, 0, 0, 307, 1, 0, 0, 0, 0, 309, 1, 0, + 0, 0, 0, 311, 1, 0, 0, 0, 0, 313, 1, 0, 0, 0, 0, 315, 1, 0, 0, 0, 0, 317, + 1, 0, 0, 0, 0, 319, 1, 0, 0, 0, 0, 321, 1, 0, 0, 0, 0, 323, 1, 0, 0, 0, + 0, 325, 1, 0, 0, 0, 0, 327, 1, 0, 0, 0, 0, 329, 1, 0, 0, 0, 0, 331, 1, + 0, 0, 0, 0, 333, 1, 0, 0, 0, 0, 335, 1, 0, 0, 0, 0, 337, 1, 0, 0, 0, 0, + 339, 1, 0, 0, 0, 0, 341, 1, 0, 0, 0, 0, 343, 1, 0, 0, 0, 0, 345, 1, 0, + 0, 0, 0, 347, 1, 0, 0, 0, 0, 349, 1, 0, 0, 0, 0, 351, 1, 0, 0, 0, 0, 353, + 1, 0, 0, 0, 0, 355, 1, 0, 0, 0, 0, 357, 1, 0, 0, 0, 0, 359, 1, 0, 0, 0, + 0, 361, 1, 0, 0, 0, 0, 363, 1, 0, 0, 0, 0, 365, 1, 0, 0, 0, 0, 367, 1, + 0, 0, 0, 0, 369, 1, 0, 0, 0, 0, 371, 1, 0, 0, 0, 0, 373, 1, 0, 0, 0, 0, + 375, 1, 0, 0, 0, 0, 377, 1, 0, 0, 0, 0, 379, 1, 0, 0, 0, 0, 381, 1, 0, + 0, 0, 0, 383, 1, 0, 0, 0, 0, 385, 1, 0, 0, 0, 0, 387, 1, 0, 0, 0, 0, 389, + 1, 0, 0, 0, 0, 391, 1, 0, 0, 0, 0, 393, 1, 0, 0, 0, 0, 395, 1, 0, 0, 0, + 0, 397, 1, 0, 0, 0, 0, 399, 1, 0, 0, 0, 0, 401, 1, 0, 0, 0, 0, 403, 1, + 0, 0, 0, 0, 405, 1, 0, 0, 0, 0, 407, 1, 0, 0, 0, 0, 409, 1, 0, 0, 0, 0, + 411, 1, 0, 0, 0, 0, 413, 1, 0, 0, 0, 0, 415, 1, 0, 0, 0, 0, 417, 1, 0, + 0, 0, 0, 419, 1, 0, 0, 0, 0, 421, 1, 0, 0, 0, 0, 423, 1, 0, 0, 0, 0, 425, + 1, 0, 0, 0, 0, 427, 1, 0, 0, 0, 0, 429, 1, 0, 0, 0, 0, 431, 1, 0, 0, 0, + 0, 433, 1, 0, 0, 0, 0, 435, 1, 0, 0, 0, 0, 437, 1, 0, 0, 0, 0, 439, 1, + 0, 0, 0, 0, 441, 1, 0, 0, 0, 0, 443, 1, 0, 0, 0, 0, 445, 1, 0, 0, 0, 0, + 447, 1, 0, 0, 0, 0, 449, 1, 0, 0, 0, 0, 451, 1, 0, 0, 0, 0, 453, 1, 0, + 0, 0, 0, 455, 1, 0, 0, 0, 0, 457, 1, 0, 0, 0, 0, 459, 1, 0, 0, 0, 0, 461, + 1, 0, 0, 0, 0, 463, 1, 0, 0, 0, 0, 465, 1, 0, 0, 0, 0, 467, 1, 0, 0, 0, + 0, 469, 1, 0, 0, 0, 0, 471, 1, 0, 0, 0, 0, 473, 1, 0, 0, 0, 0, 475, 1, + 0, 0, 0, 0, 477, 1, 0, 0, 0, 0, 479, 1, 0, 0, 0, 0, 481, 1, 0, 0, 0, 0, + 483, 1, 0, 0, 0, 0, 485, 1, 0, 0, 0, 0, 487, 1, 0, 0, 0, 0, 489, 1, 0, + 0, 0, 0, 491, 1, 0, 0, 0, 0, 493, 1, 0, 0, 0, 0, 495, 1, 0, 0, 0, 0, 497, + 1, 0, 0, 0, 0, 499, 1, 0, 0, 0, 0, 501, 1, 0, 0, 0, 0, 503, 1, 0, 0, 0, + 0, 505, 1, 0, 0, 0, 0, 507, 1, 0, 0, 0, 0, 509, 1, 0, 0, 0, 0, 511, 1, + 0, 0, 0, 0, 513, 1, 0, 0, 0, 0, 515, 1, 0, 0, 0, 0, 517, 1, 0, 0, 0, 0, + 519, 1, 0, 0, 0, 0, 521, 1, 0, 0, 0, 0, 523, 1, 0, 0, 0, 0, 525, 1, 0, + 0, 0, 0, 527, 1, 0, 0, 0, 0, 529, 1, 0, 0, 0, 0, 531, 1, 0, 0, 0, 0, 533, + 1, 0, 0, 0, 0, 535, 1, 0, 0, 0, 0, 537, 1, 0, 0, 0, 0, 539, 1, 0, 0, 0, + 0, 541, 1, 0, 0, 0, 0, 543, 1, 0, 0, 0, 0, 545, 1, 0, 0, 0, 0, 547, 1, + 0, 0, 0, 0, 549, 1, 0, 0, 0, 0, 551, 1, 0, 0, 0, 0, 553, 1, 0, 0, 0, 0, + 555, 1, 0, 0, 0, 0, 557, 1, 0, 0, 0, 0, 559, 1, 0, 0, 0, 0, 561, 1, 0, + 0, 0, 0, 563, 1, 0, 0, 0, 0, 565, 1, 0, 0, 0, 0, 567, 1, 0, 0, 0, 0, 569, + 1, 0, 0, 0, 0, 571, 1, 0, 0, 0, 0, 573, 1, 0, 0, 0, 0, 575, 1, 0, 0, 0, + 0, 577, 1, 0, 0, 0, 0, 579, 1, 0, 0, 0, 0, 581, 1, 0, 0, 0, 0, 583, 1, + 0, 0, 0, 0, 585, 1, 0, 0, 0, 0, 587, 1, 0, 0, 0, 0, 589, 1, 0, 0, 0, 0, + 591, 1, 0, 0, 0, 0, 593, 1, 0, 0, 0, 0, 595, 1, 0, 0, 0, 0, 597, 1, 0, + 0, 0, 0, 599, 1, 0, 0, 0, 0, 601, 1, 0, 0, 0, 0, 603, 1, 0, 0, 0, 0, 605, + 1, 0, 0, 0, 0, 607, 1, 0, 0, 0, 0, 609, 1, 0, 0, 0, 0, 611, 1, 0, 0, 0, + 0, 613, 1, 0, 0, 0, 0, 615, 1, 0, 0, 0, 0, 617, 1, 0, 0, 0, 0, 619, 1, + 0, 0, 0, 0, 621, 1, 0, 0, 0, 0, 623, 1, 0, 0, 0, 0, 625, 1, 0, 0, 0, 0, + 627, 1, 0, 0, 0, 0, 629, 1, 0, 0, 0, 0, 631, 1, 0, 0, 0, 0, 633, 1, 0, + 0, 0, 0, 635, 1, 0, 0, 0, 0, 637, 1, 0, 0, 0, 0, 639, 1, 0, 0, 0, 0, 641, + 1, 0, 0, 0, 0, 643, 1, 0, 0, 0, 0, 645, 1, 0, 0, 0, 0, 647, 1, 0, 0, 0, + 0, 649, 1, 0, 0, 0, 0, 651, 1, 0, 0, 0, 0, 653, 1, 0, 0, 0, 0, 655, 1, + 0, 0, 0, 0, 657, 1, 0, 0, 0, 0, 659, 1, 0, 0, 0, 0, 661, 1, 0, 0, 0, 0, + 663, 1, 0, 0, 0, 0, 665, 1, 0, 0, 0, 0, 667, 1, 0, 0, 0, 0, 669, 1, 0, + 0, 0, 0, 671, 1, 0, 0, 0, 0, 673, 1, 0, 0, 0, 0, 675, 1, 0, 0, 0, 0, 677, + 1, 0, 0, 0, 0, 679, 1, 0, 0, 0, 0, 681, 1, 0, 0, 0, 0, 683, 1, 0, 0, 0, + 0, 685, 1, 0, 0, 0, 0, 687, 1, 0, 0, 0, 0, 689, 1, 0, 0, 0, 0, 691, 1, + 0, 0, 0, 0, 693, 1, 0, 0, 0, 0, 695, 1, 0, 0, 0, 0, 697, 1, 0, 0, 0, 0, + 699, 1, 0, 0, 0, 0, 701, 1, 0, 0, 0, 0, 703, 1, 0, 0, 0, 0, 705, 1, 0, + 0, 0, 0, 707, 1, 0, 0, 0, 0, 709, 1, 0, 0, 0, 0, 711, 1, 0, 0, 0, 0, 713, + 1, 0, 0, 0, 0, 715, 1, 0, 0, 0, 0, 717, 1, 0, 0, 0, 0, 719, 1, 0, 0, 0, + 0, 721, 1, 0, 0, 0, 0, 723, 1, 0, 0, 0, 0, 725, 1, 0, 0, 0, 0, 727, 1, + 0, 0, 0, 0, 729, 1, 0, 0, 0, 0, 731, 1, 0, 0, 0, 0, 733, 1, 0, 0, 0, 0, + 735, 1, 0, 0, 0, 0, 737, 1, 0, 0, 0, 0, 739, 1, 0, 0, 0, 0, 741, 1, 0, + 0, 0, 0, 743, 1, 0, 0, 0, 0, 745, 1, 0, 0, 0, 0, 747, 1, 0, 0, 0, 0, 749, + 1, 0, 0, 0, 0, 751, 1, 0, 0, 0, 0, 753, 1, 0, 0, 0, 0, 755, 1, 0, 0, 0, + 0, 757, 1, 0, 0, 0, 0, 759, 1, 0, 0, 0, 0, 761, 1, 0, 0, 0, 0, 763, 1, + 0, 0, 0, 0, 765, 1, 0, 0, 0, 0, 767, 1, 0, 0, 0, 0, 769, 1, 0, 0, 0, 0, + 771, 1, 0, 0, 0, 0, 773, 1, 0, 0, 0, 0, 775, 1, 0, 0, 0, 0, 777, 1, 0, + 0, 0, 0, 779, 1, 0, 0, 0, 0, 781, 1, 0, 0, 0, 0, 783, 1, 0, 0, 0, 0, 785, + 1, 0, 0, 0, 0, 787, 1, 0, 0, 0, 0, 789, 1, 0, 0, 0, 0, 791, 1, 0, 0, 0, + 0, 793, 1, 0, 0, 0, 0, 795, 1, 0, 0, 0, 0, 797, 1, 0, 0, 0, 0, 799, 1, + 0, 0, 0, 0, 801, 1, 0, 0, 0, 0, 803, 1, 0, 0, 0, 0, 805, 1, 0, 0, 0, 0, + 807, 1, 0, 0, 0, 0, 809, 1, 0, 0, 0, 0, 811, 1, 0, 0, 0, 0, 813, 1, 0, + 0, 0, 0, 815, 1, 0, 0, 0, 0, 817, 1, 0, 0, 0, 0, 819, 1, 0, 0, 0, 0, 821, + 1, 0, 0, 0, 0, 823, 1, 0, 0, 0, 0, 825, 1, 0, 0, 0, 0, 827, 1, 0, 0, 0, + 0, 829, 1, 0, 0, 0, 0, 831, 1, 0, 0, 0, 0, 833, 1, 0, 0, 0, 0, 835, 1, + 0, 0, 0, 0, 837, 1, 0, 0, 0, 0, 839, 1, 0, 0, 0, 0, 841, 1, 0, 0, 0, 0, + 843, 1, 0, 0, 0, 0, 845, 1, 0, 0, 0, 0, 847, 1, 0, 0, 0, 0, 849, 1, 0, + 0, 0, 0, 851, 1, 0, 0, 0, 0, 853, 1, 0, 0, 0, 0, 855, 1, 0, 0, 0, 0, 857, + 1, 0, 0, 0, 0, 859, 1, 0, 0, 0, 0, 861, 1, 0, 0, 0, 0, 863, 1, 0, 0, 0, + 0, 865, 1, 0, 0, 0, 0, 867, 1, 0, 0, 0, 0, 869, 1, 0, 0, 0, 0, 871, 1, + 0, 0, 0, 0, 873, 1, 0, 0, 0, 0, 875, 1, 0, 0, 0, 0, 877, 1, 0, 0, 0, 0, + 879, 1, 0, 0, 0, 0, 881, 1, 0, 0, 0, 0, 883, 1, 0, 0, 0, 0, 885, 1, 0, + 0, 0, 0, 887, 1, 0, 0, 0, 0, 889, 1, 0, 0, 0, 0, 891, 1, 0, 0, 0, 0, 893, + 1, 0, 0, 0, 0, 895, 1, 0, 0, 0, 0, 897, 1, 0, 0, 0, 0, 899, 1, 0, 0, 0, + 0, 901, 1, 0, 0, 0, 0, 903, 1, 0, 0, 0, 0, 905, 1, 0, 0, 0, 0, 907, 1, + 0, 0, 0, 0, 909, 1, 0, 0, 0, 0, 911, 1, 0, 0, 0, 0, 913, 1, 0, 0, 0, 0, + 915, 1, 0, 0, 0, 0, 917, 1, 0, 0, 0, 0, 919, 1, 0, 0, 0, 0, 921, 1, 0, + 0, 0, 0, 923, 1, 0, 0, 0, 0, 925, 1, 0, 0, 0, 0, 927, 1, 0, 0, 0, 0, 929, + 1, 0, 0, 0, 0, 931, 1, 0, 0, 0, 0, 933, 1, 0, 0, 0, 0, 935, 1, 0, 0, 0, + 0, 937, 1, 0, 0, 0, 0, 939, 1, 0, 0, 0, 0, 941, 1, 0, 0, 0, 0, 943, 1, + 0, 0, 0, 0, 945, 1, 0, 0, 0, 0, 947, 1, 0, 0, 0, 0, 949, 1, 0, 0, 0, 0, + 951, 1, 0, 0, 0, 0, 953, 1, 0, 0, 0, 0, 955, 1, 0, 0, 0, 0, 957, 1, 0, + 0, 0, 0, 959, 1, 0, 0, 0, 0, 961, 1, 0, 0, 0, 0, 963, 1, 0, 0, 0, 0, 965, + 1, 0, 0, 0, 0, 967, 1, 0, 0, 0, 0, 969, 1, 0, 0, 0, 0, 971, 1, 0, 0, 0, + 0, 973, 1, 0, 0, 0, 0, 975, 1, 0, 0, 0, 0, 977, 1, 0, 0, 0, 0, 979, 1, + 0, 0, 0, 0, 981, 1, 0, 0, 0, 0, 983, 1, 0, 0, 0, 0, 985, 1, 0, 0, 0, 0, + 987, 1, 0, 0, 0, 0, 989, 1, 0, 0, 0, 0, 991, 1, 0, 0, 0, 0, 993, 1, 0, + 0, 0, 0, 995, 1, 0, 0, 0, 0, 997, 1, 0, 0, 0, 0, 999, 1, 0, 0, 0, 0, 1001, + 1, 0, 0, 0, 0, 1003, 1, 0, 0, 0, 0, 1005, 1, 0, 0, 0, 0, 1007, 1, 0, 0, + 0, 0, 1009, 1, 0, 0, 0, 0, 1011, 1, 0, 0, 0, 0, 1013, 1, 0, 0, 0, 0, 1015, + 1, 0, 0, 0, 0, 1017, 1, 0, 0, 0, 0, 1019, 1, 0, 0, 0, 0, 1021, 1, 0, 0, + 0, 0, 1023, 1, 0, 0, 0, 0, 1025, 1, 0, 0, 0, 0, 1027, 1, 0, 0, 0, 0, 1029, + 1, 0, 0, 0, 0, 1031, 1, 0, 0, 0, 0, 1033, 1, 0, 0, 0, 0, 1035, 1, 0, 0, + 0, 0, 1037, 1, 0, 0, 0, 0, 1039, 1, 0, 0, 0, 0, 1041, 1, 0, 0, 0, 0, 1043, + 1, 0, 0, 0, 0, 1045, 1, 0, 0, 0, 0, 1047, 1, 0, 0, 0, 0, 1049, 1, 0, 0, + 0, 0, 1051, 1, 0, 0, 0, 0, 1053, 1, 0, 0, 0, 0, 1055, 1, 0, 0, 0, 0, 1057, + 1, 0, 0, 0, 0, 1059, 1, 0, 0, 0, 0, 1061, 1, 0, 0, 0, 0, 1063, 1, 0, 0, + 0, 0, 1065, 1, 0, 0, 0, 0, 1067, 1, 0, 0, 0, 0, 1069, 1, 0, 0, 0, 0, 1071, + 1, 0, 0, 0, 0, 1073, 1, 0, 0, 0, 0, 1075, 1, 0, 0, 0, 0, 1077, 1, 0, 0, + 0, 0, 1079, 1, 0, 0, 0, 0, 1081, 1, 0, 0, 0, 0, 1083, 1, 0, 0, 0, 0, 1085, + 1, 0, 0, 0, 0, 1087, 1, 0, 0, 0, 0, 1089, 1, 0, 0, 0, 0, 1091, 1, 0, 0, + 0, 0, 1093, 1, 0, 0, 0, 0, 1095, 1, 0, 0, 0, 0, 1097, 1, 0, 0, 0, 0, 1099, + 1, 0, 0, 0, 0, 1101, 1, 0, 0, 0, 0, 1103, 1, 0, 0, 0, 0, 1105, 1, 0, 0, + 0, 0, 1107, 1, 0, 0, 0, 0, 1109, 1, 0, 0, 0, 0, 1111, 1, 0, 0, 0, 0, 1113, + 1, 0, 0, 0, 0, 1115, 1, 0, 0, 0, 0, 1117, 1, 0, 0, 0, 0, 1119, 1, 0, 0, + 0, 0, 1121, 1, 0, 0, 0, 0, 1123, 1, 0, 0, 0, 0, 1125, 1, 0, 0, 0, 0, 1127, + 1, 0, 0, 0, 0, 1129, 1, 0, 0, 0, 0, 1131, 1, 0, 0, 0, 0, 1133, 1, 0, 0, + 0, 0, 1135, 1, 0, 0, 0, 0, 1137, 1, 0, 0, 0, 0, 1139, 1, 0, 0, 0, 0, 1141, + 1, 0, 0, 0, 0, 1143, 1, 0, 0, 0, 0, 1145, 1, 0, 0, 0, 0, 1147, 1, 0, 0, + 0, 0, 1149, 1, 0, 0, 0, 0, 1151, 1, 0, 0, 0, 0, 1153, 1, 0, 0, 0, 0, 1155, + 1, 0, 0, 0, 0, 1157, 1, 0, 0, 0, 0, 1159, 1, 0, 0, 0, 0, 1161, 1, 0, 0, + 0, 0, 1163, 1, 0, 0, 0, 0, 1165, 1, 0, 0, 0, 0, 1167, 1, 0, 0, 0, 0, 1169, + 1, 0, 0, 0, 0, 1171, 1, 0, 0, 0, 0, 1173, 1, 0, 0, 0, 0, 1175, 1, 0, 0, + 0, 0, 1177, 1, 0, 0, 0, 0, 1179, 1, 0, 0, 0, 0, 1181, 1, 0, 0, 0, 0, 1183, + 1, 0, 0, 0, 0, 1185, 1, 0, 0, 0, 0, 1187, 1, 0, 0, 0, 0, 1189, 1, 0, 0, + 0, 0, 1191, 1, 0, 0, 0, 0, 1193, 1, 0, 0, 0, 0, 1195, 1, 0, 0, 0, 0, 1197, + 1, 0, 0, 0, 0, 1199, 1, 0, 0, 0, 0, 1201, 1, 0, 0, 0, 0, 1203, 1, 0, 0, + 0, 0, 1205, 1, 0, 0, 0, 0, 1207, 1, 0, 0, 0, 0, 1209, 1, 0, 0, 0, 0, 1211, + 1, 0, 0, 0, 0, 1213, 1, 0, 0, 0, 0, 1215, 1, 0, 0, 0, 0, 1217, 1, 0, 0, + 0, 0, 1219, 1, 0, 0, 0, 0, 1221, 1, 0, 0, 0, 0, 1223, 1, 0, 0, 0, 0, 1225, + 1, 0, 0, 0, 0, 1227, 1, 0, 0, 0, 0, 1229, 1, 0, 0, 0, 0, 1231, 1, 0, 0, + 0, 0, 1233, 1, 0, 0, 0, 0, 1235, 1, 0, 0, 0, 0, 1237, 1, 0, 0, 0, 0, 1239, + 1, 0, 0, 0, 0, 1241, 1, 0, 0, 0, 0, 1243, 1, 0, 0, 0, 0, 1245, 1, 0, 0, + 0, 0, 1247, 1, 0, 0, 0, 0, 1249, 1, 0, 0, 0, 0, 1251, 1, 0, 0, 0, 0, 1253, + 1, 0, 0, 0, 0, 1255, 1, 0, 0, 0, 0, 1257, 1, 0, 0, 0, 0, 1259, 1, 0, 0, + 0, 0, 1261, 1, 0, 0, 0, 0, 1263, 1, 0, 0, 0, 0, 1265, 1, 0, 0, 0, 0, 1267, + 1, 0, 0, 0, 0, 1269, 1, 0, 0, 0, 0, 1271, 1, 0, 0, 0, 0, 1273, 1, 0, 0, + 0, 0, 1275, 1, 0, 0, 0, 0, 1277, 1, 0, 0, 0, 0, 1279, 1, 0, 0, 0, 0, 1281, + 1, 0, 0, 0, 0, 1283, 1, 0, 0, 0, 0, 1285, 1, 0, 0, 0, 0, 1287, 1, 0, 0, + 0, 0, 1289, 1, 0, 0, 0, 0, 1291, 1, 0, 0, 0, 0, 1293, 1, 0, 0, 0, 0, 1295, + 1, 0, 0, 0, 0, 1297, 1, 0, 0, 0, 0, 1299, 1, 0, 0, 0, 0, 1301, 1, 0, 0, + 0, 0, 1303, 1, 0, 0, 0, 0, 1305, 1, 0, 0, 0, 0, 1307, 1, 0, 0, 0, 0, 1309, + 1, 0, 0, 0, 0, 1311, 1, 0, 0, 0, 0, 1313, 1, 0, 0, 0, 0, 1315, 1, 0, 0, + 0, 0, 1317, 1, 0, 0, 0, 0, 1319, 1, 0, 0, 0, 0, 1321, 1, 0, 0, 0, 0, 1323, + 1, 0, 0, 0, 0, 1325, 1, 0, 0, 0, 0, 1327, 1, 0, 0, 0, 0, 1329, 1, 0, 0, + 0, 0, 1331, 1, 0, 0, 0, 0, 1333, 1, 0, 0, 0, 0, 1335, 1, 0, 0, 0, 0, 1337, + 1, 0, 0, 0, 0, 1339, 1, 0, 0, 0, 0, 1341, 1, 0, 0, 0, 0, 1343, 1, 0, 0, + 0, 0, 1345, 1, 0, 0, 0, 0, 1347, 1, 0, 0, 0, 0, 1349, 1, 0, 0, 0, 0, 1351, + 1, 0, 0, 0, 0, 1353, 1, 0, 0, 0, 0, 1355, 1, 0, 0, 0, 0, 1357, 1, 0, 0, + 0, 0, 1359, 1, 0, 0, 0, 0, 1361, 1, 0, 0, 0, 0, 1363, 1, 0, 0, 0, 0, 1365, + 1, 0, 0, 0, 0, 1367, 1, 0, 0, 0, 0, 1369, 1, 0, 0, 0, 0, 1371, 1, 0, 0, + 0, 0, 1373, 1, 0, 0, 0, 0, 1375, 1, 0, 0, 0, 0, 1377, 1, 0, 0, 0, 0, 1379, + 1, 0, 0, 0, 0, 1381, 1, 0, 0, 0, 0, 1383, 1, 0, 0, 0, 0, 1385, 1, 0, 0, + 0, 0, 1387, 1, 0, 0, 0, 0, 1389, 1, 0, 0, 0, 0, 1391, 1, 0, 0, 0, 0, 1393, + 1, 0, 0, 0, 0, 1395, 1, 0, 0, 0, 0, 1397, 1, 0, 0, 0, 0, 1399, 1, 0, 0, + 0, 0, 1401, 1, 0, 0, 0, 0, 1403, 1, 0, 0, 0, 0, 1405, 1, 0, 0, 0, 0, 1407, + 1, 0, 0, 0, 0, 1409, 1, 0, 0, 0, 0, 1411, 1, 0, 0, 0, 0, 1413, 1, 0, 0, + 0, 0, 1415, 1, 0, 0, 0, 0, 1417, 1, 0, 0, 0, 0, 1419, 1, 0, 0, 0, 0, 1421, + 1, 0, 0, 0, 0, 1423, 1, 0, 0, 0, 0, 1425, 1, 0, 0, 0, 0, 1427, 1, 0, 0, + 0, 0, 1429, 1, 0, 0, 0, 0, 1431, 1, 0, 0, 0, 0, 1433, 1, 0, 0, 0, 0, 1435, + 1, 0, 0, 0, 0, 1437, 1, 0, 0, 0, 0, 1439, 1, 0, 0, 0, 0, 1441, 1, 0, 0, + 0, 0, 1443, 1, 0, 0, 0, 0, 1445, 1, 0, 0, 0, 0, 1447, 1, 0, 0, 0, 0, 1449, + 1, 0, 0, 0, 0, 1451, 1, 0, 0, 0, 0, 1453, 1, 0, 0, 0, 0, 1455, 1, 0, 0, + 0, 0, 1457, 1, 0, 0, 0, 0, 1459, 1, 0, 0, 0, 0, 1461, 1, 0, 0, 0, 0, 1463, + 1, 0, 0, 0, 0, 1465, 1, 0, 0, 0, 0, 1467, 1, 0, 0, 0, 0, 1469, 1, 0, 0, + 0, 0, 1471, 1, 0, 0, 0, 0, 1473, 1, 0, 0, 0, 0, 1475, 1, 0, 0, 0, 0, 1477, + 1, 0, 0, 0, 0, 1479, 1, 0, 0, 0, 0, 1481, 1, 0, 0, 0, 0, 1483, 1, 0, 0, + 0, 0, 1485, 1, 0, 0, 0, 0, 1487, 1, 0, 0, 0, 0, 1489, 1, 0, 0, 0, 0, 1491, + 1, 0, 0, 0, 0, 1493, 1, 0, 0, 0, 0, 1495, 1, 0, 0, 0, 0, 1497, 1, 0, 0, + 0, 0, 1499, 1, 0, 0, 0, 0, 1501, 1, 0, 0, 0, 0, 1503, 1, 0, 0, 0, 0, 1505, + 1, 0, 0, 0, 0, 1507, 1, 0, 0, 0, 0, 1509, 1, 0, 0, 0, 0, 1511, 1, 0, 0, + 0, 0, 1513, 1, 0, 0, 0, 0, 1515, 1, 0, 0, 0, 0, 1517, 1, 0, 0, 0, 0, 1519, + 1, 0, 0, 0, 0, 1521, 1, 0, 0, 0, 0, 1523, 1, 0, 0, 0, 0, 1525, 1, 0, 0, + 0, 0, 1527, 1, 0, 0, 0, 0, 1529, 1, 0, 0, 0, 0, 1531, 1, 0, 0, 0, 0, 1533, + 1, 0, 0, 0, 0, 1535, 1, 0, 0, 0, 0, 1537, 1, 0, 0, 0, 0, 1539, 1, 0, 0, + 0, 0, 1541, 1, 0, 0, 0, 0, 1543, 1, 0, 0, 0, 0, 1545, 1, 0, 0, 0, 0, 1547, + 1, 0, 0, 0, 0, 1549, 1, 0, 0, 0, 0, 1551, 1, 0, 0, 0, 0, 1553, 1, 0, 0, + 0, 0, 1555, 1, 0, 0, 0, 0, 1557, 1, 0, 0, 0, 0, 1559, 1, 0, 0, 0, 0, 1561, + 1, 0, 0, 0, 0, 1563, 1, 0, 0, 0, 0, 1565, 1, 0, 0, 0, 0, 1567, 1, 0, 0, + 0, 0, 1569, 1, 0, 0, 0, 0, 1571, 1, 0, 0, 0, 0, 1573, 1, 0, 0, 0, 0, 1575, + 1, 0, 0, 0, 0, 1577, 1, 0, 0, 0, 0, 1579, 1, 0, 0, 0, 0, 1581, 1, 0, 0, + 0, 0, 1583, 1, 0, 0, 0, 0, 1585, 1, 0, 0, 0, 0, 1587, 1, 0, 0, 0, 0, 1589, + 1, 0, 0, 0, 0, 1591, 1, 0, 0, 0, 0, 1593, 1, 0, 0, 0, 0, 1595, 1, 0, 0, + 0, 0, 1597, 1, 0, 0, 0, 0, 1599, 1, 0, 0, 0, 0, 1601, 1, 0, 0, 0, 0, 1603, + 1, 0, 0, 0, 0, 1605, 1, 0, 0, 0, 0, 1607, 1, 0, 0, 0, 0, 1609, 1, 0, 0, + 0, 0, 1611, 1, 0, 0, 0, 0, 1613, 1, 0, 0, 0, 0, 1615, 1, 0, 0, 0, 0, 1617, + 1, 0, 0, 0, 0, 1619, 1, 0, 0, 0, 0, 1621, 1, 0, 0, 0, 0, 1623, 1, 0, 0, + 0, 0, 1625, 1, 0, 0, 0, 0, 1627, 1, 0, 0, 0, 0, 1629, 1, 0, 0, 0, 0, 1631, + 1, 0, 0, 0, 0, 1633, 1, 0, 0, 0, 0, 1635, 1, 0, 0, 0, 0, 1637, 1, 0, 0, + 0, 0, 1639, 1, 0, 0, 0, 0, 1641, 1, 0, 0, 0, 0, 1643, 1, 0, 0, 0, 0, 1645, + 1, 0, 0, 0, 0, 1647, 1, 0, 0, 0, 0, 1649, 1, 0, 0, 0, 0, 1651, 1, 0, 0, + 0, 0, 1653, 1, 0, 0, 0, 0, 1655, 1, 0, 0, 0, 0, 1657, 1, 0, 0, 0, 0, 1659, + 1, 0, 0, 0, 0, 1661, 1, 0, 0, 0, 0, 1663, 1, 0, 0, 0, 0, 1665, 1, 0, 0, + 0, 0, 1667, 1, 0, 0, 0, 0, 1669, 1, 0, 0, 0, 0, 1671, 1, 0, 0, 0, 0, 1673, + 1, 0, 0, 0, 0, 1675, 1, 0, 0, 0, 0, 1677, 1, 0, 0, 0, 0, 1679, 1, 0, 0, + 0, 0, 1681, 1, 0, 0, 0, 0, 1683, 1, 0, 0, 0, 0, 1685, 1, 0, 0, 0, 0, 1687, + 1, 0, 0, 0, 0, 1689, 1, 0, 0, 0, 0, 1691, 1, 0, 0, 0, 0, 1693, 1, 0, 0, + 0, 0, 1695, 1, 0, 0, 0, 0, 1697, 1, 0, 0, 0, 0, 1699, 1, 0, 0, 0, 0, 1701, + 1, 0, 0, 0, 0, 1703, 1, 0, 0, 0, 0, 1705, 1, 0, 0, 0, 0, 1707, 1, 0, 0, + 0, 0, 1709, 1, 0, 0, 0, 0, 1711, 1, 0, 0, 0, 0, 1713, 1, 0, 0, 0, 0, 1715, + 1, 0, 0, 0, 0, 1717, 1, 0, 0, 0, 0, 1719, 1, 0, 0, 0, 0, 1721, 1, 0, 0, + 0, 0, 1723, 1, 0, 0, 0, 0, 1725, 1, 0, 0, 0, 0, 1727, 1, 0, 0, 0, 0, 1729, + 1, 0, 0, 0, 0, 1731, 1, 0, 0, 0, 0, 1733, 1, 0, 0, 0, 0, 1735, 1, 0, 0, + 0, 0, 1737, 1, 0, 0, 0, 0, 1739, 1, 0, 0, 0, 0, 1741, 1, 0, 0, 0, 0, 1743, + 1, 0, 0, 0, 0, 1745, 1, 0, 0, 0, 0, 1747, 1, 0, 0, 0, 0, 1749, 1, 0, 0, + 0, 0, 1751, 1, 0, 0, 0, 0, 1753, 1, 0, 0, 0, 0, 1755, 1, 0, 0, 0, 0, 1757, + 1, 0, 0, 0, 0, 1759, 1, 0, 0, 0, 0, 1761, 1, 0, 0, 0, 0, 1763, 1, 0, 0, + 0, 0, 1765, 1, 0, 0, 0, 0, 1767, 1, 0, 0, 0, 0, 1769, 1, 0, 0, 0, 0, 1771, + 1, 0, 0, 0, 0, 1773, 1, 0, 0, 0, 0, 1775, 1, 0, 0, 0, 0, 1777, 1, 0, 0, + 0, 0, 1779, 1, 0, 0, 0, 0, 1781, 1, 0, 0, 0, 0, 1783, 1, 0, 0, 0, 0, 1785, + 1, 0, 0, 0, 0, 1787, 1, 0, 0, 0, 0, 1789, 1, 0, 0, 0, 0, 1791, 1, 0, 0, + 0, 0, 1793, 1, 0, 0, 0, 0, 1795, 1, 0, 0, 0, 0, 1797, 1, 0, 0, 0, 0, 1799, + 1, 0, 0, 0, 0, 1801, 1, 0, 0, 0, 0, 1803, 1, 0, 0, 0, 0, 1805, 1, 0, 0, + 0, 0, 1807, 1, 0, 0, 0, 0, 1809, 1, 0, 0, 0, 0, 1811, 1, 0, 0, 0, 0, 1813, + 1, 0, 0, 0, 0, 1815, 1, 0, 0, 0, 0, 1817, 1, 0, 0, 0, 0, 1819, 1, 0, 0, + 0, 0, 1821, 1, 0, 0, 0, 0, 1823, 1, 0, 0, 0, 0, 1825, 1, 0, 0, 0, 0, 1827, + 1, 0, 0, 0, 0, 1829, 1, 0, 0, 0, 0, 1831, 1, 0, 0, 0, 0, 1833, 1, 0, 0, + 0, 0, 1835, 1, 0, 0, 0, 0, 1837, 1, 0, 0, 0, 0, 1839, 1, 0, 0, 0, 0, 1841, + 1, 0, 0, 0, 0, 1843, 1, 0, 0, 0, 0, 1845, 1, 0, 0, 0, 0, 1847, 1, 0, 0, + 0, 0, 1849, 1, 0, 0, 0, 0, 1851, 1, 0, 0, 0, 0, 1853, 1, 0, 0, 0, 0, 1855, + 1, 0, 0, 0, 0, 1857, 1, 0, 0, 0, 0, 1859, 1, 0, 0, 0, 0, 1861, 1, 0, 0, + 0, 0, 1863, 1, 0, 0, 0, 0, 1865, 1, 0, 0, 0, 0, 1867, 1, 0, 0, 0, 0, 1869, + 1, 0, 0, 0, 0, 1871, 1, 0, 0, 0, 0, 1873, 1, 0, 0, 0, 0, 1875, 1, 0, 0, + 0, 0, 1877, 1, 0, 0, 0, 0, 1879, 1, 0, 0, 0, 0, 1881, 1, 0, 0, 0, 0, 1883, + 1, 0, 0, 0, 0, 1885, 1, 0, 0, 0, 0, 1887, 1, 0, 0, 0, 0, 1889, 1, 0, 0, + 0, 0, 1891, 1, 0, 0, 0, 0, 1893, 1, 0, 0, 0, 0, 1895, 1, 0, 0, 0, 0, 1897, + 1, 0, 0, 0, 0, 1899, 1, 0, 0, 0, 0, 1901, 1, 0, 0, 0, 0, 1903, 1, 0, 0, + 0, 0, 1905, 1, 0, 0, 0, 0, 1907, 1, 0, 0, 0, 0, 1909, 1, 0, 0, 0, 0, 1911, + 1, 0, 0, 0, 0, 1913, 1, 0, 0, 0, 0, 1915, 1, 0, 0, 0, 0, 1917, 1, 0, 0, + 0, 0, 1919, 1, 0, 0, 0, 0, 1921, 1, 0, 0, 0, 0, 1923, 1, 0, 0, 0, 0, 1925, + 1, 0, 0, 0, 0, 1927, 1, 0, 0, 0, 0, 1929, 1, 0, 0, 0, 0, 1931, 1, 0, 0, + 0, 0, 1933, 1, 0, 0, 0, 0, 1935, 1, 0, 0, 0, 0, 1937, 1, 0, 0, 0, 0, 1939, + 1, 0, 0, 0, 0, 1941, 1, 0, 0, 0, 0, 1943, 1, 0, 0, 0, 0, 1945, 1, 0, 0, + 0, 0, 1947, 1, 0, 0, 0, 0, 1949, 1, 0, 0, 0, 0, 1951, 1, 0, 0, 0, 0, 1953, + 1, 0, 0, 0, 0, 1955, 1, 0, 0, 0, 0, 1957, 1, 0, 0, 0, 0, 1959, 1, 0, 0, + 0, 0, 1961, 1, 0, 0, 0, 0, 1963, 1, 0, 0, 0, 0, 1965, 1, 0, 0, 0, 0, 1967, + 1, 0, 0, 0, 0, 1969, 1, 0, 0, 0, 0, 1971, 1, 0, 0, 0, 0, 1973, 1, 0, 0, + 0, 0, 1975, 1, 0, 0, 0, 0, 1977, 1, 0, 0, 0, 0, 1979, 1, 0, 0, 0, 0, 1981, + 1, 0, 0, 0, 0, 1983, 1, 0, 0, 0, 0, 1985, 1, 0, 0, 0, 0, 1987, 1, 0, 0, + 0, 0, 1989, 1, 0, 0, 0, 0, 1991, 1, 0, 0, 0, 0, 1993, 1, 0, 0, 0, 0, 1995, + 1, 0, 0, 0, 0, 1997, 1, 0, 0, 0, 0, 1999, 1, 0, 0, 0, 0, 2001, 1, 0, 0, + 0, 0, 2003, 1, 0, 0, 0, 0, 2005, 1, 0, 0, 0, 0, 2007, 1, 0, 0, 0, 0, 2009, + 1, 0, 0, 0, 0, 2011, 1, 0, 0, 0, 0, 2013, 1, 0, 0, 0, 0, 2015, 1, 0, 0, + 0, 0, 2017, 1, 0, 0, 0, 0, 2019, 1, 0, 0, 0, 0, 2021, 1, 0, 0, 0, 0, 2023, + 1, 0, 0, 0, 0, 2025, 1, 0, 0, 0, 0, 2027, 1, 0, 0, 0, 0, 2029, 1, 0, 0, + 0, 0, 2031, 1, 0, 0, 0, 0, 2033, 1, 0, 0, 0, 0, 2035, 1, 0, 0, 0, 0, 2037, + 1, 0, 0, 0, 0, 2039, 1, 0, 0, 0, 0, 2041, 1, 0, 0, 0, 0, 2043, 1, 0, 0, + 0, 0, 2045, 1, 0, 0, 0, 0, 2047, 1, 0, 0, 0, 0, 2049, 1, 0, 0, 0, 0, 2051, + 1, 0, 0, 0, 0, 2053, 1, 0, 0, 0, 0, 2055, 1, 0, 0, 0, 0, 2057, 1, 0, 0, + 0, 0, 2059, 1, 0, 0, 0, 0, 2061, 1, 0, 0, 0, 0, 2063, 1, 0, 0, 0, 0, 2065, + 1, 0, 0, 0, 0, 2067, 1, 0, 0, 0, 0, 2069, 1, 0, 0, 0, 0, 2071, 1, 0, 0, + 0, 0, 2073, 1, 0, 0, 0, 0, 2075, 1, 0, 0, 0, 0, 2077, 1, 0, 0, 0, 0, 2079, + 1, 0, 0, 0, 0, 2081, 1, 0, 0, 0, 0, 2083, 1, 0, 0, 0, 0, 2085, 1, 0, 0, + 0, 0, 2087, 1, 0, 0, 0, 0, 2089, 1, 0, 0, 0, 0, 2091, 1, 0, 0, 0, 0, 2093, + 1, 0, 0, 0, 0, 2095, 1, 0, 0, 0, 0, 2097, 1, 0, 0, 0, 0, 2099, 1, 0, 0, + 0, 0, 2101, 1, 0, 0, 0, 0, 2103, 1, 0, 0, 0, 0, 2105, 1, 0, 0, 0, 0, 2107, + 1, 0, 0, 0, 0, 2109, 1, 0, 0, 0, 0, 2111, 1, 0, 0, 0, 0, 2113, 1, 0, 0, + 0, 0, 2115, 1, 0, 0, 0, 0, 2117, 1, 0, 0, 0, 0, 2119, 1, 0, 0, 0, 0, 2121, + 1, 0, 0, 0, 0, 2123, 1, 0, 0, 0, 0, 2125, 1, 0, 0, 0, 0, 2127, 1, 0, 0, + 0, 0, 2129, 1, 0, 0, 0, 0, 2131, 1, 0, 0, 0, 0, 2133, 1, 0, 0, 0, 0, 2135, + 1, 0, 0, 0, 0, 2137, 1, 0, 0, 0, 0, 2139, 1, 0, 0, 0, 0, 2141, 1, 0, 0, + 0, 0, 2143, 1, 0, 0, 0, 0, 2145, 1, 0, 0, 0, 0, 2147, 1, 0, 0, 0, 0, 2149, + 1, 0, 0, 0, 0, 2151, 1, 0, 0, 0, 0, 2153, 1, 0, 0, 0, 0, 2155, 1, 0, 0, + 0, 0, 2157, 1, 0, 0, 0, 0, 2159, 1, 0, 0, 0, 0, 2161, 1, 0, 0, 0, 0, 2163, + 1, 0, 0, 0, 0, 2165, 1, 0, 0, 0, 0, 2167, 1, 0, 0, 0, 0, 2169, 1, 0, 0, + 0, 0, 2171, 1, 0, 0, 0, 0, 2173, 1, 0, 0, 0, 0, 2175, 1, 0, 0, 0, 0, 2177, + 1, 0, 0, 0, 0, 2179, 1, 0, 0, 0, 0, 2181, 1, 0, 0, 0, 0, 2183, 1, 0, 0, + 0, 0, 2185, 1, 0, 0, 0, 0, 2187, 1, 0, 0, 0, 0, 2189, 1, 0, 0, 0, 0, 2191, + 1, 0, 0, 0, 0, 2193, 1, 0, 0, 0, 0, 2195, 1, 0, 0, 0, 0, 2197, 1, 0, 0, + 0, 0, 2199, 1, 0, 0, 0, 0, 2201, 1, 0, 0, 0, 0, 2203, 1, 0, 0, 0, 0, 2205, + 1, 0, 0, 0, 0, 2207, 1, 0, 0, 0, 0, 2209, 1, 0, 0, 0, 0, 2211, 1, 0, 0, + 0, 0, 2213, 1, 0, 0, 0, 0, 2215, 1, 0, 0, 0, 0, 2217, 1, 0, 0, 0, 0, 2219, + 1, 0, 0, 0, 0, 2221, 1, 0, 0, 0, 0, 2223, 1, 0, 0, 0, 0, 2225, 1, 0, 0, + 0, 0, 2227, 1, 0, 0, 0, 0, 2229, 1, 0, 0, 0, 0, 2231, 1, 0, 0, 0, 0, 2233, + 1, 0, 0, 0, 0, 2235, 1, 0, 0, 0, 0, 2237, 1, 0, 0, 0, 0, 2239, 1, 0, 0, + 0, 0, 2241, 1, 0, 0, 0, 0, 2243, 1, 0, 0, 0, 0, 2245, 1, 0, 0, 0, 0, 2247, + 1, 0, 0, 0, 0, 2249, 1, 0, 0, 0, 0, 2251, 1, 0, 0, 0, 0, 2253, 1, 0, 0, + 0, 0, 2255, 1, 0, 0, 0, 0, 2257, 1, 0, 0, 0, 0, 2259, 1, 0, 0, 0, 0, 2261, + 1, 0, 0, 0, 0, 2263, 1, 0, 0, 0, 0, 2265, 1, 0, 0, 0, 0, 2267, 1, 0, 0, + 0, 0, 2269, 1, 0, 0, 0, 0, 2271, 1, 0, 0, 0, 0, 2273, 1, 0, 0, 0, 0, 2275, + 1, 0, 0, 0, 0, 2277, 1, 0, 0, 0, 0, 2279, 1, 0, 0, 0, 0, 2281, 1, 0, 0, + 0, 0, 2283, 1, 0, 0, 0, 0, 2285, 1, 0, 0, 0, 0, 2287, 1, 0, 0, 0, 0, 2289, + 1, 0, 0, 0, 0, 2291, 1, 0, 0, 0, 0, 2293, 1, 0, 0, 0, 0, 2295, 1, 0, 0, + 0, 0, 2297, 1, 0, 0, 0, 0, 2299, 1, 0, 0, 0, 0, 2301, 1, 0, 0, 0, 0, 2303, + 1, 0, 0, 0, 0, 2305, 1, 0, 0, 0, 0, 2307, 1, 0, 0, 0, 0, 2309, 1, 0, 0, + 0, 0, 2311, 1, 0, 0, 0, 0, 2313, 1, 0, 0, 0, 0, 2315, 1, 0, 0, 0, 0, 2317, + 1, 0, 0, 0, 0, 2319, 1, 0, 0, 0, 0, 2321, 1, 0, 0, 0, 0, 2323, 1, 0, 0, + 0, 0, 2325, 1, 0, 0, 0, 0, 2327, 1, 0, 0, 0, 0, 2329, 1, 0, 0, 0, 0, 2331, + 1, 0, 0, 0, 0, 2333, 1, 0, 0, 0, 0, 2335, 1, 0, 0, 0, 0, 2337, 1, 0, 0, + 0, 0, 2339, 1, 0, 0, 0, 0, 2341, 1, 0, 0, 0, 0, 2343, 1, 0, 0, 0, 0, 2345, + 1, 0, 0, 0, 0, 2347, 1, 0, 0, 0, 0, 2349, 1, 0, 0, 0, 0, 2351, 1, 0, 0, + 0, 0, 2353, 1, 0, 0, 0, 0, 2355, 1, 0, 0, 0, 0, 2357, 1, 0, 0, 0, 0, 2359, + 1, 0, 0, 0, 0, 2361, 1, 0, 0, 0, 0, 2363, 1, 0, 0, 0, 0, 2365, 1, 0, 0, + 0, 0, 2367, 1, 0, 0, 0, 0, 2369, 1, 0, 0, 0, 0, 2371, 1, 0, 0, 0, 0, 2373, + 1, 0, 0, 0, 0, 2375, 1, 0, 0, 0, 0, 2377, 1, 0, 0, 0, 0, 2379, 1, 0, 0, + 0, 0, 2381, 1, 0, 0, 0, 0, 2383, 1, 0, 0, 0, 0, 2385, 1, 0, 0, 0, 0, 2387, + 1, 0, 0, 0, 0, 2389, 1, 0, 0, 0, 0, 2391, 1, 0, 0, 0, 0, 2393, 1, 0, 0, + 0, 0, 2395, 1, 0, 0, 0, 0, 2397, 1, 0, 0, 0, 0, 2399, 1, 0, 0, 0, 0, 2401, + 1, 0, 0, 0, 0, 2403, 1, 0, 0, 0, 0, 2405, 1, 0, 0, 0, 0, 2407, 1, 0, 0, + 0, 0, 2409, 1, 0, 0, 0, 0, 2411, 1, 0, 0, 0, 0, 2413, 1, 0, 0, 0, 0, 2415, + 1, 0, 0, 0, 0, 2417, 1, 0, 0, 0, 0, 2419, 1, 0, 0, 0, 0, 2421, 1, 0, 0, + 0, 0, 2423, 1, 0, 0, 0, 0, 2425, 1, 0, 0, 0, 0, 2427, 1, 0, 0, 0, 0, 2429, + 1, 0, 0, 0, 0, 2431, 1, 0, 0, 0, 0, 2433, 1, 0, 0, 0, 0, 2435, 1, 0, 0, + 0, 0, 2437, 1, 0, 0, 0, 0, 2439, 1, 0, 0, 0, 0, 2441, 1, 0, 0, 0, 1, 2453, + 1, 0, 0, 0, 3, 2459, 1, 0, 0, 0, 5, 2476, 1, 0, 0, 0, 7, 2483, 1, 0, 0, + 0, 9, 2492, 1, 0, 0, 0, 11, 2522, 1, 0, 0, 0, 13, 2541, 1, 0, 0, 0, 15, + 2548, 1, 0, 0, 0, 17, 2555, 1, 0, 0, 0, 19, 2566, 1, 0, 0, 0, 21, 2573, + 1, 0, 0, 0, 23, 2577, 1, 0, 0, 0, 25, 2585, 1, 0, 0, 0, 27, 2596, 1, 0, + 0, 0, 29, 2600, 1, 0, 0, 0, 31, 2608, 1, 0, 0, 0, 33, 2616, 1, 0, 0, 0, + 35, 2624, 1, 0, 0, 0, 37, 2633, 1, 0, 0, 0, 39, 2639, 1, 0, 0, 0, 41, 2649, + 1, 0, 0, 0, 43, 2659, 1, 0, 0, 0, 45, 2663, 1, 0, 0, 0, 47, 2671, 1, 0, + 0, 0, 49, 2689, 1, 0, 0, 0, 51, 2725, 1, 0, 0, 0, 53, 2751, 1, 0, 0, 0, + 55, 2768, 1, 0, 0, 0, 57, 2784, 1, 0, 0, 0, 59, 2808, 1, 0, 0, 0, 61, 2833, + 1, 0, 0, 0, 63, 2849, 1, 0, 0, 0, 65, 2863, 1, 0, 0, 0, 67, 2875, 1, 0, + 0, 0, 69, 2886, 1, 0, 0, 0, 71, 2892, 1, 0, 0, 0, 73, 2899, 1, 0, 0, 0, + 75, 2903, 1, 0, 0, 0, 77, 2913, 1, 0, 0, 0, 79, 2927, 1, 0, 0, 0, 81, 2938, + 1, 0, 0, 0, 83, 2956, 1, 0, 0, 0, 85, 2975, 1, 0, 0, 0, 87, 2993, 1, 0, + 0, 0, 89, 3006, 1, 0, 0, 0, 91, 3020, 1, 0, 0, 0, 93, 3024, 1, 0, 0, 0, + 95, 3031, 1, 0, 0, 0, 97, 3043, 1, 0, 0, 0, 99, 3059, 1, 0, 0, 0, 101, + 3072, 1, 0, 0, 0, 103, 3085, 1, 0, 0, 0, 105, 3091, 1, 0, 0, 0, 107, 3100, + 1, 0, 0, 0, 109, 3111, 1, 0, 0, 0, 111, 3123, 1, 0, 0, 0, 113, 3126, 1, + 0, 0, 0, 115, 3130, 1, 0, 0, 0, 117, 3136, 1, 0, 0, 0, 119, 3145, 1, 0, + 0, 0, 121, 3162, 1, 0, 0, 0, 123, 3173, 1, 0, 0, 0, 125, 3193, 1, 0, 0, + 0, 127, 3196, 1, 0, 0, 0, 129, 3202, 1, 0, 0, 0, 131, 3213, 1, 0, 0, 0, + 133, 3226, 1, 0, 0, 0, 135, 3241, 1, 0, 0, 0, 137, 3255, 1, 0, 0, 0, 139, + 3260, 1, 0, 0, 0, 141, 3279, 1, 0, 0, 0, 143, 3300, 1, 0, 0, 0, 145, 3328, + 1, 0, 0, 0, 147, 3338, 1, 0, 0, 0, 149, 3351, 1, 0, 0, 0, 151, 3362, 1, + 0, 0, 0, 153, 3385, 1, 0, 0, 0, 155, 3395, 1, 0, 0, 0, 157, 3407, 1, 0, + 0, 0, 159, 3430, 1, 0, 0, 0, 161, 3459, 1, 0, 0, 0, 163, 3472, 1, 0, 0, + 0, 165, 3490, 1, 0, 0, 0, 167, 3494, 1, 0, 0, 0, 169, 3496, 1, 0, 0, 0, + 171, 3503, 1, 0, 0, 0, 173, 3518, 1, 0, 0, 0, 175, 3534, 1, 0, 0, 0, 177, + 3541, 1, 0, 0, 0, 179, 3548, 1, 0, 0, 0, 181, 3554, 1, 0, 0, 0, 183, 3567, + 1, 0, 0, 0, 185, 3575, 1, 0, 0, 0, 187, 3582, 1, 0, 0, 0, 189, 3598, 1, + 0, 0, 0, 191, 3605, 1, 0, 0, 0, 193, 3613, 1, 0, 0, 0, 195, 3626, 1, 0, + 0, 0, 197, 3632, 1, 0, 0, 0, 199, 3641, 1, 0, 0, 0, 201, 3660, 1, 0, 0, + 0, 203, 3670, 1, 0, 0, 0, 205, 3683, 1, 0, 0, 0, 207, 3689, 1, 0, 0, 0, + 209, 3696, 1, 0, 0, 0, 211, 3712, 1, 0, 0, 0, 213, 3719, 1, 0, 0, 0, 215, + 3726, 1, 0, 0, 0, 217, 3738, 1, 0, 0, 0, 219, 3743, 1, 0, 0, 0, 221, 3755, + 1, 0, 0, 0, 223, 3758, 1, 0, 0, 0, 225, 3764, 1, 0, 0, 0, 227, 3771, 1, + 0, 0, 0, 229, 3778, 1, 0, 0, 0, 231, 3794, 1, 0, 0, 0, 233, 3802, 1, 0, + 0, 0, 235, 3807, 1, 0, 0, 0, 237, 3812, 1, 0, 0, 0, 239, 3820, 1, 0, 0, + 0, 241, 3826, 1, 0, 0, 0, 243, 3843, 1, 0, 0, 0, 245, 3855, 1, 0, 0, 0, + 247, 3867, 1, 0, 0, 0, 249, 3882, 1, 0, 0, 0, 251, 3890, 1, 0, 0, 0, 253, + 3897, 1, 0, 0, 0, 255, 3905, 1, 0, 0, 0, 257, 3917, 1, 0, 0, 0, 259, 3934, + 1, 0, 0, 0, 261, 3950, 1, 0, 0, 0, 263, 3955, 1, 0, 0, 0, 265, 3965, 1, + 0, 0, 0, 267, 3971, 1, 0, 0, 0, 269, 3982, 1, 0, 0, 0, 271, 3995, 1, 0, + 0, 0, 273, 4012, 1, 0, 0, 0, 275, 4020, 1, 0, 0, 0, 277, 4035, 1, 0, 0, + 0, 279, 4046, 1, 0, 0, 0, 281, 4055, 1, 0, 0, 0, 283, 4068, 1, 0, 0, 0, + 285, 4079, 1, 0, 0, 0, 287, 4096, 1, 0, 0, 0, 289, 4109, 1, 0, 0, 0, 291, + 4129, 1, 0, 0, 0, 293, 4140, 1, 0, 0, 0, 295, 4148, 1, 0, 0, 0, 297, 4162, + 1, 0, 0, 0, 299, 4168, 1, 0, 0, 0, 301, 4176, 1, 0, 0, 0, 303, 4186, 1, + 0, 0, 0, 305, 4195, 1, 0, 0, 0, 307, 4203, 1, 0, 0, 0, 309, 4214, 1, 0, + 0, 0, 311, 4221, 1, 0, 0, 0, 313, 4236, 1, 0, 0, 0, 315, 4244, 1, 0, 0, + 0, 317, 4256, 1, 0, 0, 0, 319, 4276, 1, 0, 0, 0, 321, 4298, 1, 0, 0, 0, + 323, 4316, 1, 0, 0, 0, 325, 4327, 1, 0, 0, 0, 327, 4336, 1, 0, 0, 0, 329, + 4343, 1, 0, 0, 0, 331, 4353, 1, 0, 0, 0, 333, 4373, 1, 0, 0, 0, 335, 4382, + 1, 0, 0, 0, 337, 4394, 1, 0, 0, 0, 339, 4412, 1, 0, 0, 0, 341, 4436, 1, + 0, 0, 0, 343, 4444, 1, 0, 0, 0, 345, 4451, 1, 0, 0, 0, 347, 4475, 1, 0, + 0, 0, 349, 4485, 1, 0, 0, 0, 351, 4499, 1, 0, 0, 0, 353, 4507, 1, 0, 0, + 0, 355, 4518, 1, 0, 0, 0, 357, 4537, 1, 0, 0, 0, 359, 4548, 1, 0, 0, 0, + 361, 4560, 1, 0, 0, 0, 363, 4569, 1, 0, 0, 0, 365, 4583, 1, 0, 0, 0, 367, + 4591, 1, 0, 0, 0, 369, 4599, 1, 0, 0, 0, 371, 4612, 1, 0, 0, 0, 373, 4621, + 1, 0, 0, 0, 375, 4642, 1, 0, 0, 0, 377, 4651, 1, 0, 0, 0, 379, 4665, 1, + 0, 0, 0, 381, 4673, 1, 0, 0, 0, 383, 4690, 1, 0, 0, 0, 385, 4700, 1, 0, + 0, 0, 387, 4707, 1, 0, 0, 0, 389, 4717, 1, 0, 0, 0, 391, 4723, 1, 0, 0, + 0, 393, 4731, 1, 0, 0, 0, 395, 4741, 1, 0, 0, 0, 397, 4745, 1, 0, 0, 0, + 399, 4752, 1, 0, 0, 0, 401, 4763, 1, 0, 0, 0, 403, 4784, 1, 0, 0, 0, 405, + 4795, 1, 0, 0, 0, 407, 4801, 1, 0, 0, 0, 409, 4815, 1, 0, 0, 0, 411, 4825, + 1, 0, 0, 0, 413, 4833, 1, 0, 0, 0, 415, 4846, 1, 0, 0, 0, 417, 4865, 1, + 0, 0, 0, 419, 4878, 1, 0, 0, 0, 421, 4896, 1, 0, 0, 0, 423, 4919, 1, 0, + 0, 0, 425, 4932, 1, 0, 0, 0, 427, 4939, 1, 0, 0, 0, 429, 4962, 1, 0, 0, + 0, 431, 4977, 1, 0, 0, 0, 433, 4991, 1, 0, 0, 0, 435, 4997, 1, 0, 0, 0, + 437, 5002, 1, 0, 0, 0, 439, 5011, 1, 0, 0, 0, 441, 5030, 1, 0, 0, 0, 443, + 5049, 1, 0, 0, 0, 445, 5071, 1, 0, 0, 0, 447, 5082, 1, 0, 0, 0, 449, 5092, + 1, 0, 0, 0, 451, 5109, 1, 0, 0, 0, 453, 5121, 1, 0, 0, 0, 455, 5133, 1, + 0, 0, 0, 457, 5141, 1, 0, 0, 0, 459, 5150, 1, 0, 0, 0, 461, 5159, 1, 0, + 0, 0, 463, 5168, 1, 0, 0, 0, 465, 5198, 1, 0, 0, 0, 467, 5203, 1, 0, 0, + 0, 469, 5208, 1, 0, 0, 0, 471, 5218, 1, 0, 0, 0, 473, 5230, 1, 0, 0, 0, + 475, 5242, 1, 0, 0, 0, 477, 5248, 1, 0, 0, 0, 479, 5256, 1, 0, 0, 0, 481, + 5260, 1, 0, 0, 0, 483, 5271, 1, 0, 0, 0, 485, 5279, 1, 0, 0, 0, 487, 5290, + 1, 0, 0, 0, 489, 5301, 1, 0, 0, 0, 491, 5309, 1, 0, 0, 0, 493, 5326, 1, + 0, 0, 0, 495, 5337, 1, 0, 0, 0, 497, 5363, 1, 0, 0, 0, 499, 5380, 1, 0, + 0, 0, 501, 5395, 1, 0, 0, 0, 503, 5406, 1, 0, 0, 0, 505, 5412, 1, 0, 0, + 0, 507, 5431, 1, 0, 0, 0, 509, 5438, 1, 0, 0, 0, 511, 5446, 1, 0, 0, 0, + 513, 5457, 1, 0, 0, 0, 515, 5462, 1, 0, 0, 0, 517, 5473, 1, 0, 0, 0, 519, + 5477, 1, 0, 0, 0, 521, 5482, 1, 0, 0, 0, 523, 5494, 1, 0, 0, 0, 525, 5499, + 1, 0, 0, 0, 527, 5513, 1, 0, 0, 0, 529, 5518, 1, 0, 0, 0, 531, 5530, 1, + 0, 0, 0, 533, 5537, 1, 0, 0, 0, 535, 5548, 1, 0, 0, 0, 537, 5561, 1, 0, + 0, 0, 539, 5576, 1, 0, 0, 0, 541, 5584, 1, 0, 0, 0, 543, 5593, 1, 0, 0, + 0, 545, 5608, 1, 0, 0, 0, 547, 5613, 1, 0, 0, 0, 549, 5622, 1, 0, 0, 0, + 551, 5634, 1, 0, 0, 0, 553, 5647, 1, 0, 0, 0, 555, 5656, 1, 0, 0, 0, 557, + 5667, 1, 0, 0, 0, 559, 5674, 1, 0, 0, 0, 561, 5677, 1, 0, 0, 0, 563, 5680, + 1, 0, 0, 0, 565, 5685, 1, 0, 0, 0, 567, 5702, 1, 0, 0, 0, 569, 5716, 1, + 0, 0, 0, 571, 5728, 1, 0, 0, 0, 573, 5733, 1, 0, 0, 0, 575, 5741, 1, 0, + 0, 0, 577, 5750, 1, 0, 0, 0, 579, 5755, 1, 0, 0, 0, 581, 5765, 1, 0, 0, + 0, 583, 5771, 1, 0, 0, 0, 585, 5778, 1, 0, 0, 0, 587, 5786, 1, 0, 0, 0, + 589, 5800, 1, 0, 0, 0, 591, 5810, 1, 0, 0, 0, 593, 5826, 1, 0, 0, 0, 595, + 5837, 1, 0, 0, 0, 597, 5853, 1, 0, 0, 0, 599, 5857, 1, 0, 0, 0, 601, 5866, + 1, 0, 0, 0, 603, 5879, 1, 0, 0, 0, 605, 5886, 1, 0, 0, 0, 607, 5892, 1, + 0, 0, 0, 609, 5919, 1, 0, 0, 0, 611, 5930, 1, 0, 0, 0, 613, 5944, 1, 0, + 0, 0, 615, 5957, 1, 0, 0, 0, 617, 5973, 1, 0, 0, 0, 619, 5988, 1, 0, 0, + 0, 621, 6000, 1, 0, 0, 0, 623, 6007, 1, 0, 0, 0, 625, 6020, 1, 0, 0, 0, + 627, 6026, 1, 0, 0, 0, 629, 6036, 1, 0, 0, 0, 631, 6057, 1, 0, 0, 0, 633, + 6064, 1, 0, 0, 0, 635, 6074, 1, 0, 0, 0, 637, 6085, 1, 0, 0, 0, 639, 6101, + 1, 0, 0, 0, 641, 6111, 1, 0, 0, 0, 643, 6117, 1, 0, 0, 0, 645, 6124, 1, + 0, 0, 0, 647, 6132, 1, 0, 0, 0, 649, 6137, 1, 0, 0, 0, 651, 6144, 1, 0, + 0, 0, 653, 6155, 1, 0, 0, 0, 655, 6167, 1, 0, 0, 0, 657, 6176, 1, 0, 0, + 0, 659, 6200, 1, 0, 0, 0, 661, 6210, 1, 0, 0, 0, 663, 6219, 1, 0, 0, 0, + 665, 6235, 1, 0, 0, 0, 667, 6244, 1, 0, 0, 0, 669, 6258, 1, 0, 0, 0, 671, + 6266, 1, 0, 0, 0, 673, 6288, 1, 0, 0, 0, 675, 6312, 1, 0, 0, 0, 677, 6327, + 1, 0, 0, 0, 679, 6334, 1, 0, 0, 0, 681, 6339, 1, 0, 0, 0, 683, 6352, 1, + 0, 0, 0, 685, 6358, 1, 0, 0, 0, 687, 6363, 1, 0, 0, 0, 689, 6373, 1, 0, + 0, 0, 691, 6391, 1, 0, 0, 0, 693, 6404, 1, 0, 0, 0, 695, 6419, 1, 0, 0, + 0, 697, 6430, 1, 0, 0, 0, 699, 6439, 1, 0, 0, 0, 701, 6448, 1, 0, 0, 0, + 703, 6461, 1, 0, 0, 0, 705, 6476, 1, 0, 0, 0, 707, 6487, 1, 0, 0, 0, 709, + 6501, 1, 0, 0, 0, 711, 6509, 1, 0, 0, 0, 713, 6519, 1, 0, 0, 0, 715, 6529, + 1, 0, 0, 0, 717, 6543, 1, 0, 0, 0, 719, 6554, 1, 0, 0, 0, 721, 6561, 1, + 0, 0, 0, 723, 6567, 1, 0, 0, 0, 725, 6579, 1, 0, 0, 0, 727, 6587, 1, 0, + 0, 0, 729, 6597, 1, 0, 0, 0, 731, 6601, 1, 0, 0, 0, 733, 6607, 1, 0, 0, + 0, 735, 6614, 1, 0, 0, 0, 737, 6624, 1, 0, 0, 0, 739, 6634, 1, 0, 0, 0, + 741, 6644, 1, 0, 0, 0, 743, 6675, 1, 0, 0, 0, 745, 6705, 1, 0, 0, 0, 747, + 6713, 1, 0, 0, 0, 749, 6720, 1, 0, 0, 0, 751, 6734, 1, 0, 0, 0, 753, 6747, + 1, 0, 0, 0, 755, 6752, 1, 0, 0, 0, 757, 6761, 1, 0, 0, 0, 759, 6775, 1, + 0, 0, 0, 761, 6780, 1, 0, 0, 0, 763, 6785, 1, 0, 0, 0, 765, 6794, 1, 0, + 0, 0, 767, 6803, 1, 0, 0, 0, 769, 6827, 1, 0, 0, 0, 771, 6851, 1, 0, 0, + 0, 773, 6860, 1, 0, 0, 0, 775, 6863, 1, 0, 0, 0, 777, 6873, 1, 0, 0, 0, + 779, 6883, 1, 0, 0, 0, 781, 6903, 1, 0, 0, 0, 783, 6918, 1, 0, 0, 0, 785, + 6927, 1, 0, 0, 0, 787, 6946, 1, 0, 0, 0, 789, 6960, 1, 0, 0, 0, 791, 6964, + 1, 0, 0, 0, 793, 6970, 1, 0, 0, 0, 795, 6982, 1, 0, 0, 0, 797, 6994, 1, + 0, 0, 0, 799, 7002, 1, 0, 0, 0, 801, 7016, 1, 0, 0, 0, 803, 7025, 1, 0, + 0, 0, 805, 7044, 1, 0, 0, 0, 807, 7052, 1, 0, 0, 0, 809, 7063, 1, 0, 0, + 0, 811, 7098, 1, 0, 0, 0, 813, 7105, 1, 0, 0, 0, 815, 7108, 1, 0, 0, 0, + 817, 7113, 1, 0, 0, 0, 819, 7122, 1, 0, 0, 0, 821, 7128, 1, 0, 0, 0, 823, + 7137, 1, 0, 0, 0, 825, 7143, 1, 0, 0, 0, 827, 7152, 1, 0, 0, 0, 829, 7164, + 1, 0, 0, 0, 831, 7183, 1, 0, 0, 0, 833, 7188, 1, 0, 0, 0, 835, 7193, 1, + 0, 0, 0, 837, 7200, 1, 0, 0, 0, 839, 7213, 1, 0, 0, 0, 841, 7231, 1, 0, + 0, 0, 843, 7238, 1, 0, 0, 0, 845, 7257, 1, 0, 0, 0, 847, 7278, 1, 0, 0, + 0, 849, 7283, 1, 0, 0, 0, 851, 7290, 1, 0, 0, 0, 853, 7302, 1, 0, 0, 0, + 855, 7307, 1, 0, 0, 0, 857, 7316, 1, 0, 0, 0, 859, 7338, 1, 0, 0, 0, 861, + 7346, 1, 0, 0, 0, 863, 7356, 1, 0, 0, 0, 865, 7362, 1, 0, 0, 0, 867, 7371, + 1, 0, 0, 0, 869, 7383, 1, 0, 0, 0, 871, 7399, 1, 0, 0, 0, 873, 7414, 1, + 0, 0, 0, 875, 7428, 1, 0, 0, 0, 877, 7439, 1, 0, 0, 0, 879, 7450, 1, 0, + 0, 0, 881, 7453, 1, 0, 0, 0, 883, 7472, 1, 0, 0, 0, 885, 7487, 1, 0, 0, + 0, 887, 7525, 1, 0, 0, 0, 889, 7555, 1, 0, 0, 0, 891, 7571, 1, 0, 0, 0, + 893, 7575, 1, 0, 0, 0, 895, 7585, 1, 0, 0, 0, 897, 7597, 1, 0, 0, 0, 899, + 7619, 1, 0, 0, 0, 901, 7630, 1, 0, 0, 0, 903, 7633, 1, 0, 0, 0, 905, 7641, + 1, 0, 0, 0, 907, 7661, 1, 0, 0, 0, 909, 7671, 1, 0, 0, 0, 911, 7683, 1, + 0, 0, 0, 913, 7689, 1, 0, 0, 0, 915, 7707, 1, 0, 0, 0, 917, 7721, 1, 0, + 0, 0, 919, 7731, 1, 0, 0, 0, 921, 7740, 1, 0, 0, 0, 923, 7745, 1, 0, 0, + 0, 925, 7755, 1, 0, 0, 0, 927, 7761, 1, 0, 0, 0, 929, 7767, 1, 0, 0, 0, + 931, 7779, 1, 0, 0, 0, 933, 7786, 1, 0, 0, 0, 935, 7795, 1, 0, 0, 0, 937, + 7803, 1, 0, 0, 0, 939, 7807, 1, 0, 0, 0, 941, 7817, 1, 0, 0, 0, 943, 7822, + 1, 0, 0, 0, 945, 7825, 1, 0, 0, 0, 947, 7828, 1, 0, 0, 0, 949, 7831, 1, + 0, 0, 0, 951, 7846, 1, 0, 0, 0, 953, 7853, 1, 0, 0, 0, 955, 7860, 1, 0, + 0, 0, 957, 7870, 1, 0, 0, 0, 959, 7880, 1, 0, 0, 0, 961, 7890, 1, 0, 0, + 0, 963, 7904, 1, 0, 0, 0, 965, 7921, 1, 0, 0, 0, 967, 7925, 1, 0, 0, 0, + 969, 7930, 1, 0, 0, 0, 971, 7935, 1, 0, 0, 0, 973, 7946, 1, 0, 0, 0, 975, + 7958, 1, 0, 0, 0, 977, 7970, 1, 0, 0, 0, 979, 7987, 1, 0, 0, 0, 981, 7998, + 1, 0, 0, 0, 983, 8009, 1, 0, 0, 0, 985, 8012, 1, 0, 0, 0, 987, 8017, 1, + 0, 0, 0, 989, 8030, 1, 0, 0, 0, 991, 8040, 1, 0, 0, 0, 993, 8053, 1, 0, + 0, 0, 995, 8062, 1, 0, 0, 0, 997, 8066, 1, 0, 0, 0, 999, 8071, 1, 0, 0, + 0, 1001, 8078, 1, 0, 0, 0, 1003, 8087, 1, 0, 0, 0, 1005, 8098, 1, 0, 0, + 0, 1007, 8122, 1, 0, 0, 0, 1009, 8127, 1, 0, 0, 0, 1011, 8131, 1, 0, 0, + 0, 1013, 8140, 1, 0, 0, 0, 1015, 8145, 1, 0, 0, 0, 1017, 8156, 1, 0, 0, + 0, 1019, 8161, 1, 0, 0, 0, 1021, 8167, 1, 0, 0, 0, 1023, 8172, 1, 0, 0, + 0, 1025, 8176, 1, 0, 0, 0, 1027, 8182, 1, 0, 0, 0, 1029, 8190, 1, 0, 0, + 0, 1031, 8198, 1, 0, 0, 0, 1033, 8206, 1, 0, 0, 0, 1035, 8214, 1, 0, 0, + 0, 1037, 8222, 1, 0, 0, 0, 1039, 8231, 1, 0, 0, 0, 1041, 8236, 1, 0, 0, + 0, 1043, 8243, 1, 0, 0, 0, 1045, 8250, 1, 0, 0, 0, 1047, 8256, 1, 0, 0, + 0, 1049, 8261, 1, 0, 0, 0, 1051, 8270, 1, 0, 0, 0, 1053, 8282, 1, 0, 0, + 0, 1055, 8296, 1, 0, 0, 0, 1057, 8309, 1, 0, 0, 0, 1059, 8314, 1, 0, 0, + 0, 1061, 8329, 1, 0, 0, 0, 1063, 8335, 1, 0, 0, 0, 1065, 8354, 1, 0, 0, + 0, 1067, 8363, 1, 0, 0, 0, 1069, 8368, 1, 0, 0, 0, 1071, 8384, 1, 0, 0, + 0, 1073, 8388, 1, 0, 0, 0, 1075, 8394, 1, 0, 0, 0, 1077, 8408, 1, 0, 0, + 0, 1079, 8413, 1, 0, 0, 0, 1081, 8417, 1, 0, 0, 0, 1083, 8423, 1, 0, 0, + 0, 1085, 8429, 1, 0, 0, 0, 1087, 8436, 1, 0, 0, 0, 1089, 8441, 1, 0, 0, + 0, 1091, 8446, 1, 0, 0, 0, 1093, 8453, 1, 0, 0, 0, 1095, 8460, 1, 0, 0, + 0, 1097, 8468, 1, 0, 0, 0, 1099, 8481, 1, 0, 0, 0, 1101, 8485, 1, 0, 0, + 0, 1103, 8492, 1, 0, 0, 0, 1105, 8505, 1, 0, 0, 0, 1107, 8513, 1, 0, 0, + 0, 1109, 8525, 1, 0, 0, 0, 1111, 8534, 1, 0, 0, 0, 1113, 8550, 1, 0, 0, + 0, 1115, 8571, 1, 0, 0, 0, 1117, 8579, 1, 0, 0, 0, 1119, 8592, 1, 0, 0, + 0, 1121, 8607, 1, 0, 0, 0, 1123, 8617, 1, 0, 0, 0, 1125, 8637, 1, 0, 0, + 0, 1127, 8648, 1, 0, 0, 0, 1129, 8667, 1, 0, 0, 0, 1131, 8697, 1, 0, 0, + 0, 1133, 8711, 1, 0, 0, 0, 1135, 8729, 1, 0, 0, 0, 1137, 8748, 1, 0, 0, + 0, 1139, 8757, 1, 0, 0, 0, 1141, 8760, 1, 0, 0, 0, 1143, 8777, 1, 0, 0, + 0, 1145, 8787, 1, 0, 0, 0, 1147, 8794, 1, 0, 0, 0, 1149, 8801, 1, 0, 0, + 0, 1151, 8823, 1, 0, 0, 0, 1153, 8845, 1, 0, 0, 0, 1155, 8851, 1, 0, 0, + 0, 1157, 8859, 1, 0, 0, 0, 1159, 8878, 1, 0, 0, 0, 1161, 8899, 1, 0, 0, + 0, 1163, 8903, 1, 0, 0, 0, 1165, 8911, 1, 0, 0, 0, 1167, 8920, 1, 0, 0, + 0, 1169, 8942, 1, 0, 0, 0, 1171, 8958, 1, 0, 0, 0, 1173, 8978, 1, 0, 0, + 0, 1175, 8997, 1, 0, 0, 0, 1177, 9004, 1, 0, 0, 0, 1179, 9019, 1, 0, 0, + 0, 1181, 9041, 1, 0, 0, 0, 1183, 9046, 1, 0, 0, 0, 1185, 9053, 1, 0, 0, + 0, 1187, 9062, 1, 0, 0, 0, 1189, 9067, 1, 0, 0, 0, 1191, 9078, 1, 0, 0, + 0, 1193, 9090, 1, 0, 0, 0, 1195, 9095, 1, 0, 0, 0, 1197, 9104, 1, 0, 0, + 0, 1199, 9110, 1, 0, 0, 0, 1201, 9120, 1, 0, 0, 0, 1203, 9136, 1, 0, 0, + 0, 1205, 9142, 1, 0, 0, 0, 1207, 9150, 1, 0, 0, 0, 1209, 9166, 1, 0, 0, + 0, 1211, 9178, 1, 0, 0, 0, 1213, 9189, 1, 0, 0, 0, 1215, 9202, 1, 0, 0, + 0, 1217, 9207, 1, 0, 0, 0, 1219, 9210, 1, 0, 0, 0, 1221, 9218, 1, 0, 0, + 0, 1223, 9226, 1, 0, 0, 0, 1225, 9232, 1, 0, 0, 0, 1227, 9239, 1, 0, 0, + 0, 1229, 9248, 1, 0, 0, 0, 1231, 9257, 1, 0, 0, 0, 1233, 9268, 1, 0, 0, + 0, 1235, 9276, 1, 0, 0, 0, 1237, 9283, 1, 0, 0, 0, 1239, 9290, 1, 0, 0, + 0, 1241, 9303, 1, 0, 0, 0, 1243, 9308, 1, 0, 0, 0, 1245, 9330, 1, 0, 0, + 0, 1247, 9342, 1, 0, 0, 0, 1249, 9353, 1, 0, 0, 0, 1251, 9362, 1, 0, 0, + 0, 1253, 9369, 1, 0, 0, 0, 1255, 9373, 1, 0, 0, 0, 1257, 9386, 1, 0, 0, + 0, 1259, 9400, 1, 0, 0, 0, 1261, 9409, 1, 0, 0, 0, 1263, 9416, 1, 0, 0, + 0, 1265, 9428, 1, 0, 0, 0, 1267, 9443, 1, 0, 0, 0, 1269, 9457, 1, 0, 0, + 0, 1271, 9469, 1, 0, 0, 0, 1273, 9483, 1, 0, 0, 0, 1275, 9497, 1, 0, 0, + 0, 1277, 9509, 1, 0, 0, 0, 1279, 9517, 1, 0, 0, 0, 1281, 9523, 1, 0, 0, + 0, 1283, 9528, 1, 0, 0, 0, 1285, 9535, 1, 0, 0, 0, 1287, 9540, 1, 0, 0, + 0, 1289, 9548, 1, 0, 0, 0, 1291, 9557, 1, 0, 0, 0, 1293, 9564, 1, 0, 0, + 0, 1295, 9583, 1, 0, 0, 0, 1297, 9590, 1, 0, 0, 0, 1299, 9605, 1, 0, 0, + 0, 1301, 9622, 1, 0, 0, 0, 1303, 9640, 1, 0, 0, 0, 1305, 9650, 1, 0, 0, + 0, 1307, 9662, 1, 0, 0, 0, 1309, 9681, 1, 0, 0, 0, 1311, 9684, 1, 0, 0, + 0, 1313, 9688, 1, 0, 0, 0, 1315, 9696, 1, 0, 0, 0, 1317, 9703, 1, 0, 0, + 0, 1319, 9711, 1, 0, 0, 0, 1321, 9723, 1, 0, 0, 0, 1323, 9736, 1, 0, 0, + 0, 1325, 9739, 1, 0, 0, 0, 1327, 9746, 1, 0, 0, 0, 1329, 9751, 1, 0, 0, + 0, 1331, 9762, 1, 0, 0, 0, 1333, 9767, 1, 0, 0, 0, 1335, 9782, 1, 0, 0, + 0, 1337, 9791, 1, 0, 0, 0, 1339, 9801, 1, 0, 0, 0, 1341, 9812, 1, 0, 0, + 0, 1343, 9820, 1, 0, 0, 0, 1345, 9834, 1, 0, 0, 0, 1347, 9845, 1, 0, 0, + 0, 1349, 9856, 1, 0, 0, 0, 1351, 9865, 1, 0, 0, 0, 1353, 9893, 1, 0, 0, + 0, 1355, 9900, 1, 0, 0, 0, 1357, 9903, 1, 0, 0, 0, 1359, 9909, 1, 0, 0, + 0, 1361, 9926, 1, 0, 0, 0, 1363, 9941, 1, 0, 0, 0, 1365, 9945, 1, 0, 0, + 0, 1367, 9951, 1, 0, 0, 0, 1369, 9958, 1, 0, 0, 0, 1371, 9963, 1, 0, 0, + 0, 1373, 9972, 1, 0, 0, 0, 1375, 9978, 1, 0, 0, 0, 1377, 9988, 1, 0, 0, + 0, 1379, 9998, 1, 0, 0, 0, 1381, 10003, 1, 0, 0, 0, 1383, 10013, 1, 0, + 0, 0, 1385, 10025, 1, 0, 0, 0, 1387, 10033, 1, 0, 0, 0, 1389, 10050, 1, + 0, 0, 0, 1391, 10065, 1, 0, 0, 0, 1393, 10073, 1, 0, 0, 0, 1395, 10083, + 1, 0, 0, 0, 1397, 10093, 1, 0, 0, 0, 1399, 10101, 1, 0, 0, 0, 1401, 10111, + 1, 0, 0, 0, 1403, 10122, 1, 0, 0, 0, 1405, 10130, 1, 0, 0, 0, 1407, 10139, + 1, 0, 0, 0, 1409, 10144, 1, 0, 0, 0, 1411, 10153, 1, 0, 0, 0, 1413, 10159, + 1, 0, 0, 0, 1415, 10177, 1, 0, 0, 0, 1417, 10185, 1, 0, 0, 0, 1419, 10201, + 1, 0, 0, 0, 1421, 10217, 1, 0, 0, 0, 1423, 10230, 1, 0, 0, 0, 1425, 10242, + 1, 0, 0, 0, 1427, 10257, 1, 0, 0, 0, 1429, 10267, 1, 0, 0, 0, 1431, 10290, + 1, 0, 0, 0, 1433, 10298, 1, 0, 0, 0, 1435, 10305, 1, 0, 0, 0, 1437, 10314, + 1, 0, 0, 0, 1439, 10328, 1, 0, 0, 0, 1441, 10334, 1, 0, 0, 0, 1443, 10339, + 1, 0, 0, 0, 1445, 10348, 1, 0, 0, 0, 1447, 10372, 1, 0, 0, 0, 1449, 10379, + 1, 0, 0, 0, 1451, 10384, 1, 0, 0, 0, 1453, 10389, 1, 0, 0, 0, 1455, 10399, + 1, 0, 0, 0, 1457, 10409, 1, 0, 0, 0, 1459, 10419, 1, 0, 0, 0, 1461, 10427, + 1, 0, 0, 0, 1463, 10440, 1, 0, 0, 0, 1465, 10446, 1, 0, 0, 0, 1467, 10452, + 1, 0, 0, 0, 1469, 10461, 1, 0, 0, 0, 1471, 10476, 1, 0, 0, 0, 1473, 10484, + 1, 0, 0, 0, 1475, 10496, 1, 0, 0, 0, 1477, 10507, 1, 0, 0, 0, 1479, 10512, + 1, 0, 0, 0, 1481, 10522, 1, 0, 0, 0, 1483, 10532, 1, 0, 0, 0, 1485, 10547, + 1, 0, 0, 0, 1487, 10555, 1, 0, 0, 0, 1489, 10563, 1, 0, 0, 0, 1491, 10572, + 1, 0, 0, 0, 1493, 10581, 1, 0, 0, 0, 1495, 10599, 1, 0, 0, 0, 1497, 10606, + 1, 0, 0, 0, 1499, 10617, 1, 0, 0, 0, 1501, 10628, 1, 0, 0, 0, 1503, 10635, + 1, 0, 0, 0, 1505, 10641, 1, 0, 0, 0, 1507, 10649, 1, 0, 0, 0, 1509, 10655, + 1, 0, 0, 0, 1511, 10667, 1, 0, 0, 0, 1513, 10685, 1, 0, 0, 0, 1515, 10695, + 1, 0, 0, 0, 1517, 10697, 1, 0, 0, 0, 1519, 10707, 1, 0, 0, 0, 1521, 10718, + 1, 0, 0, 0, 1523, 10724, 1, 0, 0, 0, 1525, 10729, 1, 0, 0, 0, 1527, 10733, + 1, 0, 0, 0, 1529, 10737, 1, 0, 0, 0, 1531, 10741, 1, 0, 0, 0, 1533, 10749, + 1, 0, 0, 0, 1535, 10754, 1, 0, 0, 0, 1537, 10768, 1, 0, 0, 0, 1539, 10786, + 1, 0, 0, 0, 1541, 10795, 1, 0, 0, 0, 1543, 10804, 1, 0, 0, 0, 1545, 10813, + 1, 0, 0, 0, 1547, 10829, 1, 0, 0, 0, 1549, 10839, 1, 0, 0, 0, 1551, 10863, + 1, 0, 0, 0, 1553, 10873, 1, 0, 0, 0, 1555, 10896, 1, 0, 0, 0, 1557, 10907, + 1, 0, 0, 0, 1559, 10929, 1, 0, 0, 0, 1561, 10937, 1, 0, 0, 0, 1563, 10945, + 1, 0, 0, 0, 1565, 10955, 1, 0, 0, 0, 1567, 10967, 1, 0, 0, 0, 1569, 10976, + 1, 0, 0, 0, 1571, 10995, 1, 0, 0, 0, 1573, 11006, 1, 0, 0, 0, 1575, 11017, + 1, 0, 0, 0, 1577, 11038, 1, 0, 0, 0, 1579, 11065, 1, 0, 0, 0, 1581, 11074, + 1, 0, 0, 0, 1583, 11081, 1, 0, 0, 0, 1585, 11106, 1, 0, 0, 0, 1587, 11126, + 1, 0, 0, 0, 1589, 11133, 1, 0, 0, 0, 1591, 11144, 1, 0, 0, 0, 1593, 11167, + 1, 0, 0, 0, 1595, 11179, 1, 0, 0, 0, 1597, 11194, 1, 0, 0, 0, 1599, 11205, + 1, 0, 0, 0, 1601, 11220, 1, 0, 0, 0, 1603, 11228, 1, 0, 0, 0, 1605, 11236, + 1, 0, 0, 0, 1607, 11246, 1, 0, 0, 0, 1609, 11258, 1, 0, 0, 0, 1611, 11283, + 1, 0, 0, 0, 1613, 11316, 1, 0, 0, 0, 1615, 11349, 1, 0, 0, 0, 1617, 11358, + 1, 0, 0, 0, 1619, 11402, 1, 0, 0, 0, 1621, 11411, 1, 0, 0, 0, 1623, 11430, + 1, 0, 0, 0, 1625, 11436, 1, 0, 0, 0, 1627, 11445, 1, 0, 0, 0, 1629, 11455, + 1, 0, 0, 0, 1631, 11481, 1, 0, 0, 0, 1633, 11489, 1, 0, 0, 0, 1635, 11497, + 1, 0, 0, 0, 1637, 11506, 1, 0, 0, 0, 1639, 11522, 1, 0, 0, 0, 1641, 11532, + 1, 0, 0, 0, 1643, 11539, 1, 0, 0, 0, 1645, 11550, 1, 0, 0, 0, 1647, 11560, + 1, 0, 0, 0, 1649, 11567, 1, 0, 0, 0, 1651, 11575, 1, 0, 0, 0, 1653, 11583, + 1, 0, 0, 0, 1655, 11590, 1, 0, 0, 0, 1657, 11597, 1, 0, 0, 0, 1659, 11604, + 1, 0, 0, 0, 1661, 11610, 1, 0, 0, 0, 1663, 11617, 1, 0, 0, 0, 1665, 11622, + 1, 0, 0, 0, 1667, 11631, 1, 0, 0, 0, 1669, 11636, 1, 0, 0, 0, 1671, 11648, + 1, 0, 0, 0, 1673, 11654, 1, 0, 0, 0, 1675, 11658, 1, 0, 0, 0, 1677, 11667, + 1, 0, 0, 0, 1679, 11680, 1, 0, 0, 0, 1681, 11688, 1, 0, 0, 0, 1683, 11699, + 1, 0, 0, 0, 1685, 11707, 1, 0, 0, 0, 1687, 11712, 1, 0, 0, 0, 1689, 11723, + 1, 0, 0, 0, 1691, 11732, 1, 0, 0, 0, 1693, 11741, 1, 0, 0, 0, 1695, 11750, + 1, 0, 0, 0, 1697, 11759, 1, 0, 0, 0, 1699, 11767, 1, 0, 0, 0, 1701, 11773, + 1, 0, 0, 0, 1703, 11778, 1, 0, 0, 0, 1705, 11783, 1, 0, 0, 0, 1707, 11790, + 1, 0, 0, 0, 1709, 11797, 1, 0, 0, 0, 1711, 11802, 1, 0, 0, 0, 1713, 11812, + 1, 0, 0, 0, 1715, 11819, 1, 0, 0, 0, 1717, 11833, 1, 0, 0, 0, 1719, 11843, + 1, 0, 0, 0, 1721, 11855, 1, 0, 0, 0, 1723, 11862, 1, 0, 0, 0, 1725, 11869, + 1, 0, 0, 0, 1727, 11884, 1, 0, 0, 0, 1729, 11891, 1, 0, 0, 0, 1731, 11898, + 1, 0, 0, 0, 1733, 11911, 1, 0, 0, 0, 1735, 11918, 1, 0, 0, 0, 1737, 11928, + 1, 0, 0, 0, 1739, 11943, 1, 0, 0, 0, 1741, 11958, 1, 0, 0, 0, 1743, 11966, + 1, 0, 0, 0, 1745, 11973, 1, 0, 0, 0, 1747, 11984, 1, 0, 0, 0, 1749, 11993, + 1, 0, 0, 0, 1751, 12007, 1, 0, 0, 0, 1753, 12020, 1, 0, 0, 0, 1755, 12033, + 1, 0, 0, 0, 1757, 12040, 1, 0, 0, 0, 1759, 12045, 1, 0, 0, 0, 1761, 12068, + 1, 0, 0, 0, 1763, 12099, 1, 0, 0, 0, 1765, 12123, 1, 0, 0, 0, 1767, 12138, + 1, 0, 0, 0, 1769, 12143, 1, 0, 0, 0, 1771, 12148, 1, 0, 0, 0, 1773, 12157, + 1, 0, 0, 0, 1775, 12173, 1, 0, 0, 0, 1777, 12186, 1, 0, 0, 0, 1779, 12193, + 1, 0, 0, 0, 1781, 12208, 1, 0, 0, 0, 1783, 12216, 1, 0, 0, 0, 1785, 12230, + 1, 0, 0, 0, 1787, 12245, 1, 0, 0, 0, 1789, 12258, 1, 0, 0, 0, 1791, 12266, + 1, 0, 0, 0, 1793, 12282, 1, 0, 0, 0, 1795, 12298, 1, 0, 0, 0, 1797, 12314, + 1, 0, 0, 0, 1799, 12327, 1, 0, 0, 0, 1801, 12331, 1, 0, 0, 0, 1803, 12340, + 1, 0, 0, 0, 1805, 12345, 1, 0, 0, 0, 1807, 12354, 1, 0, 0, 0, 1809, 12362, + 1, 0, 0, 0, 1811, 12368, 1, 0, 0, 0, 1813, 12375, 1, 0, 0, 0, 1815, 12386, + 1, 0, 0, 0, 1817, 12395, 1, 0, 0, 0, 1819, 12408, 1, 0, 0, 0, 1821, 12422, + 1, 0, 0, 0, 1823, 12435, 1, 0, 0, 0, 1825, 12445, 1, 0, 0, 0, 1827, 12454, + 1, 0, 0, 0, 1829, 12458, 1, 0, 0, 0, 1831, 12468, 1, 0, 0, 0, 1833, 12475, + 1, 0, 0, 0, 1835, 12487, 1, 0, 0, 0, 1837, 12492, 1, 0, 0, 0, 1839, 12497, + 1, 0, 0, 0, 1841, 12506, 1, 0, 0, 0, 1843, 12515, 1, 0, 0, 0, 1845, 12524, + 1, 0, 0, 0, 1847, 12529, 1, 0, 0, 0, 1849, 12544, 1, 0, 0, 0, 1851, 12552, + 1, 0, 0, 0, 1853, 12559, 1, 0, 0, 0, 1855, 12565, 1, 0, 0, 0, 1857, 12572, + 1, 0, 0, 0, 1859, 12580, 1, 0, 0, 0, 1861, 12605, 1, 0, 0, 0, 1863, 12619, + 1, 0, 0, 0, 1865, 12625, 1, 0, 0, 0, 1867, 12629, 1, 0, 0, 0, 1869, 12644, + 1, 0, 0, 0, 1871, 12658, 1, 0, 0, 0, 1873, 12675, 1, 0, 0, 0, 1875, 12696, + 1, 0, 0, 0, 1877, 12704, 1, 0, 0, 0, 1879, 12710, 1, 0, 0, 0, 1881, 12718, + 1, 0, 0, 0, 1883, 12732, 1, 0, 0, 0, 1885, 12743, 1, 0, 0, 0, 1887, 12749, + 1, 0, 0, 0, 1889, 12756, 1, 0, 0, 0, 1891, 12767, 1, 0, 0, 0, 1893, 12790, + 1, 0, 0, 0, 1895, 12813, 1, 0, 0, 0, 1897, 12819, 1, 0, 0, 0, 1899, 12830, + 1, 0, 0, 0, 1901, 12843, 1, 0, 0, 0, 1903, 12850, 1, 0, 0, 0, 1905, 12861, + 1, 0, 0, 0, 1907, 12867, 1, 0, 0, 0, 1909, 12874, 1, 0, 0, 0, 1911, 12879, + 1, 0, 0, 0, 1913, 12888, 1, 0, 0, 0, 1915, 12896, 1, 0, 0, 0, 1917, 12910, + 1, 0, 0, 0, 1919, 12914, 1, 0, 0, 0, 1921, 12925, 1, 0, 0, 0, 1923, 12939, + 1, 0, 0, 0, 1925, 12945, 1, 0, 0, 0, 1927, 12953, 1, 0, 0, 0, 1929, 12963, + 1, 0, 0, 0, 1931, 12976, 1, 0, 0, 0, 1933, 12986, 1, 0, 0, 0, 1935, 12990, + 1, 0, 0, 0, 1937, 13000, 1, 0, 0, 0, 1939, 13009, 1, 0, 0, 0, 1941, 13020, + 1, 0, 0, 0, 1943, 13030, 1, 0, 0, 0, 1945, 13042, 1, 0, 0, 0, 1947, 13050, + 1, 0, 0, 0, 1949, 13057, 1, 0, 0, 0, 1951, 13067, 1, 0, 0, 0, 1953, 13086, + 1, 0, 0, 0, 1955, 13094, 1, 0, 0, 0, 1957, 13101, 1, 0, 0, 0, 1959, 13113, + 1, 0, 0, 0, 1961, 13119, 1, 0, 0, 0, 1963, 13132, 1, 0, 0, 0, 1965, 13144, + 1, 0, 0, 0, 1967, 13152, 1, 0, 0, 0, 1969, 13161, 1, 0, 0, 0, 1971, 13166, + 1, 0, 0, 0, 1973, 13171, 1, 0, 0, 0, 1975, 13178, 1, 0, 0, 0, 1977, 13199, + 1, 0, 0, 0, 1979, 13202, 1, 0, 0, 0, 1981, 13206, 1, 0, 0, 0, 1983, 13219, + 1, 0, 0, 0, 1985, 13228, 1, 0, 0, 0, 1987, 13233, 1, 0, 0, 0, 1989, 13239, + 1, 0, 0, 0, 1991, 13244, 1, 0, 0, 0, 1993, 13249, 1, 0, 0, 0, 1995, 13257, + 1, 0, 0, 0, 1997, 13263, 1, 0, 0, 0, 1999, 13271, 1, 0, 0, 0, 2001, 13274, + 1, 0, 0, 0, 2003, 13278, 1, 0, 0, 0, 2005, 13298, 1, 0, 0, 0, 2007, 13307, + 1, 0, 0, 0, 2009, 13313, 1, 0, 0, 0, 2011, 13322, 1, 0, 0, 0, 2013, 13338, + 1, 0, 0, 0, 2015, 13343, 1, 0, 0, 0, 2017, 13355, 1, 0, 0, 0, 2019, 13370, + 1, 0, 0, 0, 2021, 13379, 1, 0, 0, 0, 2023, 13401, 1, 0, 0, 0, 2025, 13411, + 1, 0, 0, 0, 2027, 13419, 1, 0, 0, 0, 2029, 13424, 1, 0, 0, 0, 2031, 13435, + 1, 0, 0, 0, 2033, 13451, 1, 0, 0, 0, 2035, 13460, 1, 0, 0, 0, 2037, 13472, + 1, 0, 0, 0, 2039, 13476, 1, 0, 0, 0, 2041, 13485, 1, 0, 0, 0, 2043, 13493, + 1, 0, 0, 0, 2045, 13498, 1, 0, 0, 0, 2047, 13520, 1, 0, 0, 0, 2049, 13525, + 1, 0, 0, 0, 2051, 13538, 1, 0, 0, 0, 2053, 13546, 1, 0, 0, 0, 2055, 13556, + 1, 0, 0, 0, 2057, 13569, 1, 0, 0, 0, 2059, 13579, 1, 0, 0, 0, 2061, 13589, + 1, 0, 0, 0, 2063, 13601, 1, 0, 0, 0, 2065, 13609, 1, 0, 0, 0, 2067, 13615, + 1, 0, 0, 0, 2069, 13622, 1, 0, 0, 0, 2071, 13630, 1, 0, 0, 0, 2073, 13640, + 1, 0, 0, 0, 2075, 13647, 1, 0, 0, 0, 2077, 13654, 1, 0, 0, 0, 2079, 13662, + 1, 0, 0, 0, 2081, 13669, 1, 0, 0, 0, 2083, 13673, 1, 0, 0, 0, 2085, 13680, + 1, 0, 0, 0, 2087, 13691, 1, 0, 0, 0, 2089, 13699, 1, 0, 0, 0, 2091, 13705, + 1, 0, 0, 0, 2093, 13709, 1, 0, 0, 0, 2095, 13713, 1, 0, 0, 0, 2097, 13718, + 1, 0, 0, 0, 2099, 13723, 1, 0, 0, 0, 2101, 13731, 1, 0, 0, 0, 2103, 13741, + 1, 0, 0, 0, 2105, 13747, 1, 0, 0, 0, 2107, 13758, 1, 0, 0, 0, 2109, 13768, + 1, 0, 0, 0, 2111, 13774, 1, 0, 0, 0, 2113, 13781, 1, 0, 0, 0, 2115, 13789, + 1, 0, 0, 0, 2117, 13793, 1, 0, 0, 0, 2119, 13803, 1, 0, 0, 0, 2121, 13808, + 1, 0, 0, 0, 2123, 13816, 1, 0, 0, 0, 2125, 13831, 1, 0, 0, 0, 2127, 13846, + 1, 0, 0, 0, 2129, 13854, 1, 0, 0, 0, 2131, 13859, 1, 0, 0, 0, 2133, 13865, + 1, 0, 0, 0, 2135, 13879, 1, 0, 0, 0, 2137, 13890, 1, 0, 0, 0, 2139, 13895, + 1, 0, 0, 0, 2141, 13903, 1, 0, 0, 0, 2143, 13924, 1, 0, 0, 0, 2145, 13940, + 1, 0, 0, 0, 2147, 13945, 1, 0, 0, 0, 2149, 13951, 1, 0, 0, 0, 2151, 13957, + 1, 0, 0, 0, 2153, 13965, 1, 0, 0, 0, 2155, 13970, 1, 0, 0, 0, 2157, 13977, + 1, 0, 0, 0, 2159, 13985, 1, 0, 0, 0, 2161, 14007, 1, 0, 0, 0, 2163, 14015, + 1, 0, 0, 0, 2165, 14020, 1, 0, 0, 0, 2167, 14029, 1, 0, 0, 0, 2169, 14039, + 1, 0, 0, 0, 2171, 14050, 1, 0, 0, 0, 2173, 14061, 1, 0, 0, 0, 2175, 14067, + 1, 0, 0, 0, 2177, 14071, 1, 0, 0, 0, 2179, 14079, 1, 0, 0, 0, 2181, 14093, + 1, 0, 0, 0, 2183, 14103, 1, 0, 0, 0, 2185, 14119, 1, 0, 0, 0, 2187, 14126, + 1, 0, 0, 0, 2189, 14131, 1, 0, 0, 0, 2191, 14135, 1, 0, 0, 0, 2193, 14140, + 1, 0, 0, 0, 2195, 14145, 1, 0, 0, 0, 2197, 14150, 1, 0, 0, 0, 2199, 14155, + 1, 0, 0, 0, 2201, 14163, 1, 0, 0, 0, 2203, 14167, 1, 0, 0, 0, 2205, 14171, + 1, 0, 0, 0, 2207, 14179, 1, 0, 0, 0, 2209, 14183, 1, 0, 0, 0, 2211, 14189, + 1, 0, 0, 0, 2213, 14195, 1, 0, 0, 0, 2215, 14198, 1, 0, 0, 0, 2217, 14204, + 1, 0, 0, 0, 2219, 14212, 1, 0, 0, 0, 2221, 14217, 1, 0, 0, 0, 2223, 14223, + 1, 0, 0, 0, 2225, 14228, 1, 0, 0, 0, 2227, 14232, 1, 0, 0, 0, 2229, 14237, + 1, 0, 0, 0, 2231, 14244, 1, 0, 0, 0, 2233, 14248, 1, 0, 0, 0, 2235, 14265, + 1, 0, 0, 0, 2237, 14285, 1, 0, 0, 0, 2239, 14297, 1, 0, 0, 0, 2241, 14310, + 1, 0, 0, 0, 2243, 14324, 1, 0, 0, 0, 2245, 14343, 1, 0, 0, 0, 2247, 14361, + 1, 0, 0, 0, 2249, 14385, 1, 0, 0, 0, 2251, 14395, 1, 0, 0, 0, 2253, 14399, + 1, 0, 0, 0, 2255, 14407, 1, 0, 0, 0, 2257, 14414, 1, 0, 0, 0, 2259, 14420, + 1, 0, 0, 0, 2261, 14443, 1, 0, 0, 0, 2263, 14456, 1, 0, 0, 0, 2265, 14468, + 1, 0, 0, 0, 2267, 14486, 1, 0, 0, 0, 2269, 14501, 1, 0, 0, 0, 2271, 14515, + 1, 0, 0, 0, 2273, 14532, 1, 0, 0, 0, 2275, 14537, 1, 0, 0, 0, 2277, 14545, + 1, 0, 0, 0, 2279, 14555, 1, 0, 0, 0, 2281, 14560, 1, 0, 0, 0, 2283, 14565, + 1, 0, 0, 0, 2285, 14572, 1, 0, 0, 0, 2287, 14579, 1, 0, 0, 0, 2289, 14591, + 1, 0, 0, 0, 2291, 14603, 1, 0, 0, 0, 2293, 14614, 1, 0, 0, 0, 2295, 14623, + 1, 0, 0, 0, 2297, 14632, 1, 0, 0, 0, 2299, 14646, 1, 0, 0, 0, 2301, 14651, + 1, 0, 0, 0, 2303, 14656, 1, 0, 0, 0, 2305, 14661, 1, 0, 0, 0, 2307, 14666, + 1, 0, 0, 0, 2309, 14672, 1, 0, 0, 0, 2311, 14674, 1, 0, 0, 0, 2313, 14680, + 1, 0, 0, 0, 2315, 14685, 1, 0, 0, 0, 2317, 14687, 1, 0, 0, 0, 2319, 14690, + 1, 0, 0, 0, 2321, 14694, 1, 0, 0, 0, 2323, 14697, 1, 0, 0, 0, 2325, 14710, + 1, 0, 0, 0, 2327, 14712, 1, 0, 0, 0, 2329, 14715, 1, 0, 0, 0, 2331, 14729, + 1, 0, 0, 0, 2333, 14737, 1, 0, 0, 0, 2335, 14746, 1, 0, 0, 0, 2337, 14749, + 1, 0, 0, 0, 2339, 14757, 1, 0, 0, 0, 2341, 14771, 1, 0, 0, 0, 2343, 14787, + 1, 0, 0, 0, 2345, 14809, 1, 0, 0, 0, 2347, 14813, 1, 0, 0, 0, 2349, 14828, + 1, 0, 0, 0, 2351, 14839, 1, 0, 0, 0, 2353, 14847, 1, 0, 0, 0, 2355, 14850, + 1, 0, 0, 0, 2357, 14852, 1, 0, 0, 0, 2359, 14863, 1, 0, 0, 0, 2361, 14871, + 1, 0, 0, 0, 2363, 14880, 1, 0, 0, 0, 2365, 14886, 1, 0, 0, 0, 2367, 14896, + 1, 0, 0, 0, 2369, 14909, 1, 0, 0, 0, 2371, 14917, 1, 0, 0, 0, 2373, 14921, + 1, 0, 0, 0, 2375, 14932, 1, 0, 0, 0, 2377, 14934, 1, 0, 0, 0, 2379, 14936, + 1, 0, 0, 0, 2381, 14938, 1, 0, 0, 0, 2383, 14940, 1, 0, 0, 0, 2385, 14943, + 1, 0, 0, 0, 2387, 14946, 1, 0, 0, 0, 2389, 14949, 1, 0, 0, 0, 2391, 14952, + 1, 0, 0, 0, 2393, 14955, 1, 0, 0, 0, 2395, 14958, 1, 0, 0, 0, 2397, 14961, + 1, 0, 0, 0, 2399, 14964, 1, 0, 0, 0, 2401, 14967, 1, 0, 0, 0, 2403, 14969, + 1, 0, 0, 0, 2405, 14971, 1, 0, 0, 0, 2407, 14973, 1, 0, 0, 0, 2409, 14975, + 1, 0, 0, 0, 2411, 14977, 1, 0, 0, 0, 2413, 14979, 1, 0, 0, 0, 2415, 14981, + 1, 0, 0, 0, 2417, 14983, 1, 0, 0, 0, 2419, 14985, 1, 0, 0, 0, 2421, 14987, + 1, 0, 0, 0, 2423, 14990, 1, 0, 0, 0, 2425, 14992, 1, 0, 0, 0, 2427, 14994, + 1, 0, 0, 0, 2429, 14996, 1, 0, 0, 0, 2431, 14998, 1, 0, 0, 0, 2433, 15000, + 1, 0, 0, 0, 2435, 15002, 1, 0, 0, 0, 2437, 15004, 1, 0, 0, 0, 2439, 15006, + 1, 0, 0, 0, 2441, 15008, 1, 0, 0, 0, 2443, 15010, 1, 0, 0, 0, 2445, 15036, + 1, 0, 0, 0, 2447, 15038, 1, 0, 0, 0, 2449, 15040, 1, 0, 0, 0, 2451, 15042, + 1, 0, 0, 0, 2453, 2454, 7, 0, 0, 0, 2454, 2455, 7, 1, 0, 0, 2455, 2456, + 7, 2, 0, 0, 2456, 2457, 7, 3, 0, 0, 2457, 2458, 7, 4, 0, 0, 2458, 2, 1, + 0, 0, 0, 2459, 2460, 7, 0, 0, 0, 2460, 2461, 7, 1, 0, 0, 2461, 2462, 7, + 2, 0, 0, 2462, 2463, 7, 3, 0, 0, 2463, 2464, 7, 4, 0, 0, 2464, 2465, 5, + 95, 0, 0, 2465, 2466, 7, 0, 0, 0, 2466, 2467, 7, 5, 0, 0, 2467, 2468, 7, + 4, 0, 0, 2468, 2469, 7, 6, 0, 0, 2469, 2470, 7, 3, 0, 0, 2470, 2471, 5, + 95, 0, 0, 2471, 2472, 7, 7, 0, 0, 2472, 2473, 7, 0, 0, 0, 2473, 2474, 7, + 8, 0, 0, 2474, 2475, 7, 4, 0, 0, 2475, 4, 1, 0, 0, 0, 2476, 2477, 7, 0, + 0, 0, 2477, 2478, 7, 1, 0, 0, 2478, 2479, 7, 9, 0, 0, 2479, 2480, 7, 6, + 0, 0, 2480, 2481, 7, 10, 0, 0, 2481, 2482, 7, 4, 0, 0, 2482, 6, 1, 0, 0, + 0, 2483, 2484, 7, 0, 0, 0, 2484, 2485, 7, 1, 0, 0, 2485, 2486, 7, 9, 0, + 0, 2486, 2487, 7, 2, 0, 0, 2487, 2488, 7, 11, 0, 0, 2488, 2489, 7, 12, + 0, 0, 2489, 2490, 7, 4, 0, 0, 2490, 2491, 7, 6, 0, 0, 2491, 8, 1, 0, 0, + 0, 2492, 2493, 7, 0, 0, 0, 2493, 2494, 7, 13, 0, 0, 2494, 2495, 7, 13, + 0, 0, 2495, 2496, 7, 6, 0, 0, 2496, 2497, 7, 11, 0, 0, 2497, 2498, 7, 6, + 0, 0, 2498, 2499, 7, 3, 0, 0, 2499, 2500, 7, 0, 0, 0, 2500, 2501, 7, 4, + 0, 0, 2501, 2502, 7, 6, 0, 0, 2502, 2503, 7, 14, 0, 0, 2503, 2504, 5, 95, + 0, 0, 2504, 2505, 7, 14, 0, 0, 2505, 2506, 7, 0, 0, 0, 2506, 2507, 7, 4, + 0, 0, 2507, 2508, 7, 0, 0, 0, 2508, 2509, 7, 1, 0, 0, 2509, 2510, 7, 0, + 0, 0, 2510, 2511, 7, 9, 0, 0, 2511, 2512, 7, 6, 0, 0, 2512, 2513, 5, 95, + 0, 0, 2513, 2514, 7, 3, 0, 0, 2514, 2515, 7, 6, 0, 0, 2515, 2516, 7, 13, + 0, 0, 2516, 2517, 7, 2, 0, 0, 2517, 2518, 7, 15, 0, 0, 2518, 2519, 7, 6, + 0, 0, 2519, 2520, 7, 3, 0, 0, 2520, 2521, 7, 16, 0, 0, 2521, 10, 1, 0, + 0, 0, 2522, 2523, 7, 0, 0, 0, 2523, 2524, 7, 13, 0, 0, 2524, 2525, 7, 13, + 0, 0, 2525, 2526, 7, 6, 0, 0, 2526, 2527, 7, 10, 0, 0, 2527, 2528, 7, 4, + 0, 0, 2528, 2529, 5, 95, 0, 0, 2529, 2530, 7, 9, 0, 0, 2530, 2531, 7, 6, + 0, 0, 2531, 2532, 7, 10, 0, 0, 2532, 2533, 7, 9, 0, 0, 2533, 2534, 7, 8, + 0, 0, 2534, 2535, 7, 4, 0, 0, 2535, 2536, 7, 8, 0, 0, 2536, 2537, 7, 15, + 0, 0, 2537, 2538, 7, 8, 0, 0, 2538, 2539, 7, 4, 0, 0, 2539, 2540, 7, 16, + 0, 0, 2540, 12, 1, 0, 0, 0, 2541, 2542, 7, 0, 0, 0, 2542, 2543, 7, 13, + 0, 0, 2543, 2544, 7, 13, 0, 0, 2544, 2545, 7, 6, 0, 0, 2545, 2546, 7, 9, + 0, 0, 2546, 2547, 7, 9, 0, 0, 2547, 14, 1, 0, 0, 0, 2548, 2549, 7, 0, 0, + 0, 2549, 2550, 7, 13, 0, 0, 2550, 2551, 7, 4, 0, 0, 2551, 2552, 7, 8, 0, + 0, 2552, 2553, 7, 2, 0, 0, 2553, 2554, 7, 10, 0, 0, 2554, 16, 1, 0, 0, + 0, 2555, 2556, 7, 0, 0, 0, 2556, 2557, 7, 13, 0, 0, 2557, 2558, 7, 4, 0, + 0, 2558, 2559, 7, 8, 0, 0, 2559, 2560, 7, 15, 0, 0, 2560, 2561, 7, 0, 0, + 0, 2561, 2562, 7, 4, 0, 0, 2562, 2563, 7, 8, 0, 0, 2563, 2564, 7, 2, 0, + 0, 2564, 2565, 7, 10, 0, 0, 2565, 18, 1, 0, 0, 0, 2566, 2567, 7, 0, 0, + 0, 2567, 2568, 7, 13, 0, 0, 2568, 2569, 7, 4, 0, 0, 2569, 2570, 7, 8, 0, + 0, 2570, 2571, 7, 15, 0, 0, 2571, 2572, 7, 6, 0, 0, 2572, 20, 1, 0, 0, + 0, 2573, 2574, 7, 0, 0, 0, 2574, 2575, 7, 14, 0, 0, 2575, 2576, 7, 14, + 0, 0, 2576, 22, 1, 0, 0, 0, 2577, 2578, 7, 0, 0, 0, 2578, 2579, 7, 14, + 0, 0, 2579, 2580, 7, 14, 0, 0, 2580, 2581, 7, 3, 0, 0, 2581, 2582, 7, 6, + 0, 0, 2582, 2583, 7, 9, 0, 0, 2583, 2584, 7, 9, 0, 0, 2584, 24, 1, 0, 0, + 0, 2585, 2586, 7, 0, 0, 0, 2586, 2587, 7, 14, 0, 0, 2587, 2588, 7, 17, + 0, 0, 2588, 2589, 7, 8, 0, 0, 2589, 2590, 7, 10, 0, 0, 2590, 2591, 7, 8, + 0, 0, 2591, 2592, 7, 9, 0, 0, 2592, 2593, 7, 4, 0, 0, 2593, 2594, 7, 6, + 0, 0, 2594, 2595, 7, 3, 0, 0, 2595, 26, 1, 0, 0, 0, 2596, 2597, 7, 0, 0, + 0, 2597, 2598, 7, 6, 0, 0, 2598, 2599, 7, 9, 0, 0, 2599, 28, 1, 0, 0, 0, + 2600, 2601, 7, 0, 0, 0, 2601, 2602, 7, 6, 0, 0, 2602, 2603, 7, 9, 0, 0, + 2603, 2604, 5, 95, 0, 0, 2604, 2605, 5, 49, 0, 0, 2605, 2606, 5, 50, 0, + 0, 2606, 2607, 5, 56, 0, 0, 2607, 30, 1, 0, 0, 0, 2608, 2609, 7, 0, 0, + 0, 2609, 2610, 7, 6, 0, 0, 2610, 2611, 7, 9, 0, 0, 2611, 2612, 5, 95, 0, + 0, 2612, 2613, 5, 49, 0, 0, 2613, 2614, 5, 57, 0, 0, 2614, 2615, 5, 50, + 0, 0, 2615, 32, 1, 0, 0, 0, 2616, 2617, 7, 0, 0, 0, 2617, 2618, 7, 6, 0, + 0, 2618, 2619, 7, 9, 0, 0, 2619, 2620, 5, 95, 0, 0, 2620, 2621, 5, 50, + 0, 0, 2621, 2622, 5, 53, 0, 0, 2622, 2623, 5, 54, 0, 0, 2623, 34, 1, 0, + 0, 0, 2624, 2625, 7, 0, 0, 0, 2625, 2626, 7, 5, 0, 0, 2626, 2627, 7, 5, + 0, 0, 2627, 2628, 7, 8, 0, 0, 2628, 2629, 7, 10, 0, 0, 2629, 2630, 7, 8, + 0, 0, 2630, 2631, 7, 4, 0, 0, 2631, 2632, 7, 16, 0, 0, 2632, 36, 1, 0, + 0, 0, 2633, 2634, 7, 0, 0, 0, 2634, 2635, 7, 5, 0, 0, 2635, 2636, 7, 4, + 0, 0, 2636, 2637, 7, 6, 0, 0, 2637, 2638, 7, 3, 0, 0, 2638, 38, 1, 0, 0, + 0, 2639, 2640, 7, 0, 0, 0, 2640, 2641, 7, 18, 0, 0, 2641, 2642, 7, 18, + 0, 0, 2642, 2643, 7, 3, 0, 0, 2643, 2644, 7, 6, 0, 0, 2644, 2645, 7, 18, + 0, 0, 2645, 2646, 7, 0, 0, 0, 2646, 2647, 7, 4, 0, 0, 2647, 2648, 7, 6, + 0, 0, 2648, 40, 1, 0, 0, 0, 2649, 2650, 7, 0, 0, 0, 2650, 2651, 7, 11, + 0, 0, 2651, 2652, 7, 18, 0, 0, 2652, 2653, 7, 2, 0, 0, 2653, 2654, 7, 3, + 0, 0, 2654, 2655, 7, 8, 0, 0, 2655, 2656, 7, 4, 0, 0, 2656, 2657, 7, 19, + 0, 0, 2657, 2658, 7, 17, 0, 0, 2658, 42, 1, 0, 0, 0, 2659, 2660, 7, 0, + 0, 0, 2660, 2661, 7, 11, 0, 0, 2661, 2662, 7, 11, 0, 0, 2662, 44, 1, 0, + 0, 0, 2663, 2664, 7, 0, 0, 0, 2664, 2665, 7, 11, 0, 0, 2665, 2666, 7, 11, + 0, 0, 2666, 2667, 7, 2, 0, 0, 2667, 2668, 7, 7, 0, 0, 2668, 2669, 7, 6, + 0, 0, 2669, 2670, 7, 14, 0, 0, 2670, 46, 1, 0, 0, 0, 2671, 2672, 7, 0, + 0, 0, 2672, 2673, 7, 11, 0, 0, 2673, 2674, 7, 11, 0, 0, 2674, 2675, 7, + 2, 0, 0, 2675, 2676, 7, 7, 0, 0, 2676, 2677, 5, 95, 0, 0, 2677, 2678, 7, + 13, 0, 0, 2678, 2679, 7, 2, 0, 0, 2679, 2680, 7, 10, 0, 0, 2680, 2681, + 7, 10, 0, 0, 2681, 2682, 7, 6, 0, 0, 2682, 2683, 7, 13, 0, 0, 2683, 2684, + 7, 4, 0, 0, 2684, 2685, 7, 8, 0, 0, 2685, 2686, 7, 2, 0, 0, 2686, 2687, + 7, 10, 0, 0, 2687, 2688, 7, 9, 0, 0, 2688, 48, 1, 0, 0, 0, 2689, 2690, + 7, 0, 0, 0, 2690, 2691, 7, 11, 0, 0, 2691, 2692, 7, 11, 0, 0, 2692, 2693, + 7, 2, 0, 0, 2693, 2694, 7, 7, 0, 0, 2694, 2695, 5, 95, 0, 0, 2695, 2696, + 7, 6, 0, 0, 2696, 2697, 7, 10, 0, 0, 2697, 2698, 7, 13, 0, 0, 2698, 2699, + 7, 3, 0, 0, 2699, 2700, 7, 16, 0, 0, 2700, 2701, 7, 20, 0, 0, 2701, 2702, + 7, 4, 0, 0, 2702, 2703, 7, 6, 0, 0, 2703, 2704, 7, 14, 0, 0, 2704, 2705, + 5, 95, 0, 0, 2705, 2706, 7, 15, 0, 0, 2706, 2707, 7, 0, 0, 0, 2707, 2708, + 7, 11, 0, 0, 2708, 2709, 7, 12, 0, 0, 2709, 2710, 7, 6, 0, 0, 2710, 2711, + 5, 95, 0, 0, 2711, 2712, 7, 17, 0, 0, 2712, 2713, 7, 2, 0, 0, 2713, 2714, + 7, 14, 0, 0, 2714, 2715, 7, 8, 0, 0, 2715, 2716, 7, 5, 0, 0, 2716, 2717, + 7, 8, 0, 0, 2717, 2718, 7, 13, 0, 0, 2718, 2719, 7, 0, 0, 0, 2719, 2720, + 7, 4, 0, 0, 2720, 2721, 7, 8, 0, 0, 2721, 2722, 7, 2, 0, 0, 2722, 2723, + 7, 10, 0, 0, 2723, 2724, 7, 9, 0, 0, 2724, 50, 1, 0, 0, 0, 2725, 2726, + 7, 0, 0, 0, 2726, 2727, 7, 11, 0, 0, 2727, 2728, 7, 11, 0, 0, 2728, 2729, + 7, 2, 0, 0, 2729, 2730, 7, 7, 0, 0, 2730, 2731, 5, 95, 0, 0, 2731, 2732, + 7, 17, 0, 0, 2732, 2733, 7, 12, 0, 0, 2733, 2734, 7, 11, 0, 0, 2734, 2735, + 7, 4, 0, 0, 2735, 2736, 7, 8, 0, 0, 2736, 2737, 7, 20, 0, 0, 2737, 2738, + 7, 11, 0, 0, 2738, 2739, 7, 6, 0, 0, 2739, 2740, 5, 95, 0, 0, 2740, 2741, + 7, 6, 0, 0, 2741, 2742, 7, 15, 0, 0, 2742, 2743, 7, 6, 0, 0, 2743, 2744, + 7, 10, 0, 0, 2744, 2745, 7, 4, 0, 0, 2745, 2746, 5, 95, 0, 0, 2746, 2747, + 7, 11, 0, 0, 2747, 2748, 7, 2, 0, 0, 2748, 2749, 7, 9, 0, 0, 2749, 2750, + 7, 9, 0, 0, 2750, 52, 1, 0, 0, 0, 2751, 2752, 7, 0, 0, 0, 2752, 2753, 7, + 11, 0, 0, 2753, 2754, 7, 11, 0, 0, 2754, 2755, 7, 2, 0, 0, 2755, 2756, + 7, 7, 0, 0, 2756, 2757, 5, 95, 0, 0, 2757, 2758, 7, 20, 0, 0, 2758, 2759, + 7, 0, 0, 0, 2759, 2760, 7, 18, 0, 0, 2760, 2761, 7, 6, 0, 0, 2761, 2762, + 5, 95, 0, 0, 2762, 2763, 7, 11, 0, 0, 2763, 2764, 7, 2, 0, 0, 2764, 2765, + 7, 13, 0, 0, 2765, 2766, 7, 21, 0, 0, 2766, 2767, 7, 9, 0, 0, 2767, 54, + 1, 0, 0, 0, 2768, 2769, 7, 0, 0, 0, 2769, 2770, 7, 11, 0, 0, 2770, 2771, + 7, 11, 0, 0, 2771, 2772, 7, 2, 0, 0, 2772, 2773, 7, 7, 0, 0, 2773, 2774, + 5, 95, 0, 0, 2774, 2775, 7, 3, 0, 0, 2775, 2776, 7, 2, 0, 0, 2776, 2777, + 7, 7, 0, 0, 2777, 2778, 5, 95, 0, 0, 2778, 2779, 7, 11, 0, 0, 2779, 2780, + 7, 2, 0, 0, 2780, 2781, 7, 13, 0, 0, 2781, 2782, 7, 21, 0, 0, 2782, 2783, + 7, 9, 0, 0, 2783, 56, 1, 0, 0, 0, 2784, 2785, 7, 0, 0, 0, 2785, 2786, 7, + 11, 0, 0, 2786, 2787, 7, 11, 0, 0, 2787, 2788, 7, 2, 0, 0, 2788, 2789, + 7, 7, 0, 0, 2789, 2790, 5, 95, 0, 0, 2790, 2791, 7, 9, 0, 0, 2791, 2792, + 7, 8, 0, 0, 2792, 2793, 7, 10, 0, 0, 2793, 2794, 7, 18, 0, 0, 2794, 2795, + 7, 11, 0, 0, 2795, 2796, 7, 6, 0, 0, 2796, 2797, 5, 95, 0, 0, 2797, 2798, + 7, 6, 0, 0, 2798, 2799, 7, 15, 0, 0, 2799, 2800, 7, 6, 0, 0, 2800, 2801, + 7, 10, 0, 0, 2801, 2802, 7, 4, 0, 0, 2802, 2803, 5, 95, 0, 0, 2803, 2804, + 7, 11, 0, 0, 2804, 2805, 7, 2, 0, 0, 2805, 2806, 7, 9, 0, 0, 2806, 2807, + 7, 9, 0, 0, 2807, 58, 1, 0, 0, 0, 2808, 2809, 7, 0, 0, 0, 2809, 2810, 7, + 11, 0, 0, 2810, 2811, 7, 11, 0, 0, 2811, 2812, 7, 2, 0, 0, 2812, 2813, + 7, 7, 0, 0, 2813, 2814, 5, 95, 0, 0, 2814, 2815, 7, 9, 0, 0, 2815, 2816, + 7, 10, 0, 0, 2816, 2817, 7, 0, 0, 0, 2817, 2818, 7, 20, 0, 0, 2818, 2819, + 7, 9, 0, 0, 2819, 2820, 7, 19, 0, 0, 2820, 2821, 7, 2, 0, 0, 2821, 2822, + 7, 4, 0, 0, 2822, 2823, 5, 95, 0, 0, 2823, 2824, 7, 8, 0, 0, 2824, 2825, + 7, 9, 0, 0, 2825, 2826, 7, 2, 0, 0, 2826, 2827, 7, 11, 0, 0, 2827, 2828, + 7, 0, 0, 0, 2828, 2829, 7, 4, 0, 0, 2829, 2830, 7, 8, 0, 0, 2830, 2831, + 7, 2, 0, 0, 2831, 2832, 7, 10, 0, 0, 2832, 60, 1, 0, 0, 0, 2833, 2834, + 7, 0, 0, 0, 2834, 2835, 7, 11, 0, 0, 2835, 2836, 7, 11, 0, 0, 2836, 2837, + 5, 95, 0, 0, 2837, 2838, 7, 13, 0, 0, 2838, 2839, 7, 2, 0, 0, 2839, 2840, + 7, 10, 0, 0, 2840, 2841, 7, 9, 0, 0, 2841, 2842, 7, 4, 0, 0, 2842, 2843, + 7, 3, 0, 0, 2843, 2844, 7, 0, 0, 0, 2844, 2845, 7, 8, 0, 0, 2845, 2846, + 7, 10, 0, 0, 2846, 2847, 7, 4, 0, 0, 2847, 2848, 7, 9, 0, 0, 2848, 62, + 1, 0, 0, 0, 2849, 2850, 7, 0, 0, 0, 2850, 2851, 7, 11, 0, 0, 2851, 2852, + 7, 11, 0, 0, 2852, 2853, 5, 95, 0, 0, 2853, 2854, 7, 6, 0, 0, 2854, 2855, + 7, 3, 0, 0, 2855, 2856, 7, 3, 0, 0, 2856, 2857, 7, 2, 0, 0, 2857, 2858, + 7, 3, 0, 0, 2858, 2859, 7, 17, 0, 0, 2859, 2860, 7, 9, 0, 0, 2860, 2861, + 7, 18, 0, 0, 2861, 2862, 7, 9, 0, 0, 2862, 64, 1, 0, 0, 0, 2863, 2864, + 7, 0, 0, 0, 2864, 2865, 7, 11, 0, 0, 2865, 2866, 7, 11, 0, 0, 2866, 2867, + 5, 95, 0, 0, 2867, 2868, 7, 8, 0, 0, 2868, 2869, 7, 10, 0, 0, 2869, 2870, + 7, 14, 0, 0, 2870, 2871, 7, 6, 0, 0, 2871, 2872, 7, 22, 0, 0, 2872, 2873, + 7, 6, 0, 0, 2873, 2874, 7, 9, 0, 0, 2874, 66, 1, 0, 0, 0, 2875, 2876, 7, + 0, 0, 0, 2876, 2877, 7, 11, 0, 0, 2877, 2878, 7, 11, 0, 0, 2878, 2879, + 5, 95, 0, 0, 2879, 2880, 7, 11, 0, 0, 2880, 2881, 7, 6, 0, 0, 2881, 2882, + 7, 15, 0, 0, 2882, 2883, 7, 6, 0, 0, 2883, 2884, 7, 11, 0, 0, 2884, 2885, + 7, 9, 0, 0, 2885, 68, 1, 0, 0, 0, 2886, 2887, 7, 0, 0, 0, 2887, 2888, 7, + 11, 0, 0, 2888, 2889, 7, 4, 0, 0, 2889, 2890, 7, 6, 0, 0, 2890, 2891, 7, + 3, 0, 0, 2891, 70, 1, 0, 0, 0, 2892, 2893, 7, 0, 0, 0, 2893, 2894, 7, 11, + 0, 0, 2894, 2895, 7, 7, 0, 0, 2895, 2896, 7, 0, 0, 0, 2896, 2897, 7, 16, + 0, 0, 2897, 2898, 7, 9, 0, 0, 2898, 72, 1, 0, 0, 0, 2899, 2900, 7, 0, 0, + 0, 2900, 2901, 7, 10, 0, 0, 2901, 2902, 7, 14, 0, 0, 2902, 74, 1, 0, 0, + 0, 2903, 2904, 7, 0, 0, 0, 2904, 2905, 7, 10, 0, 0, 2905, 2906, 7, 2, 0, + 0, 2906, 2907, 7, 10, 0, 0, 2907, 2908, 7, 16, 0, 0, 2908, 2909, 7, 17, + 0, 0, 2909, 2910, 7, 2, 0, 0, 2910, 2911, 7, 12, 0, 0, 2911, 2912, 7, 9, + 0, 0, 2912, 76, 1, 0, 0, 0, 2913, 2914, 7, 0, 0, 0, 2914, 2915, 7, 10, + 0, 0, 2915, 2916, 7, 9, 0, 0, 2916, 2917, 7, 8, 0, 0, 2917, 2918, 5, 95, + 0, 0, 2918, 2919, 7, 14, 0, 0, 2919, 2920, 7, 6, 0, 0, 2920, 2921, 7, 5, + 0, 0, 2921, 2922, 7, 0, 0, 0, 2922, 2923, 7, 12, 0, 0, 2923, 2924, 7, 11, + 0, 0, 2924, 2925, 7, 4, 0, 0, 2925, 2926, 7, 9, 0, 0, 2926, 78, 1, 0, 0, + 0, 2927, 2928, 7, 0, 0, 0, 2928, 2929, 7, 10, 0, 0, 2929, 2930, 7, 9, 0, + 0, 2930, 2931, 7, 8, 0, 0, 2931, 2932, 5, 95, 0, 0, 2932, 2933, 7, 10, + 0, 0, 2933, 2934, 7, 12, 0, 0, 2934, 2935, 7, 11, 0, 0, 2935, 2936, 7, + 11, 0, 0, 2936, 2937, 7, 9, 0, 0, 2937, 80, 1, 0, 0, 0, 2938, 2939, 7, + 0, 0, 0, 2939, 2940, 7, 10, 0, 0, 2940, 2941, 7, 9, 0, 0, 2941, 2942, 7, + 8, 0, 0, 2942, 2943, 5, 95, 0, 0, 2943, 2944, 7, 10, 0, 0, 2944, 2945, + 7, 12, 0, 0, 2945, 2946, 7, 11, 0, 0, 2946, 2947, 7, 11, 0, 0, 2947, 2948, + 5, 95, 0, 0, 2948, 2949, 7, 14, 0, 0, 2949, 2950, 7, 6, 0, 0, 2950, 2951, + 7, 5, 0, 0, 2951, 2952, 7, 0, 0, 0, 2952, 2953, 7, 12, 0, 0, 2953, 2954, + 7, 11, 0, 0, 2954, 2955, 7, 4, 0, 0, 2955, 82, 1, 0, 0, 0, 2956, 2957, + 7, 0, 0, 0, 2957, 2958, 7, 10, 0, 0, 2958, 2959, 7, 9, 0, 0, 2959, 2960, + 7, 8, 0, 0, 2960, 2961, 5, 95, 0, 0, 2961, 2962, 7, 10, 0, 0, 2962, 2963, + 7, 12, 0, 0, 2963, 2964, 7, 11, 0, 0, 2964, 2965, 7, 11, 0, 0, 2965, 2966, + 5, 95, 0, 0, 2966, 2967, 7, 14, 0, 0, 2967, 2968, 7, 5, 0, 0, 2968, 2969, + 7, 11, 0, 0, 2969, 2970, 7, 4, 0, 0, 2970, 2971, 5, 95, 0, 0, 2971, 2972, + 7, 2, 0, 0, 2972, 2973, 7, 5, 0, 0, 2973, 2974, 7, 5, 0, 0, 2974, 84, 1, + 0, 0, 0, 2975, 2976, 7, 0, 0, 0, 2976, 2977, 7, 10, 0, 0, 2977, 2978, 7, + 9, 0, 0, 2978, 2979, 7, 8, 0, 0, 2979, 2980, 5, 95, 0, 0, 2980, 2981, 7, + 10, 0, 0, 2981, 2982, 7, 12, 0, 0, 2982, 2983, 7, 11, 0, 0, 2983, 2984, + 7, 11, 0, 0, 2984, 2985, 5, 95, 0, 0, 2985, 2986, 7, 14, 0, 0, 2986, 2987, + 7, 5, 0, 0, 2987, 2988, 7, 11, 0, 0, 2988, 2989, 7, 4, 0, 0, 2989, 2990, + 5, 95, 0, 0, 2990, 2991, 7, 2, 0, 0, 2991, 2992, 7, 10, 0, 0, 2992, 86, + 1, 0, 0, 0, 2993, 2994, 7, 0, 0, 0, 2994, 2995, 7, 10, 0, 0, 2995, 2996, + 7, 9, 0, 0, 2996, 2997, 7, 8, 0, 0, 2997, 2998, 5, 95, 0, 0, 2998, 2999, + 7, 20, 0, 0, 2999, 3000, 7, 0, 0, 0, 3000, 3001, 7, 14, 0, 0, 3001, 3002, + 7, 14, 0, 0, 3002, 3003, 7, 8, 0, 0, 3003, 3004, 7, 10, 0, 0, 3004, 3005, + 7, 18, 0, 0, 3005, 88, 1, 0, 0, 0, 3006, 3007, 7, 0, 0, 0, 3007, 3008, + 7, 10, 0, 0, 3008, 3009, 7, 9, 0, 0, 3009, 3010, 7, 8, 0, 0, 3010, 3011, + 5, 95, 0, 0, 3011, 3012, 7, 7, 0, 0, 3012, 3013, 7, 0, 0, 0, 3013, 3014, + 7, 3, 0, 0, 3014, 3015, 7, 10, 0, 0, 3015, 3016, 7, 8, 0, 0, 3016, 3017, + 7, 10, 0, 0, 3017, 3018, 7, 18, 0, 0, 3018, 3019, 7, 9, 0, 0, 3019, 90, + 1, 0, 0, 0, 3020, 3021, 7, 0, 0, 0, 3021, 3022, 7, 10, 0, 0, 3022, 3023, + 7, 16, 0, 0, 3023, 92, 1, 0, 0, 0, 3024, 3025, 7, 0, 0, 0, 3025, 3026, + 7, 20, 0, 0, 3026, 3027, 7, 20, 0, 0, 3027, 3028, 7, 6, 0, 0, 3028, 3029, + 7, 10, 0, 0, 3029, 3030, 7, 14, 0, 0, 3030, 94, 1, 0, 0, 0, 3031, 3032, + 7, 0, 0, 0, 3032, 3033, 7, 20, 0, 0, 3033, 3034, 7, 20, 0, 0, 3034, 3035, + 7, 11, 0, 0, 3035, 3036, 7, 8, 0, 0, 3036, 3037, 7, 13, 0, 0, 3037, 3038, + 7, 0, 0, 0, 3038, 3039, 7, 4, 0, 0, 3039, 3040, 7, 8, 0, 0, 3040, 3041, + 7, 2, 0, 0, 3041, 3042, 7, 10, 0, 0, 3042, 96, 1, 0, 0, 0, 3043, 3044, + 7, 0, 0, 0, 3044, 3045, 7, 20, 0, 0, 3045, 3046, 7, 20, 0, 0, 3046, 3047, + 7, 11, 0, 0, 3047, 3048, 7, 8, 0, 0, 3048, 3049, 7, 13, 0, 0, 3049, 3050, + 7, 0, 0, 0, 3050, 3051, 7, 4, 0, 0, 3051, 3052, 7, 8, 0, 0, 3052, 3053, + 7, 2, 0, 0, 3053, 3054, 7, 10, 0, 0, 3054, 3055, 5, 95, 0, 0, 3055, 3056, + 7, 11, 0, 0, 3056, 3057, 7, 2, 0, 0, 3057, 3058, 7, 18, 0, 0, 3058, 98, + 1, 0, 0, 0, 3059, 3060, 7, 0, 0, 0, 3060, 3061, 7, 20, 0, 0, 3061, 3062, + 7, 20, 0, 0, 3062, 3063, 7, 11, 0, 0, 3063, 3064, 7, 2, 0, 0, 3064, 3065, + 7, 13, 0, 0, 3065, 3066, 7, 21, 0, 0, 3066, 3067, 5, 95, 0, 0, 3067, 3068, + 7, 17, 0, 0, 3068, 3069, 7, 2, 0, 0, 3069, 3070, 7, 14, 0, 0, 3070, 3071, + 7, 6, 0, 0, 3071, 100, 1, 0, 0, 0, 3072, 3073, 7, 0, 0, 0, 3073, 3074, + 7, 20, 0, 0, 3074, 3075, 7, 20, 0, 0, 3075, 3076, 7, 11, 0, 0, 3076, 3077, + 7, 2, 0, 0, 3077, 3078, 7, 13, 0, 0, 3078, 3079, 7, 21, 0, 0, 3079, 3080, + 5, 95, 0, 0, 3080, 3081, 7, 4, 0, 0, 3081, 3082, 7, 6, 0, 0, 3082, 3083, + 7, 9, 0, 0, 3083, 3084, 7, 4, 0, 0, 3084, 102, 1, 0, 0, 0, 3085, 3086, + 7, 0, 0, 0, 3086, 3087, 7, 20, 0, 0, 3087, 3088, 7, 20, 0, 0, 3088, 3089, + 7, 11, 0, 0, 3089, 3090, 7, 16, 0, 0, 3090, 104, 1, 0, 0, 0, 3091, 3092, + 7, 0, 0, 0, 3092, 3093, 7, 20, 0, 0, 3093, 3094, 7, 20, 0, 0, 3094, 3095, + 5, 95, 0, 0, 3095, 3096, 7, 10, 0, 0, 3096, 3097, 7, 0, 0, 0, 3097, 3098, + 7, 17, 0, 0, 3098, 3099, 7, 6, 0, 0, 3099, 106, 1, 0, 0, 0, 3100, 3101, + 7, 0, 0, 0, 3101, 3102, 7, 3, 0, 0, 3102, 3103, 7, 8, 0, 0, 3103, 3104, + 7, 4, 0, 0, 3104, 3105, 7, 19, 0, 0, 3105, 3106, 7, 0, 0, 0, 3106, 3107, + 7, 1, 0, 0, 3107, 3108, 7, 2, 0, 0, 3108, 3109, 7, 3, 0, 0, 3109, 3110, + 7, 4, 0, 0, 3110, 108, 1, 0, 0, 0, 3111, 3112, 7, 0, 0, 0, 3112, 3113, + 7, 3, 0, 0, 3113, 3114, 7, 8, 0, 0, 3114, 3115, 7, 4, 0, 0, 3115, 3116, + 7, 19, 0, 0, 3116, 3117, 7, 8, 0, 0, 3117, 3118, 7, 18, 0, 0, 3118, 3119, + 7, 10, 0, 0, 3119, 3120, 7, 2, 0, 0, 3120, 3121, 7, 3, 0, 0, 3121, 3122, + 7, 6, 0, 0, 3122, 110, 1, 0, 0, 0, 3123, 3124, 7, 0, 0, 0, 3124, 3125, + 7, 9, 0, 0, 3125, 112, 1, 0, 0, 0, 3126, 3127, 7, 0, 0, 0, 3127, 3128, + 7, 9, 0, 0, 3128, 3129, 7, 13, 0, 0, 3129, 114, 1, 0, 0, 0, 3130, 3131, + 7, 0, 0, 0, 3131, 3132, 7, 9, 0, 0, 3132, 3133, 7, 13, 0, 0, 3133, 3134, + 7, 8, 0, 0, 3134, 3135, 7, 8, 0, 0, 3135, 116, 1, 0, 0, 0, 3136, 3137, + 7, 0, 0, 0, 3137, 3138, 7, 9, 0, 0, 3138, 3139, 7, 9, 0, 0, 3139, 3140, + 7, 6, 0, 0, 3140, 3141, 7, 17, 0, 0, 3141, 3142, 7, 1, 0, 0, 3142, 3143, + 7, 11, 0, 0, 3143, 3144, 7, 16, 0, 0, 3144, 118, 1, 0, 0, 0, 3145, 3146, + 7, 0, 0, 0, 3146, 3147, 7, 9, 0, 0, 3147, 3148, 7, 9, 0, 0, 3148, 3149, + 7, 6, 0, 0, 3149, 3150, 7, 17, 0, 0, 3150, 3151, 7, 1, 0, 0, 3151, 3152, + 7, 11, 0, 0, 3152, 3153, 7, 16, 0, 0, 3153, 3154, 7, 20, 0, 0, 3154, 3155, + 7, 3, 0, 0, 3155, 3156, 7, 2, 0, 0, 3156, 3157, 7, 20, 0, 0, 3157, 3158, + 7, 6, 0, 0, 3158, 3159, 7, 3, 0, 0, 3159, 3160, 7, 4, 0, 0, 3160, 3161, + 7, 16, 0, 0, 3161, 120, 1, 0, 0, 0, 3162, 3163, 7, 0, 0, 0, 3163, 3164, + 7, 9, 0, 0, 3164, 3165, 7, 16, 0, 0, 3165, 3166, 7, 17, 0, 0, 3166, 3167, + 7, 17, 0, 0, 3167, 3168, 7, 6, 0, 0, 3168, 3169, 7, 4, 0, 0, 3169, 3170, + 7, 3, 0, 0, 3170, 3171, 7, 8, 0, 0, 3171, 3172, 7, 13, 0, 0, 3172, 122, + 1, 0, 0, 0, 3173, 3174, 7, 0, 0, 0, 3174, 3175, 7, 9, 0, 0, 3175, 3176, + 7, 16, 0, 0, 3176, 3177, 7, 10, 0, 0, 3177, 3178, 7, 13, 0, 0, 3178, 3179, + 7, 19, 0, 0, 3179, 3180, 7, 3, 0, 0, 3180, 3181, 7, 2, 0, 0, 3181, 3182, + 7, 10, 0, 0, 3182, 3183, 7, 2, 0, 0, 3183, 3184, 7, 12, 0, 0, 3184, 3185, + 7, 9, 0, 0, 3185, 3186, 5, 95, 0, 0, 3186, 3187, 7, 13, 0, 0, 3187, 3188, + 7, 2, 0, 0, 3188, 3189, 7, 17, 0, 0, 3189, 3190, 7, 17, 0, 0, 3190, 3191, + 7, 8, 0, 0, 3191, 3192, 7, 4, 0, 0, 3192, 124, 1, 0, 0, 0, 3193, 3194, + 7, 0, 0, 0, 3194, 3195, 7, 4, 0, 0, 3195, 126, 1, 0, 0, 0, 3196, 3197, + 7, 0, 0, 0, 3197, 3198, 7, 12, 0, 0, 3198, 3199, 7, 14, 0, 0, 3199, 3200, + 7, 8, 0, 0, 3200, 3201, 7, 4, 0, 0, 3201, 128, 1, 0, 0, 0, 3202, 3203, + 7, 0, 0, 0, 3203, 3204, 7, 12, 0, 0, 3204, 3205, 7, 14, 0, 0, 3205, 3206, + 7, 8, 0, 0, 3206, 3207, 7, 4, 0, 0, 3207, 3208, 5, 95, 0, 0, 3208, 3209, + 7, 18, 0, 0, 3209, 3210, 7, 12, 0, 0, 3210, 3211, 7, 8, 0, 0, 3211, 3212, + 7, 14, 0, 0, 3212, 130, 1, 0, 0, 0, 3213, 3214, 7, 0, 0, 0, 3214, 3215, + 7, 12, 0, 0, 3215, 3216, 7, 4, 0, 0, 3216, 3217, 7, 19, 0, 0, 3217, 3218, + 7, 6, 0, 0, 3218, 3219, 7, 10, 0, 0, 3219, 3220, 7, 4, 0, 0, 3220, 3221, + 7, 8, 0, 0, 3221, 3222, 7, 13, 0, 0, 3222, 3223, 7, 0, 0, 0, 3223, 3224, + 7, 4, 0, 0, 3224, 3225, 7, 6, 0, 0, 3225, 132, 1, 0, 0, 0, 3226, 3227, + 7, 0, 0, 0, 3227, 3228, 7, 12, 0, 0, 3228, 3229, 7, 4, 0, 0, 3229, 3230, + 7, 19, 0, 0, 3230, 3231, 7, 6, 0, 0, 3231, 3232, 7, 10, 0, 0, 3232, 3233, + 7, 4, 0, 0, 3233, 3234, 7, 8, 0, 0, 3234, 3235, 7, 13, 0, 0, 3235, 3236, + 7, 0, 0, 0, 3236, 3237, 7, 4, 0, 0, 3237, 3238, 7, 8, 0, 0, 3238, 3239, + 7, 2, 0, 0, 3239, 3240, 7, 10, 0, 0, 3240, 134, 1, 0, 0, 0, 3241, 3242, + 7, 0, 0, 0, 3242, 3243, 7, 12, 0, 0, 3243, 3244, 7, 4, 0, 0, 3244, 3245, + 7, 19, 0, 0, 3245, 3246, 7, 2, 0, 0, 3246, 3247, 7, 3, 0, 0, 3247, 3248, + 7, 8, 0, 0, 3248, 3249, 7, 23, 0, 0, 3249, 3250, 7, 0, 0, 0, 3250, 3251, + 7, 4, 0, 0, 3251, 3252, 7, 8, 0, 0, 3252, 3253, 7, 2, 0, 0, 3253, 3254, + 7, 10, 0, 0, 3254, 136, 1, 0, 0, 0, 3255, 3256, 7, 0, 0, 0, 3256, 3257, + 7, 12, 0, 0, 3257, 3258, 7, 4, 0, 0, 3258, 3259, 7, 2, 0, 0, 3259, 138, + 1, 0, 0, 0, 3260, 3261, 7, 0, 0, 0, 3261, 3262, 7, 12, 0, 0, 3262, 3263, + 7, 4, 0, 0, 3263, 3264, 7, 2, 0, 0, 3264, 3265, 7, 18, 0, 0, 3265, 3266, + 7, 3, 0, 0, 3266, 3267, 7, 2, 0, 0, 3267, 3268, 7, 7, 0, 0, 3268, 3269, + 5, 95, 0, 0, 3269, 3270, 7, 0, 0, 0, 3270, 3271, 7, 11, 0, 0, 3271, 3272, + 7, 11, 0, 0, 3272, 3273, 5, 95, 0, 0, 3273, 3274, 7, 5, 0, 0, 3274, 3275, + 7, 8, 0, 0, 3275, 3276, 7, 11, 0, 0, 3276, 3277, 7, 6, 0, 0, 3277, 3278, + 7, 9, 0, 0, 3278, 140, 1, 0, 0, 0, 3279, 3280, 7, 0, 0, 0, 3280, 3281, + 7, 12, 0, 0, 3281, 3282, 7, 4, 0, 0, 3282, 3283, 7, 2, 0, 0, 3283, 3284, + 7, 18, 0, 0, 3284, 3285, 7, 3, 0, 0, 3285, 3286, 7, 2, 0, 0, 3286, 3287, + 7, 7, 0, 0, 3287, 3288, 5, 95, 0, 0, 3288, 3289, 7, 9, 0, 0, 3289, 3290, + 7, 8, 0, 0, 3290, 3291, 7, 10, 0, 0, 3291, 3292, 7, 18, 0, 0, 3292, 3293, + 7, 11, 0, 0, 3293, 3294, 7, 6, 0, 0, 3294, 3295, 5, 95, 0, 0, 3295, 3296, + 7, 5, 0, 0, 3296, 3297, 7, 8, 0, 0, 3297, 3298, 7, 11, 0, 0, 3298, 3299, + 7, 6, 0, 0, 3299, 142, 1, 0, 0, 0, 3300, 3301, 7, 0, 0, 0, 3301, 3302, + 7, 12, 0, 0, 3302, 3303, 7, 4, 0, 0, 3303, 3304, 7, 2, 0, 0, 3304, 3305, + 7, 17, 0, 0, 3305, 3306, 7, 0, 0, 0, 3306, 3307, 7, 4, 0, 0, 3307, 3308, + 7, 6, 0, 0, 3308, 3309, 7, 14, 0, 0, 3309, 3310, 5, 95, 0, 0, 3310, 3311, + 7, 1, 0, 0, 3311, 3312, 7, 0, 0, 0, 3312, 3313, 7, 13, 0, 0, 3313, 3314, + 7, 21, 0, 0, 3314, 3315, 7, 12, 0, 0, 3315, 3316, 7, 20, 0, 0, 3316, 3317, + 5, 95, 0, 0, 3317, 3318, 7, 20, 0, 0, 3318, 3319, 7, 3, 0, 0, 3319, 3320, + 7, 6, 0, 0, 3320, 3321, 7, 5, 0, 0, 3321, 3322, 7, 6, 0, 0, 3322, 3323, + 7, 3, 0, 0, 3323, 3324, 7, 6, 0, 0, 3324, 3325, 7, 10, 0, 0, 3325, 3326, + 7, 13, 0, 0, 3326, 3327, 7, 6, 0, 0, 3327, 144, 1, 0, 0, 0, 3328, 3329, + 7, 0, 0, 0, 3329, 3330, 7, 12, 0, 0, 3330, 3331, 7, 4, 0, 0, 3331, 3332, + 7, 2, 0, 0, 3332, 3333, 7, 17, 0, 0, 3333, 3334, 7, 0, 0, 0, 3334, 3335, + 7, 4, 0, 0, 3335, 3336, 7, 8, 0, 0, 3336, 3337, 7, 13, 0, 0, 3337, 146, + 1, 0, 0, 0, 3338, 3339, 7, 0, 0, 0, 3339, 3340, 7, 12, 0, 0, 3340, 3341, + 7, 4, 0, 0, 3341, 3342, 7, 2, 0, 0, 3342, 3343, 5, 95, 0, 0, 3343, 3344, + 7, 13, 0, 0, 3344, 3345, 7, 11, 0, 0, 3345, 3346, 7, 6, 0, 0, 3346, 3347, + 7, 0, 0, 0, 3347, 3348, 7, 10, 0, 0, 3348, 3349, 7, 12, 0, 0, 3349, 3350, + 7, 20, 0, 0, 3350, 148, 1, 0, 0, 0, 3351, 3352, 7, 0, 0, 0, 3352, 3353, + 7, 12, 0, 0, 3353, 3354, 7, 4, 0, 0, 3354, 3355, 7, 2, 0, 0, 3355, 3356, + 5, 95, 0, 0, 3356, 3357, 7, 13, 0, 0, 3357, 3358, 7, 11, 0, 0, 3358, 3359, + 7, 2, 0, 0, 3359, 3360, 7, 9, 0, 0, 3360, 3361, 7, 6, 0, 0, 3361, 150, + 1, 0, 0, 0, 3362, 3363, 7, 0, 0, 0, 3363, 3364, 7, 12, 0, 0, 3364, 3365, + 7, 4, 0, 0, 3365, 3366, 7, 2, 0, 0, 3366, 3367, 5, 95, 0, 0, 3367, 3368, + 7, 13, 0, 0, 3368, 3369, 7, 3, 0, 0, 3369, 3370, 7, 6, 0, 0, 3370, 3371, + 7, 0, 0, 0, 3371, 3372, 7, 4, 0, 0, 3372, 3373, 7, 6, 0, 0, 3373, 3374, + 5, 95, 0, 0, 3374, 3375, 7, 9, 0, 0, 3375, 3376, 7, 4, 0, 0, 3376, 3377, + 7, 0, 0, 0, 3377, 3378, 7, 4, 0, 0, 3378, 3379, 7, 8, 0, 0, 3379, 3380, + 7, 9, 0, 0, 3380, 3381, 7, 4, 0, 0, 3381, 3382, 7, 8, 0, 0, 3382, 3383, + 7, 13, 0, 0, 3383, 3384, 7, 9, 0, 0, 3384, 152, 1, 0, 0, 0, 3385, 3386, + 7, 0, 0, 0, 3386, 3387, 7, 12, 0, 0, 3387, 3388, 7, 4, 0, 0, 3388, 3389, + 7, 2, 0, 0, 3389, 3390, 5, 95, 0, 0, 3390, 3391, 7, 14, 0, 0, 3391, 3392, + 7, 3, 0, 0, 3392, 3393, 7, 2, 0, 0, 3393, 3394, 7, 20, 0, 0, 3394, 154, + 1, 0, 0, 0, 3395, 3396, 7, 0, 0, 0, 3396, 3397, 7, 12, 0, 0, 3397, 3398, + 7, 4, 0, 0, 3398, 3399, 7, 2, 0, 0, 3399, 3400, 5, 95, 0, 0, 3400, 3401, + 7, 9, 0, 0, 3401, 3402, 7, 19, 0, 0, 3402, 3403, 7, 3, 0, 0, 3403, 3404, + 7, 8, 0, 0, 3404, 3405, 7, 10, 0, 0, 3405, 3406, 7, 21, 0, 0, 3406, 156, + 1, 0, 0, 0, 3407, 3408, 7, 0, 0, 0, 3408, 3409, 7, 12, 0, 0, 3409, 3410, + 7, 4, 0, 0, 3410, 3411, 7, 2, 0, 0, 3411, 3412, 5, 95, 0, 0, 3412, 3413, + 7, 12, 0, 0, 3413, 3414, 7, 20, 0, 0, 3414, 3415, 7, 14, 0, 0, 3415, 3416, + 7, 0, 0, 0, 3416, 3417, 7, 4, 0, 0, 3417, 3418, 7, 6, 0, 0, 3418, 3419, + 5, 95, 0, 0, 3419, 3420, 7, 9, 0, 0, 3420, 3421, 7, 4, 0, 0, 3421, 3422, + 7, 0, 0, 0, 3422, 3423, 7, 4, 0, 0, 3423, 3424, 7, 8, 0, 0, 3424, 3425, + 7, 9, 0, 0, 3425, 3426, 7, 4, 0, 0, 3426, 3427, 7, 8, 0, 0, 3427, 3428, + 7, 13, 0, 0, 3428, 3429, 7, 9, 0, 0, 3429, 158, 1, 0, 0, 0, 3430, 3431, + 7, 0, 0, 0, 3431, 3432, 7, 12, 0, 0, 3432, 3433, 7, 4, 0, 0, 3433, 3434, + 7, 2, 0, 0, 3434, 3435, 5, 95, 0, 0, 3435, 3436, 7, 12, 0, 0, 3436, 3437, + 7, 20, 0, 0, 3437, 3438, 7, 14, 0, 0, 3438, 3439, 7, 0, 0, 0, 3439, 3440, + 7, 4, 0, 0, 3440, 3441, 7, 6, 0, 0, 3441, 3442, 5, 95, 0, 0, 3442, 3443, + 7, 9, 0, 0, 3443, 3444, 7, 4, 0, 0, 3444, 3445, 7, 0, 0, 0, 3445, 3446, + 7, 4, 0, 0, 3446, 3447, 7, 8, 0, 0, 3447, 3448, 7, 9, 0, 0, 3448, 3449, + 7, 4, 0, 0, 3449, 3450, 7, 8, 0, 0, 3450, 3451, 7, 13, 0, 0, 3451, 3452, + 7, 9, 0, 0, 3452, 3453, 5, 95, 0, 0, 3453, 3454, 7, 0, 0, 0, 3454, 3455, + 7, 9, 0, 0, 3455, 3456, 7, 16, 0, 0, 3456, 3457, 7, 10, 0, 0, 3457, 3458, + 7, 13, 0, 0, 3458, 160, 1, 0, 0, 0, 3459, 3460, 7, 0, 0, 0, 3460, 3461, + 7, 15, 0, 0, 3461, 3462, 7, 0, 0, 0, 3462, 3463, 7, 8, 0, 0, 3463, 3464, + 7, 11, 0, 0, 3464, 3465, 7, 0, 0, 0, 3465, 3466, 7, 1, 0, 0, 3466, 3467, + 7, 8, 0, 0, 3467, 3468, 7, 11, 0, 0, 3468, 3469, 7, 8, 0, 0, 3469, 3470, + 7, 4, 0, 0, 3470, 3471, 7, 16, 0, 0, 3471, 162, 1, 0, 0, 0, 3472, 3473, + 7, 0, 0, 0, 3473, 3474, 7, 15, 0, 0, 3474, 3475, 7, 0, 0, 0, 3475, 3476, + 7, 8, 0, 0, 3476, 3477, 7, 11, 0, 0, 3477, 3478, 7, 0, 0, 0, 3478, 3479, + 7, 1, 0, 0, 3479, 3480, 7, 8, 0, 0, 3480, 3481, 7, 11, 0, 0, 3481, 3482, + 7, 8, 0, 0, 3482, 3483, 7, 4, 0, 0, 3483, 3484, 7, 16, 0, 0, 3484, 3485, + 5, 95, 0, 0, 3485, 3486, 7, 17, 0, 0, 3486, 3487, 7, 2, 0, 0, 3487, 3488, + 7, 14, 0, 0, 3488, 3489, 7, 6, 0, 0, 3489, 164, 1, 0, 0, 0, 3490, 3491, + 7, 0, 0, 0, 3491, 3492, 7, 15, 0, 0, 3492, 3493, 7, 18, 0, 0, 3493, 166, + 1, 0, 0, 0, 3494, 3495, 5, 92, 0, 0, 3495, 168, 1, 0, 0, 0, 3496, 3497, + 7, 1, 0, 0, 3497, 3498, 7, 0, 0, 0, 3498, 3499, 7, 13, 0, 0, 3499, 3500, + 7, 21, 0, 0, 3500, 3501, 7, 12, 0, 0, 3501, 3502, 7, 20, 0, 0, 3502, 170, + 1, 0, 0, 0, 3503, 3504, 7, 1, 0, 0, 3504, 3505, 7, 0, 0, 0, 3505, 3506, + 7, 13, 0, 0, 3506, 3507, 7, 21, 0, 0, 3507, 3508, 7, 12, 0, 0, 3508, 3509, + 7, 20, 0, 0, 3509, 3510, 5, 95, 0, 0, 3510, 3511, 7, 13, 0, 0, 3511, 3512, + 7, 11, 0, 0, 3512, 3513, 7, 2, 0, 0, 3513, 3514, 7, 10, 0, 0, 3514, 3515, + 7, 6, 0, 0, 3515, 3516, 7, 14, 0, 0, 3516, 3517, 7, 1, 0, 0, 3517, 172, + 1, 0, 0, 0, 3518, 3519, 7, 1, 0, 0, 3519, 3520, 7, 0, 0, 0, 3520, 3521, + 7, 13, 0, 0, 3521, 3522, 7, 21, 0, 0, 3522, 3523, 7, 12, 0, 0, 3523, 3524, + 7, 20, 0, 0, 3524, 3525, 5, 95, 0, 0, 3525, 3526, 7, 20, 0, 0, 3526, 3527, + 7, 3, 0, 0, 3527, 3528, 7, 8, 0, 0, 3528, 3529, 7, 2, 0, 0, 3529, 3530, + 7, 3, 0, 0, 3530, 3531, 7, 8, 0, 0, 3531, 3532, 7, 4, 0, 0, 3532, 3533, + 7, 16, 0, 0, 3533, 174, 1, 0, 0, 0, 3534, 3535, 7, 1, 0, 0, 3535, 3536, + 7, 0, 0, 0, 3536, 3537, 7, 9, 0, 0, 3537, 3538, 7, 6, 0, 0, 3538, 3539, + 5, 54, 0, 0, 3539, 3540, 5, 52, 0, 0, 3540, 176, 1, 0, 0, 0, 3541, 3542, + 7, 1, 0, 0, 3542, 3543, 7, 6, 0, 0, 3543, 3544, 7, 5, 0, 0, 3544, 3545, + 7, 2, 0, 0, 3545, 3546, 7, 3, 0, 0, 3546, 3547, 7, 6, 0, 0, 3547, 178, + 1, 0, 0, 0, 3548, 3549, 7, 1, 0, 0, 3549, 3550, 7, 6, 0, 0, 3550, 3551, + 7, 18, 0, 0, 3551, 3552, 7, 8, 0, 0, 3552, 3553, 7, 10, 0, 0, 3553, 180, + 1, 0, 0, 0, 3554, 3555, 7, 1, 0, 0, 3555, 3556, 7, 6, 0, 0, 3556, 3557, + 7, 18, 0, 0, 3557, 3558, 7, 8, 0, 0, 3558, 3559, 7, 10, 0, 0, 3559, 3560, + 5, 95, 0, 0, 3560, 3561, 7, 14, 0, 0, 3561, 3562, 7, 8, 0, 0, 3562, 3563, + 7, 0, 0, 0, 3563, 3564, 7, 11, 0, 0, 3564, 3565, 7, 2, 0, 0, 3565, 3566, + 7, 18, 0, 0, 3566, 182, 1, 0, 0, 0, 3567, 3568, 7, 1, 0, 0, 3568, 3569, + 7, 6, 0, 0, 3569, 3570, 7, 4, 0, 0, 3570, 3571, 7, 7, 0, 0, 3571, 3572, + 7, 6, 0, 0, 3572, 3573, 7, 6, 0, 0, 3573, 3574, 7, 10, 0, 0, 3574, 184, + 1, 0, 0, 0, 3575, 3576, 7, 1, 0, 0, 3576, 3577, 7, 8, 0, 0, 3577, 3578, + 7, 18, 0, 0, 3578, 3579, 7, 8, 0, 0, 3579, 3580, 7, 10, 0, 0, 3580, 3581, + 7, 4, 0, 0, 3581, 186, 1, 0, 0, 0, 3582, 3583, 7, 1, 0, 0, 3583, 3584, + 7, 8, 0, 0, 3584, 3585, 7, 10, 0, 0, 3585, 3586, 7, 0, 0, 0, 3586, 3587, + 7, 3, 0, 0, 3587, 3588, 7, 16, 0, 0, 3588, 3589, 5, 95, 0, 0, 3589, 3590, + 7, 13, 0, 0, 3590, 3591, 7, 19, 0, 0, 3591, 3592, 7, 6, 0, 0, 3592, 3593, + 7, 13, 0, 0, 3593, 3594, 7, 21, 0, 0, 3594, 3595, 7, 9, 0, 0, 3595, 3596, + 7, 12, 0, 0, 3596, 3597, 7, 17, 0, 0, 3597, 188, 1, 0, 0, 0, 3598, 3599, + 7, 1, 0, 0, 3599, 3600, 7, 8, 0, 0, 3600, 3601, 7, 10, 0, 0, 3601, 3602, + 7, 0, 0, 0, 3602, 3603, 7, 3, 0, 0, 3603, 3604, 7, 16, 0, 0, 3604, 190, + 1, 0, 0, 0, 3605, 3606, 7, 1, 0, 0, 3606, 3607, 7, 8, 0, 0, 3607, 3608, + 7, 10, 0, 0, 3608, 3609, 7, 14, 0, 0, 3609, 3610, 7, 8, 0, 0, 3610, 3611, + 7, 10, 0, 0, 3611, 3612, 7, 18, 0, 0, 3612, 192, 1, 0, 0, 0, 3613, 3614, + 7, 1, 0, 0, 3614, 3615, 7, 11, 0, 0, 3615, 3616, 7, 2, 0, 0, 3616, 3617, + 7, 1, 0, 0, 3617, 3618, 5, 95, 0, 0, 3618, 3619, 7, 9, 0, 0, 3619, 3620, + 7, 4, 0, 0, 3620, 3621, 7, 2, 0, 0, 3621, 3622, 7, 3, 0, 0, 3622, 3623, + 7, 0, 0, 0, 3623, 3624, 7, 18, 0, 0, 3624, 3625, 7, 6, 0, 0, 3625, 194, + 1, 0, 0, 0, 3626, 3627, 7, 1, 0, 0, 3627, 3628, 7, 11, 0, 0, 3628, 3629, + 7, 2, 0, 0, 3629, 3630, 7, 13, 0, 0, 3630, 3631, 7, 21, 0, 0, 3631, 196, + 1, 0, 0, 0, 3632, 3633, 7, 1, 0, 0, 3633, 3634, 7, 11, 0, 0, 3634, 3635, + 7, 2, 0, 0, 3635, 3636, 7, 13, 0, 0, 3636, 3637, 7, 21, 0, 0, 3637, 3638, + 7, 6, 0, 0, 3638, 3639, 7, 3, 0, 0, 3639, 3640, 7, 9, 0, 0, 3640, 198, + 1, 0, 0, 0, 3641, 3642, 7, 1, 0, 0, 3642, 3643, 7, 11, 0, 0, 3643, 3644, + 7, 2, 0, 0, 3644, 3645, 7, 13, 0, 0, 3645, 3646, 7, 21, 0, 0, 3646, 3647, + 7, 8, 0, 0, 3647, 3648, 7, 10, 0, 0, 3648, 3649, 7, 18, 0, 0, 3649, 3650, + 5, 95, 0, 0, 3650, 3651, 7, 19, 0, 0, 3651, 3652, 7, 8, 0, 0, 3652, 3653, + 7, 6, 0, 0, 3653, 3654, 7, 3, 0, 0, 3654, 3655, 7, 0, 0, 0, 3655, 3656, + 7, 3, 0, 0, 3656, 3657, 7, 13, 0, 0, 3657, 3658, 7, 19, 0, 0, 3658, 3659, + 7, 16, 0, 0, 3659, 200, 1, 0, 0, 0, 3660, 3661, 7, 1, 0, 0, 3661, 3662, + 7, 11, 0, 0, 3662, 3663, 7, 2, 0, 0, 3663, 3664, 7, 13, 0, 0, 3664, 3665, + 7, 21, 0, 0, 3665, 3666, 7, 9, 0, 0, 3666, 3667, 7, 8, 0, 0, 3667, 3668, + 7, 23, 0, 0, 3668, 3669, 7, 6, 0, 0, 3669, 202, 1, 0, 0, 0, 3670, 3671, + 7, 1, 0, 0, 3671, 3672, 7, 2, 0, 0, 3672, 3673, 7, 12, 0, 0, 3673, 3674, + 7, 10, 0, 0, 3674, 3675, 7, 14, 0, 0, 3675, 3676, 7, 8, 0, 0, 3676, 3677, + 7, 10, 0, 0, 3677, 3678, 7, 18, 0, 0, 3678, 3679, 5, 95, 0, 0, 3679, 3680, + 7, 1, 0, 0, 3680, 3681, 7, 2, 0, 0, 3681, 3682, 7, 22, 0, 0, 3682, 204, + 1, 0, 0, 0, 3683, 3684, 7, 1, 0, 0, 3684, 3685, 7, 3, 0, 0, 3685, 3686, + 7, 6, 0, 0, 3686, 3687, 7, 0, 0, 0, 3687, 3688, 7, 21, 0, 0, 3688, 206, + 1, 0, 0, 0, 3689, 3690, 7, 1, 0, 0, 3690, 3691, 7, 3, 0, 0, 3691, 3692, + 7, 2, 0, 0, 3692, 3693, 7, 21, 0, 0, 3693, 3694, 7, 6, 0, 0, 3694, 3695, + 7, 3, 0, 0, 3695, 208, 1, 0, 0, 0, 3696, 3697, 7, 1, 0, 0, 3697, 3698, + 7, 3, 0, 0, 3698, 3699, 7, 2, 0, 0, 3699, 3700, 7, 21, 0, 0, 3700, 3701, + 7, 6, 0, 0, 3701, 3702, 7, 3, 0, 0, 3702, 3703, 5, 95, 0, 0, 3703, 3704, + 7, 8, 0, 0, 3704, 3705, 7, 10, 0, 0, 3705, 3706, 7, 9, 0, 0, 3706, 3707, + 7, 4, 0, 0, 3707, 3708, 7, 0, 0, 0, 3708, 3709, 7, 10, 0, 0, 3709, 3710, + 7, 13, 0, 0, 3710, 3711, 7, 6, 0, 0, 3711, 210, 1, 0, 0, 0, 3712, 3713, + 7, 1, 0, 0, 3713, 3714, 7, 3, 0, 0, 3714, 3715, 7, 2, 0, 0, 3715, 3716, + 7, 7, 0, 0, 3716, 3717, 7, 9, 0, 0, 3717, 3718, 7, 6, 0, 0, 3718, 212, + 1, 0, 0, 0, 3719, 3720, 7, 1, 0, 0, 3720, 3721, 7, 12, 0, 0, 3721, 3722, + 7, 5, 0, 0, 3722, 3723, 7, 5, 0, 0, 3723, 3724, 7, 6, 0, 0, 3724, 3725, + 7, 3, 0, 0, 3725, 214, 1, 0, 0, 0, 3726, 3727, 7, 1, 0, 0, 3727, 3728, + 7, 12, 0, 0, 3728, 3729, 7, 5, 0, 0, 3729, 3730, 7, 5, 0, 0, 3730, 3731, + 7, 6, 0, 0, 3731, 3732, 7, 3, 0, 0, 3732, 3733, 7, 13, 0, 0, 3733, 3734, + 7, 2, 0, 0, 3734, 3735, 7, 12, 0, 0, 3735, 3736, 7, 10, 0, 0, 3736, 3737, + 7, 4, 0, 0, 3737, 216, 1, 0, 0, 0, 3738, 3739, 7, 1, 0, 0, 3739, 3740, + 7, 12, 0, 0, 3740, 3741, 7, 11, 0, 0, 3741, 3742, 7, 21, 0, 0, 3742, 218, + 1, 0, 0, 0, 3743, 3744, 7, 1, 0, 0, 3744, 3745, 7, 12, 0, 0, 3745, 3746, + 7, 11, 0, 0, 3746, 3747, 7, 21, 0, 0, 3747, 3748, 5, 95, 0, 0, 3748, 3749, + 7, 11, 0, 0, 3749, 3750, 7, 2, 0, 0, 3750, 3751, 7, 18, 0, 0, 3751, 3752, + 7, 18, 0, 0, 3752, 3753, 7, 6, 0, 0, 3753, 3754, 7, 14, 0, 0, 3754, 220, + 1, 0, 0, 0, 3755, 3756, 7, 1, 0, 0, 3756, 3757, 7, 16, 0, 0, 3757, 222, + 1, 0, 0, 0, 3758, 3759, 7, 13, 0, 0, 3759, 3760, 7, 0, 0, 0, 3760, 3761, + 7, 13, 0, 0, 3761, 3762, 7, 19, 0, 0, 3762, 3763, 7, 6, 0, 0, 3763, 224, + 1, 0, 0, 0, 3764, 3765, 7, 13, 0, 0, 3765, 3766, 7, 0, 0, 0, 3766, 3767, + 7, 11, 0, 0, 3767, 3768, 7, 11, 0, 0, 3768, 3769, 7, 6, 0, 0, 3769, 3770, + 7, 14, 0, 0, 3770, 226, 1, 0, 0, 0, 3771, 3772, 7, 13, 0, 0, 3772, 3773, + 7, 0, 0, 0, 3773, 3774, 7, 11, 0, 0, 3774, 3775, 7, 11, 0, 0, 3775, 3776, + 7, 6, 0, 0, 3776, 3777, 7, 3, 0, 0, 3777, 228, 1, 0, 0, 0, 3778, 3779, + 7, 13, 0, 0, 3779, 3780, 7, 0, 0, 0, 3780, 3781, 7, 20, 0, 0, 3781, 3782, + 5, 95, 0, 0, 3782, 3783, 7, 13, 0, 0, 3783, 3784, 7, 20, 0, 0, 3784, 3785, + 7, 12, 0, 0, 3785, 3786, 5, 95, 0, 0, 3786, 3787, 7, 20, 0, 0, 3787, 3788, + 7, 6, 0, 0, 3788, 3789, 7, 3, 0, 0, 3789, 3790, 7, 13, 0, 0, 3790, 3791, + 7, 6, 0, 0, 3791, 3792, 7, 10, 0, 0, 3792, 3793, 7, 4, 0, 0, 3793, 230, + 1, 0, 0, 0, 3794, 3795, 7, 13, 0, 0, 3795, 3796, 7, 0, 0, 0, 3796, 3797, + 7, 9, 0, 0, 3797, 3798, 7, 13, 0, 0, 3798, 3799, 7, 0, 0, 0, 3799, 3800, + 7, 14, 0, 0, 3800, 3801, 7, 6, 0, 0, 3801, 232, 1, 0, 0, 0, 3802, 3803, + 7, 13, 0, 0, 3803, 3804, 7, 0, 0, 0, 3804, 3805, 7, 9, 0, 0, 3805, 3806, + 7, 6, 0, 0, 3806, 234, 1, 0, 0, 0, 3807, 3808, 7, 13, 0, 0, 3808, 3809, + 7, 0, 0, 0, 3809, 3810, 7, 9, 0, 0, 3810, 3811, 7, 4, 0, 0, 3811, 236, + 1, 0, 0, 0, 3812, 3813, 7, 13, 0, 0, 3813, 3814, 7, 0, 0, 0, 3814, 3815, + 7, 4, 0, 0, 3815, 3816, 7, 0, 0, 0, 3816, 3817, 7, 11, 0, 0, 3817, 3818, + 7, 2, 0, 0, 3818, 3819, 7, 18, 0, 0, 3819, 238, 1, 0, 0, 0, 3820, 3821, + 7, 13, 0, 0, 3821, 3822, 7, 0, 0, 0, 3822, 3823, 7, 4, 0, 0, 3823, 3824, + 7, 13, 0, 0, 3824, 3825, 7, 19, 0, 0, 3825, 240, 1, 0, 0, 0, 3826, 3827, + 7, 13, 0, 0, 3827, 3828, 7, 6, 0, 0, 3828, 3829, 7, 11, 0, 0, 3829, 3830, + 7, 11, 0, 0, 3830, 3831, 7, 9, 0, 0, 3831, 3832, 5, 95, 0, 0, 3832, 3833, + 7, 20, 0, 0, 3833, 3834, 7, 6, 0, 0, 3834, 3835, 7, 3, 0, 0, 3835, 3836, + 5, 95, 0, 0, 3836, 3837, 7, 2, 0, 0, 3837, 3838, 7, 1, 0, 0, 3838, 3839, + 7, 24, 0, 0, 3839, 3840, 7, 6, 0, 0, 3840, 3841, 7, 13, 0, 0, 3841, 3842, + 7, 4, 0, 0, 3842, 242, 1, 0, 0, 0, 3843, 3844, 7, 13, 0, 0, 3844, 3845, + 7, 6, 0, 0, 3845, 3846, 7, 3, 0, 0, 3846, 3847, 7, 4, 0, 0, 3847, 3848, + 7, 6, 0, 0, 3848, 3849, 7, 10, 0, 0, 3849, 3850, 7, 13, 0, 0, 3850, 3851, + 7, 2, 0, 0, 3851, 3852, 7, 14, 0, 0, 3852, 3853, 7, 6, 0, 0, 3853, 3854, + 7, 14, 0, 0, 3854, 244, 1, 0, 0, 0, 3855, 3856, 7, 13, 0, 0, 3856, 3857, + 7, 6, 0, 0, 3857, 3858, 7, 3, 0, 0, 3858, 3859, 7, 4, 0, 0, 3859, 3860, + 7, 8, 0, 0, 3860, 3861, 7, 5, 0, 0, 3861, 3862, 7, 8, 0, 0, 3862, 3863, + 7, 13, 0, 0, 3863, 3864, 7, 0, 0, 0, 3864, 3865, 7, 4, 0, 0, 3865, 3866, + 7, 6, 0, 0, 3866, 246, 1, 0, 0, 0, 3867, 3868, 7, 13, 0, 0, 3868, 3869, + 7, 6, 0, 0, 3869, 3870, 7, 3, 0, 0, 3870, 3871, 7, 4, 0, 0, 3871, 3872, + 7, 20, 0, 0, 3872, 3873, 7, 3, 0, 0, 3873, 3874, 7, 8, 0, 0, 3874, 3875, + 7, 15, 0, 0, 3875, 3876, 7, 0, 0, 0, 3876, 3877, 7, 4, 0, 0, 3877, 3878, + 7, 6, 0, 0, 3878, 3879, 7, 21, 0, 0, 3879, 3880, 7, 6, 0, 0, 3880, 3881, + 7, 16, 0, 0, 3881, 248, 1, 0, 0, 0, 3882, 3883, 7, 13, 0, 0, 3883, 3884, + 7, 6, 0, 0, 3884, 3885, 7, 3, 0, 0, 3885, 3886, 7, 4, 0, 0, 3886, 3887, + 5, 95, 0, 0, 3887, 3888, 7, 8, 0, 0, 3888, 3889, 7, 14, 0, 0, 3889, 250, + 1, 0, 0, 0, 3890, 3891, 7, 13, 0, 0, 3891, 3892, 7, 19, 0, 0, 3892, 3893, + 7, 0, 0, 0, 3893, 3894, 7, 10, 0, 0, 3894, 3895, 7, 18, 0, 0, 3895, 3896, + 7, 6, 0, 0, 3896, 252, 1, 0, 0, 0, 3897, 3898, 7, 13, 0, 0, 3898, 3899, + 7, 19, 0, 0, 3899, 3900, 7, 0, 0, 0, 3900, 3901, 7, 10, 0, 0, 3901, 3902, + 7, 18, 0, 0, 3902, 3903, 7, 6, 0, 0, 3903, 3904, 7, 9, 0, 0, 3904, 254, + 1, 0, 0, 0, 3905, 3906, 7, 13, 0, 0, 3906, 3907, 7, 19, 0, 0, 3907, 3908, + 7, 0, 0, 0, 3908, 3909, 7, 10, 0, 0, 3909, 3910, 7, 18, 0, 0, 3910, 3911, + 7, 6, 0, 0, 3911, 3912, 7, 4, 0, 0, 3912, 3913, 7, 0, 0, 0, 3913, 3914, + 7, 1, 0, 0, 3914, 3915, 7, 11, 0, 0, 3915, 3916, 7, 6, 0, 0, 3916, 256, + 1, 0, 0, 0, 3917, 3918, 7, 13, 0, 0, 3918, 3919, 7, 19, 0, 0, 3919, 3920, + 7, 0, 0, 0, 3920, 3921, 7, 10, 0, 0, 3921, 3922, 7, 18, 0, 0, 3922, 3923, + 7, 6, 0, 0, 3923, 3924, 5, 95, 0, 0, 3924, 3925, 7, 3, 0, 0, 3925, 3926, + 7, 6, 0, 0, 3926, 3927, 7, 4, 0, 0, 3927, 3928, 7, 6, 0, 0, 3928, 3929, + 7, 10, 0, 0, 3929, 3930, 7, 4, 0, 0, 3930, 3931, 7, 8, 0, 0, 3931, 3932, + 7, 2, 0, 0, 3932, 3933, 7, 10, 0, 0, 3933, 258, 1, 0, 0, 0, 3934, 3935, + 7, 13, 0, 0, 3935, 3936, 7, 19, 0, 0, 3936, 3937, 7, 0, 0, 0, 3937, 3938, + 7, 10, 0, 0, 3938, 3939, 7, 18, 0, 0, 3939, 3940, 7, 6, 0, 0, 3940, 3941, + 5, 95, 0, 0, 3941, 3942, 7, 4, 0, 0, 3942, 3943, 7, 3, 0, 0, 3943, 3944, + 7, 0, 0, 0, 3944, 3945, 7, 13, 0, 0, 3945, 3946, 7, 21, 0, 0, 3946, 3947, + 7, 8, 0, 0, 3947, 3948, 7, 10, 0, 0, 3948, 3949, 7, 18, 0, 0, 3949, 260, + 1, 0, 0, 0, 3950, 3951, 7, 13, 0, 0, 3951, 3952, 7, 19, 0, 0, 3952, 3953, + 7, 0, 0, 0, 3953, 3954, 7, 3, 0, 0, 3954, 262, 1, 0, 0, 0, 3955, 3956, + 7, 13, 0, 0, 3956, 3957, 7, 19, 0, 0, 3957, 3958, 7, 0, 0, 0, 3958, 3959, + 7, 3, 0, 0, 3959, 3960, 7, 8, 0, 0, 3960, 3961, 7, 10, 0, 0, 3961, 3962, + 7, 14, 0, 0, 3962, 3963, 7, 6, 0, 0, 3963, 3964, 7, 22, 0, 0, 3964, 264, + 1, 0, 0, 0, 3965, 3966, 7, 13, 0, 0, 3966, 3967, 7, 19, 0, 0, 3967, 3968, + 7, 6, 0, 0, 3968, 3969, 7, 13, 0, 0, 3969, 3970, 7, 21, 0, 0, 3970, 266, + 1, 0, 0, 0, 3971, 3972, 7, 13, 0, 0, 3972, 3973, 7, 19, 0, 0, 3973, 3974, + 7, 6, 0, 0, 3974, 3975, 7, 13, 0, 0, 3975, 3976, 7, 21, 0, 0, 3976, 3977, + 7, 0, 0, 0, 3977, 3978, 7, 11, 0, 0, 3978, 3979, 7, 11, 0, 0, 3979, 3980, + 7, 2, 0, 0, 3980, 3981, 7, 13, 0, 0, 3981, 268, 1, 0, 0, 0, 3982, 3983, + 7, 13, 0, 0, 3983, 3984, 7, 19, 0, 0, 3984, 3985, 7, 6, 0, 0, 3985, 3986, + 7, 13, 0, 0, 3986, 3987, 7, 21, 0, 0, 3987, 3988, 7, 13, 0, 0, 3988, 3989, + 7, 0, 0, 0, 3989, 3990, 7, 4, 0, 0, 3990, 3991, 7, 0, 0, 0, 3991, 3992, + 7, 11, 0, 0, 3992, 3993, 7, 2, 0, 0, 3993, 3994, 7, 18, 0, 0, 3994, 270, + 1, 0, 0, 0, 3995, 3996, 7, 13, 0, 0, 3996, 3997, 7, 19, 0, 0, 3997, 3998, + 7, 6, 0, 0, 3998, 3999, 7, 13, 0, 0, 3999, 4000, 7, 21, 0, 0, 4000, 4001, + 7, 13, 0, 0, 4001, 4002, 7, 2, 0, 0, 4002, 4003, 7, 10, 0, 0, 4003, 4004, + 7, 9, 0, 0, 4004, 4005, 7, 4, 0, 0, 4005, 4006, 7, 3, 0, 0, 4006, 4007, + 7, 0, 0, 0, 4007, 4008, 7, 8, 0, 0, 4008, 4009, 7, 10, 0, 0, 4009, 4010, + 7, 4, 0, 0, 4010, 4011, 7, 9, 0, 0, 4011, 272, 1, 0, 0, 0, 4012, 4013, + 7, 13, 0, 0, 4013, 4014, 7, 19, 0, 0, 4014, 4015, 7, 6, 0, 0, 4015, 4016, + 7, 13, 0, 0, 4016, 4017, 7, 21, 0, 0, 4017, 4018, 7, 14, 0, 0, 4018, 4019, + 7, 1, 0, 0, 4019, 274, 1, 0, 0, 0, 4020, 4021, 7, 13, 0, 0, 4021, 4022, + 7, 19, 0, 0, 4022, 4023, 7, 6, 0, 0, 4023, 4024, 7, 13, 0, 0, 4024, 4025, + 7, 21, 0, 0, 4025, 4026, 7, 5, 0, 0, 4026, 4027, 7, 8, 0, 0, 4027, 4028, + 7, 11, 0, 0, 4028, 4029, 7, 6, 0, 0, 4029, 4030, 7, 18, 0, 0, 4030, 4031, + 7, 3, 0, 0, 4031, 4032, 7, 2, 0, 0, 4032, 4033, 7, 12, 0, 0, 4033, 4034, + 7, 20, 0, 0, 4034, 276, 1, 0, 0, 0, 4035, 4036, 7, 13, 0, 0, 4036, 4037, + 7, 19, 0, 0, 4037, 4038, 7, 6, 0, 0, 4038, 4039, 7, 13, 0, 0, 4039, 4040, + 7, 21, 0, 0, 4040, 4041, 7, 20, 0, 0, 4041, 4042, 7, 2, 0, 0, 4042, 4043, + 7, 8, 0, 0, 4043, 4044, 7, 10, 0, 0, 4044, 4045, 7, 4, 0, 0, 4045, 278, + 1, 0, 0, 0, 4046, 4047, 7, 13, 0, 0, 4047, 4048, 7, 19, 0, 0, 4048, 4049, + 7, 6, 0, 0, 4049, 4050, 7, 13, 0, 0, 4050, 4051, 7, 21, 0, 0, 4051, 4052, + 7, 9, 0, 0, 4052, 4053, 7, 12, 0, 0, 4053, 4054, 7, 17, 0, 0, 4054, 280, + 1, 0, 0, 0, 4055, 4056, 7, 13, 0, 0, 4056, 4057, 7, 19, 0, 0, 4057, 4058, + 7, 6, 0, 0, 4058, 4059, 7, 13, 0, 0, 4059, 4060, 7, 21, 0, 0, 4060, 4061, + 7, 9, 0, 0, 4061, 4062, 7, 12, 0, 0, 4062, 4063, 7, 17, 0, 0, 4063, 4064, + 5, 95, 0, 0, 4064, 4065, 7, 0, 0, 0, 4065, 4066, 7, 18, 0, 0, 4066, 4067, + 7, 18, 0, 0, 4067, 282, 1, 0, 0, 0, 4068, 4069, 7, 13, 0, 0, 4069, 4070, + 7, 19, 0, 0, 4070, 4071, 7, 6, 0, 0, 4071, 4072, 7, 13, 0, 0, 4072, 4073, + 7, 21, 0, 0, 4073, 4074, 7, 4, 0, 0, 4074, 4075, 7, 0, 0, 0, 4075, 4076, + 7, 1, 0, 0, 4076, 4077, 7, 11, 0, 0, 4077, 4078, 7, 6, 0, 0, 4078, 284, + 1, 0, 0, 0, 4079, 4080, 7, 13, 0, 0, 4080, 4081, 7, 19, 0, 0, 4081, 4082, + 7, 6, 0, 0, 4082, 4083, 7, 13, 0, 0, 4083, 4084, 7, 21, 0, 0, 4084, 4085, + 5, 95, 0, 0, 4085, 4086, 7, 6, 0, 0, 4086, 4087, 7, 22, 0, 0, 4087, 4088, + 7, 20, 0, 0, 4088, 4089, 7, 8, 0, 0, 4089, 4090, 7, 3, 0, 0, 4090, 4091, + 7, 0, 0, 0, 4091, 4092, 7, 4, 0, 0, 4092, 4093, 7, 8, 0, 0, 4093, 4094, + 7, 2, 0, 0, 4094, 4095, 7, 10, 0, 0, 4095, 286, 1, 0, 0, 0, 4096, 4097, + 7, 13, 0, 0, 4097, 4098, 7, 19, 0, 0, 4098, 4099, 7, 6, 0, 0, 4099, 4100, + 7, 13, 0, 0, 4100, 4101, 7, 21, 0, 0, 4101, 4102, 5, 95, 0, 0, 4102, 4103, + 7, 20, 0, 0, 4103, 4104, 7, 2, 0, 0, 4104, 4105, 7, 11, 0, 0, 4105, 4106, + 7, 8, 0, 0, 4106, 4107, 7, 13, 0, 0, 4107, 4108, 7, 16, 0, 0, 4108, 288, + 1, 0, 0, 0, 4109, 4110, 7, 13, 0, 0, 4110, 4111, 7, 11, 0, 0, 4111, 4112, + 7, 0, 0, 0, 4112, 4113, 7, 9, 0, 0, 4113, 4114, 7, 9, 0, 0, 4114, 4115, + 7, 8, 0, 0, 4115, 4116, 7, 5, 0, 0, 4116, 4117, 7, 8, 0, 0, 4117, 4118, + 7, 6, 0, 0, 4118, 4119, 7, 3, 0, 0, 4119, 4120, 5, 95, 0, 0, 4120, 4121, + 7, 5, 0, 0, 4121, 4122, 7, 12, 0, 0, 4122, 4123, 7, 10, 0, 0, 4123, 4124, + 7, 13, 0, 0, 4124, 4125, 7, 4, 0, 0, 4125, 4126, 7, 8, 0, 0, 4126, 4127, + 7, 2, 0, 0, 4127, 4128, 7, 10, 0, 0, 4128, 290, 1, 0, 0, 0, 4129, 4130, + 7, 13, 0, 0, 4130, 4131, 7, 11, 0, 0, 4131, 4132, 7, 6, 0, 0, 4132, 4133, + 7, 0, 0, 0, 4133, 4134, 7, 10, 0, 0, 4134, 4135, 7, 4, 0, 0, 4135, 4136, + 7, 0, 0, 0, 4136, 4137, 7, 1, 0, 0, 4137, 4138, 7, 11, 0, 0, 4138, 4139, + 7, 6, 0, 0, 4139, 292, 1, 0, 0, 0, 4140, 4141, 7, 13, 0, 0, 4141, 4142, + 7, 11, 0, 0, 4142, 4143, 7, 6, 0, 0, 4143, 4144, 7, 0, 0, 0, 4144, 4145, + 7, 10, 0, 0, 4145, 4146, 7, 12, 0, 0, 4146, 4147, 7, 20, 0, 0, 4147, 294, + 1, 0, 0, 0, 4148, 4149, 7, 13, 0, 0, 4149, 4150, 7, 11, 0, 0, 4150, 4151, + 7, 2, 0, 0, 4151, 4152, 7, 10, 0, 0, 4152, 4153, 7, 6, 0, 0, 4153, 4154, + 7, 14, 0, 0, 4154, 4155, 7, 0, 0, 0, 4155, 4156, 7, 4, 0, 0, 4156, 4157, + 7, 0, 0, 0, 4157, 4158, 7, 1, 0, 0, 4158, 4159, 7, 0, 0, 0, 4159, 4160, + 7, 9, 0, 0, 4160, 4161, 7, 6, 0, 0, 4161, 296, 1, 0, 0, 0, 4162, 4163, + 7, 13, 0, 0, 4163, 4164, 7, 11, 0, 0, 4164, 4165, 7, 2, 0, 0, 4165, 4166, + 7, 9, 0, 0, 4166, 4167, 7, 6, 0, 0, 4167, 298, 1, 0, 0, 0, 4168, 4169, + 7, 13, 0, 0, 4169, 4170, 7, 11, 0, 0, 4170, 4171, 7, 12, 0, 0, 4171, 4172, + 7, 9, 0, 0, 4172, 4173, 7, 4, 0, 0, 4173, 4174, 7, 6, 0, 0, 4174, 4175, + 7, 3, 0, 0, 4175, 300, 1, 0, 0, 0, 4176, 4177, 7, 13, 0, 0, 4177, 4178, + 7, 11, 0, 0, 4178, 4179, 7, 12, 0, 0, 4179, 4180, 7, 9, 0, 0, 4180, 4181, + 7, 4, 0, 0, 4181, 4182, 7, 6, 0, 0, 4182, 4183, 7, 3, 0, 0, 4183, 4184, + 7, 6, 0, 0, 4184, 4185, 7, 14, 0, 0, 4185, 302, 1, 0, 0, 0, 4186, 4187, + 7, 13, 0, 0, 4187, 4188, 7, 2, 0, 0, 4188, 4189, 7, 0, 0, 0, 4189, 4190, + 7, 11, 0, 0, 4190, 4191, 7, 6, 0, 0, 4191, 4192, 7, 9, 0, 0, 4192, 4193, + 7, 13, 0, 0, 4193, 4194, 7, 6, 0, 0, 4194, 304, 1, 0, 0, 0, 4195, 4196, + 7, 13, 0, 0, 4196, 4197, 7, 2, 0, 0, 4197, 4198, 7, 11, 0, 0, 4198, 4199, + 7, 11, 0, 0, 4199, 4200, 7, 0, 0, 0, 4200, 4201, 7, 4, 0, 0, 4201, 4202, + 7, 6, 0, 0, 4202, 306, 1, 0, 0, 0, 4203, 4204, 7, 13, 0, 0, 4204, 4205, + 7, 2, 0, 0, 4205, 4206, 7, 11, 0, 0, 4206, 4207, 7, 11, 0, 0, 4207, 4208, + 7, 6, 0, 0, 4208, 4209, 7, 13, 0, 0, 4209, 4210, 7, 4, 0, 0, 4210, 4211, + 7, 8, 0, 0, 4211, 4212, 7, 2, 0, 0, 4212, 4213, 7, 10, 0, 0, 4213, 308, + 1, 0, 0, 0, 4214, 4215, 7, 13, 0, 0, 4215, 4216, 7, 2, 0, 0, 4216, 4217, + 7, 11, 0, 0, 4217, 4218, 7, 12, 0, 0, 4218, 4219, 7, 17, 0, 0, 4219, 4220, + 7, 10, 0, 0, 4220, 310, 1, 0, 0, 0, 4221, 4222, 7, 13, 0, 0, 4222, 4223, + 7, 2, 0, 0, 4223, 4224, 7, 11, 0, 0, 4224, 4225, 7, 12, 0, 0, 4225, 4226, + 7, 17, 0, 0, 4226, 4227, 7, 10, 0, 0, 4227, 4228, 7, 20, 0, 0, 4228, 4229, + 7, 3, 0, 0, 4229, 4230, 7, 2, 0, 0, 4230, 4231, 7, 20, 0, 0, 4231, 4232, + 7, 6, 0, 0, 4232, 4233, 7, 3, 0, 0, 4233, 4234, 7, 4, 0, 0, 4234, 4235, + 7, 16, 0, 0, 4235, 312, 1, 0, 0, 0, 4236, 4237, 7, 13, 0, 0, 4237, 4238, + 7, 2, 0, 0, 4238, 4239, 7, 11, 0, 0, 4239, 4240, 7, 12, 0, 0, 4240, 4241, + 7, 17, 0, 0, 4241, 4242, 7, 10, 0, 0, 4242, 4243, 7, 9, 0, 0, 4243, 314, + 1, 0, 0, 0, 4244, 4245, 7, 13, 0, 0, 4245, 4246, 7, 2, 0, 0, 4246, 4247, + 7, 11, 0, 0, 4247, 4248, 7, 12, 0, 0, 4248, 4249, 7, 17, 0, 0, 4249, 4250, + 7, 10, 0, 0, 4250, 4251, 7, 9, 0, 0, 4251, 4252, 7, 4, 0, 0, 4252, 4253, + 7, 2, 0, 0, 4253, 4254, 7, 3, 0, 0, 4254, 4255, 7, 6, 0, 0, 4255, 316, + 1, 0, 0, 0, 4256, 4257, 7, 13, 0, 0, 4257, 4258, 7, 2, 0, 0, 4258, 4259, + 7, 11, 0, 0, 4259, 4260, 7, 12, 0, 0, 4260, 4261, 7, 17, 0, 0, 4261, 4262, + 7, 10, 0, 0, 4262, 4263, 7, 9, 0, 0, 4263, 4264, 7, 4, 0, 0, 4264, 4265, + 7, 2, 0, 0, 4265, 4266, 7, 3, 0, 0, 4266, 4267, 7, 6, 0, 0, 4267, 4268, + 5, 95, 0, 0, 4268, 4269, 7, 0, 0, 0, 4269, 4270, 7, 3, 0, 0, 4270, 4271, + 7, 13, 0, 0, 4271, 4272, 7, 19, 0, 0, 4272, 4273, 7, 8, 0, 0, 4273, 4274, + 7, 15, 0, 0, 4274, 4275, 7, 6, 0, 0, 4275, 318, 1, 0, 0, 0, 4276, 4277, + 7, 13, 0, 0, 4277, 4278, 7, 2, 0, 0, 4278, 4279, 7, 11, 0, 0, 4279, 4280, + 7, 12, 0, 0, 4280, 4281, 7, 17, 0, 0, 4281, 4282, 7, 10, 0, 0, 4282, 4283, + 5, 95, 0, 0, 4283, 4284, 7, 6, 0, 0, 4284, 4285, 7, 10, 0, 0, 4285, 4286, + 7, 13, 0, 0, 4286, 4287, 7, 3, 0, 0, 4287, 4288, 7, 16, 0, 0, 4288, 4289, + 7, 20, 0, 0, 4289, 4290, 7, 4, 0, 0, 4290, 4291, 7, 8, 0, 0, 4291, 4292, + 7, 2, 0, 0, 4292, 4293, 7, 10, 0, 0, 4293, 4294, 5, 95, 0, 0, 4294, 4295, + 7, 21, 0, 0, 4295, 4296, 7, 6, 0, 0, 4296, 4297, 7, 16, 0, 0, 4297, 320, + 1, 0, 0, 0, 4298, 4299, 7, 13, 0, 0, 4299, 4300, 7, 2, 0, 0, 4300, 4301, + 7, 11, 0, 0, 4301, 4302, 7, 12, 0, 0, 4302, 4303, 7, 17, 0, 0, 4303, 4304, + 7, 10, 0, 0, 4304, 4305, 5, 95, 0, 0, 4305, 4306, 7, 17, 0, 0, 4306, 4307, + 7, 0, 0, 0, 4307, 4308, 7, 9, 0, 0, 4308, 4309, 7, 4, 0, 0, 4309, 4310, + 7, 6, 0, 0, 4310, 4311, 7, 3, 0, 0, 4311, 4312, 5, 95, 0, 0, 4312, 4313, + 7, 21, 0, 0, 4313, 4314, 7, 6, 0, 0, 4314, 4315, 7, 16, 0, 0, 4315, 322, + 1, 0, 0, 0, 4316, 4317, 7, 13, 0, 0, 4317, 4318, 7, 2, 0, 0, 4318, 4319, + 7, 11, 0, 0, 4319, 4320, 5, 95, 0, 0, 4320, 4321, 7, 11, 0, 0, 4321, 4322, + 7, 6, 0, 0, 4322, 4323, 7, 10, 0, 0, 4323, 4324, 7, 18, 0, 0, 4324, 4325, + 7, 4, 0, 0, 4325, 4326, 7, 19, 0, 0, 4326, 324, 1, 0, 0, 0, 4327, 4328, + 7, 13, 0, 0, 4328, 4329, 7, 2, 0, 0, 4329, 4330, 7, 11, 0, 0, 4330, 4331, + 5, 95, 0, 0, 4331, 4332, 7, 10, 0, 0, 4332, 4333, 7, 0, 0, 0, 4333, 4334, + 7, 17, 0, 0, 4334, 4335, 7, 6, 0, 0, 4335, 326, 1, 0, 0, 0, 4336, 4337, + 7, 13, 0, 0, 4337, 4338, 7, 2, 0, 0, 4338, 4339, 7, 17, 0, 0, 4339, 4340, + 7, 17, 0, 0, 4340, 4341, 7, 8, 0, 0, 4341, 4342, 7, 4, 0, 0, 4342, 328, + 1, 0, 0, 0, 4343, 4344, 7, 13, 0, 0, 4344, 4345, 7, 2, 0, 0, 4345, 4346, + 7, 17, 0, 0, 4346, 4347, 7, 17, 0, 0, 4347, 4348, 7, 8, 0, 0, 4348, 4349, + 7, 4, 0, 0, 4349, 4350, 7, 4, 0, 0, 4350, 4351, 7, 6, 0, 0, 4351, 4352, + 7, 14, 0, 0, 4352, 330, 1, 0, 0, 0, 4353, 4354, 7, 13, 0, 0, 4354, 4355, + 7, 2, 0, 0, 4355, 4356, 7, 17, 0, 0, 4356, 4357, 7, 20, 0, 0, 4357, 4358, + 7, 0, 0, 0, 4358, 4359, 7, 4, 0, 0, 4359, 4360, 7, 8, 0, 0, 4360, 4361, + 7, 1, 0, 0, 4361, 4362, 7, 8, 0, 0, 4362, 4363, 7, 11, 0, 0, 4363, 4364, + 7, 8, 0, 0, 4364, 4365, 7, 4, 0, 0, 4365, 4366, 7, 16, 0, 0, 4366, 4367, + 5, 95, 0, 0, 4367, 4368, 7, 11, 0, 0, 4368, 4369, 7, 6, 0, 0, 4369, 4370, + 7, 15, 0, 0, 4370, 4371, 7, 6, 0, 0, 4371, 4372, 7, 11, 0, 0, 4372, 332, + 1, 0, 0, 0, 4373, 4374, 7, 13, 0, 0, 4374, 4375, 7, 2, 0, 0, 4375, 4376, + 7, 17, 0, 0, 4376, 4377, 7, 20, 0, 0, 4377, 4378, 7, 3, 0, 0, 4378, 4379, + 7, 6, 0, 0, 4379, 4380, 7, 9, 0, 0, 4380, 4381, 7, 9, 0, 0, 4381, 334, + 1, 0, 0, 0, 4382, 4383, 7, 13, 0, 0, 4383, 4384, 7, 2, 0, 0, 4384, 4385, + 7, 17, 0, 0, 4385, 4386, 7, 20, 0, 0, 4386, 4387, 7, 3, 0, 0, 4387, 4388, + 7, 6, 0, 0, 4388, 4389, 7, 9, 0, 0, 4389, 4390, 7, 9, 0, 0, 4390, 4391, + 7, 8, 0, 0, 4391, 4392, 7, 2, 0, 0, 4392, 4393, 7, 10, 0, 0, 4393, 336, + 1, 0, 0, 0, 4394, 4395, 7, 13, 0, 0, 4395, 4396, 7, 2, 0, 0, 4396, 4397, + 7, 17, 0, 0, 4397, 4398, 7, 20, 0, 0, 4398, 4399, 7, 3, 0, 0, 4399, 4400, + 7, 6, 0, 0, 4400, 4401, 7, 9, 0, 0, 4401, 4402, 7, 9, 0, 0, 4402, 4403, + 7, 8, 0, 0, 4403, 4404, 7, 2, 0, 0, 4404, 4405, 7, 10, 0, 0, 4405, 4406, + 5, 95, 0, 0, 4406, 4407, 7, 14, 0, 0, 4407, 4408, 7, 6, 0, 0, 4408, 4409, + 7, 11, 0, 0, 4409, 4410, 7, 0, 0, 0, 4410, 4411, 7, 16, 0, 0, 4411, 338, + 1, 0, 0, 0, 4412, 4413, 7, 13, 0, 0, 4413, 4414, 7, 2, 0, 0, 4414, 4415, + 7, 17, 0, 0, 4415, 4416, 7, 20, 0, 0, 4416, 4417, 7, 3, 0, 0, 4417, 4418, + 7, 6, 0, 0, 4418, 4419, 7, 9, 0, 0, 4419, 4420, 7, 9, 0, 0, 4420, 4421, + 5, 95, 0, 0, 4421, 4422, 7, 0, 0, 0, 4422, 4423, 7, 11, 0, 0, 4423, 4424, + 7, 11, 0, 0, 4424, 4425, 5, 95, 0, 0, 4425, 4426, 7, 3, 0, 0, 4426, 4427, + 7, 2, 0, 0, 4427, 4428, 7, 7, 0, 0, 4428, 4429, 5, 95, 0, 0, 4429, 4430, + 7, 18, 0, 0, 4430, 4431, 7, 3, 0, 0, 4431, 4432, 7, 2, 0, 0, 4432, 4433, + 7, 12, 0, 0, 4433, 4434, 7, 20, 0, 0, 4434, 4435, 7, 9, 0, 0, 4435, 340, + 1, 0, 0, 0, 4436, 4437, 7, 13, 0, 0, 4437, 4438, 7, 2, 0, 0, 4438, 4439, + 7, 17, 0, 0, 4439, 4440, 7, 20, 0, 0, 4440, 4441, 7, 12, 0, 0, 4441, 4442, + 7, 4, 0, 0, 4442, 4443, 7, 6, 0, 0, 4443, 342, 1, 0, 0, 0, 4444, 4445, + 7, 13, 0, 0, 4445, 4446, 7, 2, 0, 0, 4446, 4447, 7, 10, 0, 0, 4447, 4448, + 7, 13, 0, 0, 4448, 4449, 7, 0, 0, 0, 4449, 4450, 7, 4, 0, 0, 4450, 344, + 1, 0, 0, 0, 4451, 4452, 7, 13, 0, 0, 4452, 4453, 7, 2, 0, 0, 4453, 4454, + 7, 10, 0, 0, 4454, 4455, 7, 13, 0, 0, 4455, 4456, 7, 0, 0, 0, 4456, 4457, + 7, 4, 0, 0, 4457, 4458, 5, 95, 0, 0, 4458, 4459, 7, 10, 0, 0, 4459, 4460, + 7, 12, 0, 0, 4460, 4461, 7, 11, 0, 0, 4461, 4462, 7, 11, 0, 0, 4462, 4463, + 5, 95, 0, 0, 4463, 4464, 7, 16, 0, 0, 4464, 4465, 7, 8, 0, 0, 4465, 4466, + 7, 6, 0, 0, 4466, 4467, 7, 11, 0, 0, 4467, 4468, 7, 14, 0, 0, 4468, 4469, + 7, 9, 0, 0, 4469, 4470, 5, 95, 0, 0, 4470, 4471, 7, 10, 0, 0, 4471, 4472, + 7, 12, 0, 0, 4472, 4473, 7, 11, 0, 0, 4473, 4474, 7, 11, 0, 0, 4474, 346, + 1, 0, 0, 0, 4475, 4476, 7, 13, 0, 0, 4476, 4477, 7, 2, 0, 0, 4477, 4478, + 7, 10, 0, 0, 4478, 4479, 7, 13, 0, 0, 4479, 4480, 7, 0, 0, 0, 4480, 4481, + 7, 4, 0, 0, 4481, 4482, 5, 95, 0, 0, 4482, 4483, 7, 7, 0, 0, 4483, 4484, + 7, 9, 0, 0, 4484, 348, 1, 0, 0, 0, 4485, 4486, 7, 13, 0, 0, 4486, 4487, + 7, 2, 0, 0, 4487, 4488, 7, 10, 0, 0, 4488, 4489, 7, 5, 0, 0, 4489, 4490, + 7, 8, 0, 0, 4490, 4491, 7, 18, 0, 0, 4491, 4492, 7, 12, 0, 0, 4492, 4493, + 7, 3, 0, 0, 4493, 4494, 7, 0, 0, 0, 4494, 4495, 7, 4, 0, 0, 4495, 4496, + 7, 8, 0, 0, 4496, 4497, 7, 2, 0, 0, 4497, 4498, 7, 10, 0, 0, 4498, 350, + 1, 0, 0, 0, 4499, 4500, 7, 13, 0, 0, 4500, 4501, 7, 2, 0, 0, 4501, 4502, + 7, 10, 0, 0, 4502, 4503, 7, 10, 0, 0, 4503, 4504, 7, 6, 0, 0, 4504, 4505, + 7, 13, 0, 0, 4505, 4506, 7, 4, 0, 0, 4506, 352, 1, 0, 0, 0, 4507, 4508, + 7, 13, 0, 0, 4508, 4509, 7, 2, 0, 0, 4509, 4510, 7, 10, 0, 0, 4510, 4511, + 7, 10, 0, 0, 4511, 4512, 7, 6, 0, 0, 4512, 4513, 7, 13, 0, 0, 4513, 4514, + 7, 4, 0, 0, 4514, 4515, 7, 8, 0, 0, 4515, 4516, 7, 2, 0, 0, 4516, 4517, + 7, 10, 0, 0, 4517, 354, 1, 0, 0, 0, 4518, 4519, 7, 13, 0, 0, 4519, 4520, + 7, 2, 0, 0, 4520, 4521, 7, 10, 0, 0, 4521, 4522, 7, 10, 0, 0, 4522, 4523, + 7, 6, 0, 0, 4523, 4524, 7, 13, 0, 0, 4524, 4525, 7, 4, 0, 0, 4525, 4526, + 7, 8, 0, 0, 4526, 4527, 7, 2, 0, 0, 4527, 4528, 7, 10, 0, 0, 4528, 4529, + 7, 20, 0, 0, 4529, 4530, 7, 3, 0, 0, 4530, 4531, 7, 2, 0, 0, 4531, 4532, + 7, 20, 0, 0, 4532, 4533, 7, 6, 0, 0, 4533, 4534, 7, 3, 0, 0, 4534, 4535, + 7, 4, 0, 0, 4535, 4536, 7, 16, 0, 0, 4536, 356, 1, 0, 0, 0, 4537, 4538, + 7, 13, 0, 0, 4538, 4539, 7, 2, 0, 0, 4539, 4540, 7, 10, 0, 0, 4540, 4541, + 7, 9, 0, 0, 4541, 4542, 7, 4, 0, 0, 4542, 4543, 7, 3, 0, 0, 4543, 4544, + 7, 0, 0, 0, 4544, 4545, 7, 8, 0, 0, 4545, 4546, 7, 10, 0, 0, 4546, 4547, + 7, 4, 0, 0, 4547, 358, 1, 0, 0, 0, 4548, 4549, 7, 13, 0, 0, 4549, 4550, + 7, 2, 0, 0, 4550, 4551, 7, 10, 0, 0, 4551, 4552, 7, 4, 0, 0, 4552, 4553, + 7, 0, 0, 0, 4553, 4554, 7, 8, 0, 0, 4554, 4555, 7, 10, 0, 0, 4555, 4556, + 7, 17, 0, 0, 4556, 4557, 7, 6, 0, 0, 4557, 4558, 7, 10, 0, 0, 4558, 4559, + 7, 4, 0, 0, 4559, 360, 1, 0, 0, 0, 4560, 4561, 7, 13, 0, 0, 4561, 4562, + 7, 2, 0, 0, 4562, 4563, 7, 10, 0, 0, 4563, 4564, 7, 4, 0, 0, 4564, 4565, + 7, 0, 0, 0, 4565, 4566, 7, 8, 0, 0, 4566, 4567, 7, 10, 0, 0, 4567, 4568, + 7, 9, 0, 0, 4568, 362, 1, 0, 0, 0, 4569, 4570, 7, 13, 0, 0, 4570, 4571, + 7, 2, 0, 0, 4571, 4572, 7, 10, 0, 0, 4572, 4573, 7, 4, 0, 0, 4573, 4574, + 7, 0, 0, 0, 4574, 4575, 7, 8, 0, 0, 4575, 4576, 7, 10, 0, 0, 4576, 4577, + 7, 9, 0, 0, 4577, 4578, 7, 4, 0, 0, 4578, 4579, 7, 0, 0, 0, 4579, 4580, + 7, 1, 0, 0, 4580, 4581, 7, 11, 0, 0, 4581, 4582, 7, 6, 0, 0, 4582, 364, + 1, 0, 0, 0, 4583, 4584, 7, 13, 0, 0, 4584, 4585, 7, 2, 0, 0, 4585, 4586, + 7, 10, 0, 0, 4586, 4587, 7, 4, 0, 0, 4587, 4588, 7, 6, 0, 0, 4588, 4589, + 7, 10, 0, 0, 4589, 4590, 7, 4, 0, 0, 4590, 366, 1, 0, 0, 0, 4591, 4592, + 7, 13, 0, 0, 4592, 4593, 7, 2, 0, 0, 4593, 4594, 7, 10, 0, 0, 4594, 4595, + 7, 4, 0, 0, 4595, 4596, 7, 6, 0, 0, 4596, 4597, 7, 22, 0, 0, 4597, 4598, + 7, 4, 0, 0, 4598, 368, 1, 0, 0, 0, 4599, 4600, 7, 13, 0, 0, 4600, 4601, + 7, 2, 0, 0, 4601, 4602, 7, 10, 0, 0, 4602, 4603, 7, 4, 0, 0, 4603, 4604, + 7, 6, 0, 0, 4604, 4605, 7, 22, 0, 0, 4605, 4606, 7, 4, 0, 0, 4606, 4607, + 5, 95, 0, 0, 4607, 4608, 7, 8, 0, 0, 4608, 4609, 7, 10, 0, 0, 4609, 4610, + 7, 5, 0, 0, 4610, 4611, 7, 2, 0, 0, 4611, 370, 1, 0, 0, 0, 4612, 4613, + 7, 13, 0, 0, 4613, 4614, 7, 2, 0, 0, 4614, 4615, 7, 10, 0, 0, 4615, 4616, + 7, 4, 0, 0, 4616, 4617, 7, 8, 0, 0, 4617, 4618, 7, 10, 0, 0, 4618, 4619, + 7, 12, 0, 0, 4619, 4620, 7, 6, 0, 0, 4620, 372, 1, 0, 0, 0, 4621, 4622, + 7, 13, 0, 0, 4622, 4623, 7, 2, 0, 0, 4623, 4624, 7, 10, 0, 0, 4624, 4625, + 7, 4, 0, 0, 4625, 4626, 7, 8, 0, 0, 4626, 4627, 7, 10, 0, 0, 4627, 4628, + 7, 12, 0, 0, 4628, 4629, 7, 6, 0, 0, 4629, 4630, 5, 95, 0, 0, 4630, 4631, + 7, 0, 0, 0, 4631, 4632, 7, 5, 0, 0, 4632, 4633, 7, 4, 0, 0, 4633, 4634, + 7, 6, 0, 0, 4634, 4635, 7, 3, 0, 0, 4635, 4636, 5, 95, 0, 0, 4636, 4637, + 7, 6, 0, 0, 4637, 4638, 7, 3, 0, 0, 4638, 4639, 7, 3, 0, 0, 4639, 4640, + 7, 2, 0, 0, 4640, 4641, 7, 3, 0, 0, 4641, 374, 1, 0, 0, 0, 4642, 4643, + 7, 13, 0, 0, 4643, 4644, 7, 2, 0, 0, 4644, 4645, 7, 10, 0, 0, 4645, 4646, + 7, 4, 0, 0, 4646, 4647, 7, 3, 0, 0, 4647, 4648, 7, 0, 0, 0, 4648, 4649, + 7, 13, 0, 0, 4649, 4650, 7, 4, 0, 0, 4650, 376, 1, 0, 0, 0, 4651, 4652, + 7, 13, 0, 0, 4652, 4653, 7, 2, 0, 0, 4653, 4654, 7, 10, 0, 0, 4654, 4655, + 7, 4, 0, 0, 4655, 4656, 7, 3, 0, 0, 4656, 4657, 7, 0, 0, 0, 4657, 4658, + 7, 13, 0, 0, 4658, 4659, 7, 4, 0, 0, 4659, 4660, 5, 95, 0, 0, 4660, 4661, + 7, 10, 0, 0, 4661, 4662, 7, 0, 0, 0, 4662, 4663, 7, 17, 0, 0, 4663, 4664, + 7, 6, 0, 0, 4664, 378, 1, 0, 0, 0, 4665, 4666, 7, 13, 0, 0, 4666, 4667, + 7, 2, 0, 0, 4667, 4668, 7, 10, 0, 0, 4668, 4669, 7, 4, 0, 0, 4669, 4670, + 7, 3, 0, 0, 4670, 4671, 7, 2, 0, 0, 4671, 4672, 7, 11, 0, 0, 4672, 380, + 1, 0, 0, 0, 4673, 4674, 7, 13, 0, 0, 4674, 4675, 7, 2, 0, 0, 4675, 4676, + 7, 10, 0, 0, 4676, 4677, 7, 15, 0, 0, 4677, 4678, 7, 6, 0, 0, 4678, 4679, + 7, 3, 0, 0, 4679, 4680, 7, 9, 0, 0, 4680, 4681, 7, 0, 0, 0, 4681, 4682, + 7, 4, 0, 0, 4682, 4683, 7, 8, 0, 0, 4683, 4684, 7, 2, 0, 0, 4684, 4685, + 7, 10, 0, 0, 4685, 382, 1, 0, 0, 0, 4686, 4687, 7, 4, 0, 0, 4687, 4688, + 7, 3, 0, 0, 4688, 4689, 7, 16, 0, 0, 4689, 4691, 5, 95, 0, 0, 4690, 4686, + 1, 0, 0, 0, 4690, 4691, 1, 0, 0, 0, 4691, 4692, 1, 0, 0, 0, 4692, 4693, + 7, 13, 0, 0, 4693, 4694, 7, 2, 0, 0, 4694, 4695, 7, 10, 0, 0, 4695, 4696, + 7, 15, 0, 0, 4696, 4697, 7, 6, 0, 0, 4697, 4698, 7, 3, 0, 0, 4698, 4699, + 7, 4, 0, 0, 4699, 384, 1, 0, 0, 0, 4700, 4701, 7, 13, 0, 0, 4701, 4702, + 7, 2, 0, 0, 4702, 4703, 7, 2, 0, 0, 4703, 4704, 7, 21, 0, 0, 4704, 4705, + 7, 8, 0, 0, 4705, 4706, 7, 6, 0, 0, 4706, 386, 1, 0, 0, 0, 4707, 4708, + 7, 13, 0, 0, 4708, 4709, 7, 2, 0, 0, 4709, 4710, 7, 20, 0, 0, 4710, 4711, + 7, 16, 0, 0, 4711, 4712, 5, 95, 0, 0, 4712, 4713, 7, 2, 0, 0, 4713, 4714, + 7, 10, 0, 0, 4714, 4715, 7, 11, 0, 0, 4715, 4716, 7, 16, 0, 0, 4716, 388, + 1, 0, 0, 0, 4717, 4718, 7, 13, 0, 0, 4718, 4719, 7, 2, 0, 0, 4719, 4720, + 7, 12, 0, 0, 4720, 4721, 7, 10, 0, 0, 4721, 4722, 7, 4, 0, 0, 4722, 390, + 1, 0, 0, 0, 4723, 4724, 7, 13, 0, 0, 4724, 4725, 7, 2, 0, 0, 4725, 4726, + 7, 12, 0, 0, 4726, 4727, 7, 10, 0, 0, 4727, 4728, 7, 4, 0, 0, 4728, 4729, + 7, 6, 0, 0, 4729, 4730, 7, 3, 0, 0, 4730, 392, 1, 0, 0, 0, 4731, 4732, + 7, 13, 0, 0, 4732, 4733, 7, 2, 0, 0, 4733, 4734, 7, 12, 0, 0, 4734, 4735, + 7, 10, 0, 0, 4735, 4736, 7, 4, 0, 0, 4736, 4737, 5, 95, 0, 0, 4737, 4738, + 7, 1, 0, 0, 4738, 4739, 7, 8, 0, 0, 4739, 4740, 7, 18, 0, 0, 4740, 394, + 1, 0, 0, 0, 4741, 4742, 7, 13, 0, 0, 4742, 4743, 7, 20, 0, 0, 4743, 4744, + 7, 12, 0, 0, 4744, 396, 1, 0, 0, 0, 4745, 4746, 7, 13, 0, 0, 4746, 4747, + 7, 3, 0, 0, 4747, 4748, 7, 6, 0, 0, 4748, 4749, 7, 0, 0, 0, 4749, 4750, + 7, 4, 0, 0, 4750, 4751, 7, 6, 0, 0, 4751, 398, 1, 0, 0, 0, 4752, 4753, + 7, 13, 0, 0, 4753, 4754, 7, 3, 0, 0, 4754, 4755, 7, 6, 0, 0, 4755, 4756, + 7, 0, 0, 0, 4756, 4757, 7, 4, 0, 0, 4757, 4758, 7, 6, 0, 0, 4758, 4759, + 5, 95, 0, 0, 4759, 4760, 7, 10, 0, 0, 4760, 4761, 7, 6, 0, 0, 4761, 4762, + 7, 7, 0, 0, 4762, 400, 1, 0, 0, 0, 4763, 4764, 7, 13, 0, 0, 4764, 4765, + 7, 3, 0, 0, 4765, 4766, 7, 6, 0, 0, 4766, 4767, 7, 0, 0, 0, 4767, 4768, + 7, 4, 0, 0, 4768, 4769, 7, 8, 0, 0, 4769, 4770, 7, 2, 0, 0, 4770, 4771, + 7, 10, 0, 0, 4771, 4772, 5, 95, 0, 0, 4772, 4773, 7, 14, 0, 0, 4773, 4774, + 7, 8, 0, 0, 4774, 4775, 7, 9, 0, 0, 4775, 4776, 7, 20, 0, 0, 4776, 4777, + 7, 2, 0, 0, 4777, 4778, 7, 9, 0, 0, 4778, 4779, 7, 8, 0, 0, 4779, 4780, + 7, 4, 0, 0, 4780, 4781, 7, 8, 0, 0, 4781, 4782, 7, 2, 0, 0, 4782, 4783, + 7, 10, 0, 0, 4783, 402, 1, 0, 0, 0, 4784, 4785, 7, 13, 0, 0, 4785, 4786, + 7, 3, 0, 0, 4786, 4787, 7, 6, 0, 0, 4787, 4788, 7, 14, 0, 0, 4788, 4789, + 7, 6, 0, 0, 4789, 4790, 7, 10, 0, 0, 4790, 4791, 7, 4, 0, 0, 4791, 4792, + 7, 8, 0, 0, 4792, 4793, 7, 0, 0, 0, 4793, 4794, 7, 11, 0, 0, 4794, 404, + 1, 0, 0, 0, 4795, 4796, 7, 13, 0, 0, 4796, 4797, 7, 3, 0, 0, 4797, 4798, + 7, 2, 0, 0, 4798, 4799, 7, 9, 0, 0, 4799, 4800, 7, 9, 0, 0, 4800, 406, + 1, 0, 0, 0, 4801, 4802, 7, 13, 0, 0, 4802, 4803, 7, 3, 0, 0, 4803, 4804, + 7, 16, 0, 0, 4804, 4805, 7, 20, 0, 0, 4805, 4806, 7, 4, 0, 0, 4806, 4807, + 7, 2, 0, 0, 4807, 4808, 7, 18, 0, 0, 4808, 4809, 7, 3, 0, 0, 4809, 4810, + 7, 0, 0, 0, 4810, 4811, 7, 20, 0, 0, 4811, 4812, 7, 19, 0, 0, 4812, 4813, + 7, 8, 0, 0, 4813, 4814, 7, 13, 0, 0, 4814, 408, 1, 0, 0, 0, 4815, 4816, + 7, 13, 0, 0, 4816, 4817, 7, 12, 0, 0, 4817, 4818, 7, 17, 0, 0, 4818, 4819, + 7, 6, 0, 0, 4819, 4820, 5, 95, 0, 0, 4820, 4821, 7, 14, 0, 0, 4821, 4822, + 7, 8, 0, 0, 4822, 4823, 7, 9, 0, 0, 4823, 4824, 7, 4, 0, 0, 4824, 410, + 1, 0, 0, 0, 4825, 4826, 7, 13, 0, 0, 4826, 4827, 7, 12, 0, 0, 4827, 4828, + 7, 3, 0, 0, 4828, 4829, 7, 3, 0, 0, 4829, 4830, 7, 6, 0, 0, 4830, 4831, + 7, 10, 0, 0, 4831, 4832, 7, 4, 0, 0, 4832, 412, 1, 0, 0, 0, 4833, 4834, + 7, 13, 0, 0, 4834, 4835, 7, 12, 0, 0, 4835, 4836, 7, 3, 0, 0, 4836, 4837, + 7, 3, 0, 0, 4837, 4838, 7, 6, 0, 0, 4838, 4839, 7, 10, 0, 0, 4839, 4840, + 7, 4, 0, 0, 4840, 4841, 5, 95, 0, 0, 4841, 4842, 7, 14, 0, 0, 4842, 4843, + 7, 0, 0, 0, 4843, 4844, 7, 4, 0, 0, 4844, 4845, 7, 6, 0, 0, 4845, 414, + 1, 0, 0, 0, 4846, 4847, 7, 13, 0, 0, 4847, 4848, 7, 12, 0, 0, 4848, 4849, + 7, 3, 0, 0, 4849, 4850, 7, 3, 0, 0, 4850, 4851, 7, 6, 0, 0, 4851, 4852, + 7, 10, 0, 0, 4852, 4853, 7, 4, 0, 0, 4853, 4854, 5, 95, 0, 0, 4854, 4855, + 7, 3, 0, 0, 4855, 4856, 7, 6, 0, 0, 4856, 4857, 7, 25, 0, 0, 4857, 4858, + 7, 12, 0, 0, 4858, 4859, 7, 6, 0, 0, 4859, 4860, 7, 9, 0, 0, 4860, 4861, + 7, 4, 0, 0, 4861, 4862, 5, 95, 0, 0, 4862, 4863, 7, 8, 0, 0, 4863, 4864, + 7, 14, 0, 0, 4864, 416, 1, 0, 0, 0, 4865, 4866, 7, 13, 0, 0, 4866, 4867, + 7, 12, 0, 0, 4867, 4868, 7, 3, 0, 0, 4868, 4869, 7, 3, 0, 0, 4869, 4870, + 7, 6, 0, 0, 4870, 4871, 7, 10, 0, 0, 4871, 4872, 7, 4, 0, 0, 4872, 4873, + 5, 95, 0, 0, 4873, 4874, 7, 4, 0, 0, 4874, 4875, 7, 8, 0, 0, 4875, 4876, + 7, 17, 0, 0, 4876, 4877, 7, 6, 0, 0, 4877, 418, 1, 0, 0, 0, 4878, 4879, + 7, 13, 0, 0, 4879, 4880, 7, 12, 0, 0, 4880, 4881, 7, 3, 0, 0, 4881, 4882, + 7, 3, 0, 0, 4882, 4883, 7, 6, 0, 0, 4883, 4884, 7, 10, 0, 0, 4884, 4885, + 7, 4, 0, 0, 4885, 4886, 5, 95, 0, 0, 4886, 4887, 7, 4, 0, 0, 4887, 4888, + 7, 8, 0, 0, 4888, 4889, 7, 17, 0, 0, 4889, 4890, 7, 6, 0, 0, 4890, 4891, + 7, 9, 0, 0, 4891, 4892, 7, 4, 0, 0, 4892, 4893, 7, 0, 0, 0, 4893, 4894, + 7, 17, 0, 0, 4894, 4895, 7, 20, 0, 0, 4895, 420, 1, 0, 0, 0, 4896, 4897, + 7, 13, 0, 0, 4897, 4898, 7, 12, 0, 0, 4898, 4899, 7, 3, 0, 0, 4899, 4900, + 7, 3, 0, 0, 4900, 4901, 7, 6, 0, 0, 4901, 4902, 7, 10, 0, 0, 4902, 4903, + 7, 4, 0, 0, 4903, 4904, 5, 95, 0, 0, 4904, 4905, 7, 4, 0, 0, 4905, 4906, + 7, 3, 0, 0, 4906, 4907, 7, 0, 0, 0, 4907, 4908, 7, 10, 0, 0, 4908, 4909, + 7, 9, 0, 0, 4909, 4910, 7, 0, 0, 0, 4910, 4911, 7, 13, 0, 0, 4911, 4912, + 7, 4, 0, 0, 4912, 4913, 7, 8, 0, 0, 4913, 4914, 7, 2, 0, 0, 4914, 4915, + 7, 10, 0, 0, 4915, 4916, 5, 95, 0, 0, 4916, 4917, 7, 8, 0, 0, 4917, 4918, + 7, 14, 0, 0, 4918, 422, 1, 0, 0, 0, 4919, 4920, 7, 13, 0, 0, 4920, 4921, + 7, 12, 0, 0, 4921, 4922, 7, 3, 0, 0, 4922, 4923, 7, 3, 0, 0, 4923, 4924, + 7, 6, 0, 0, 4924, 4925, 7, 10, 0, 0, 4925, 4926, 7, 4, 0, 0, 4926, 4927, + 5, 95, 0, 0, 4927, 4928, 7, 12, 0, 0, 4928, 4929, 7, 9, 0, 0, 4929, 4930, + 7, 6, 0, 0, 4930, 4931, 7, 3, 0, 0, 4931, 424, 1, 0, 0, 0, 4932, 4933, + 7, 13, 0, 0, 4933, 4934, 7, 12, 0, 0, 4934, 4935, 7, 3, 0, 0, 4935, 4936, + 7, 9, 0, 0, 4936, 4937, 7, 2, 0, 0, 4937, 4938, 7, 3, 0, 0, 4938, 426, + 1, 0, 0, 0, 4939, 4940, 7, 13, 0, 0, 4940, 4941, 7, 12, 0, 0, 4941, 4942, + 7, 3, 0, 0, 4942, 4943, 7, 9, 0, 0, 4943, 4944, 7, 2, 0, 0, 4944, 4945, + 7, 3, 0, 0, 4945, 4946, 5, 95, 0, 0, 4946, 4947, 7, 13, 0, 0, 4947, 4948, + 7, 11, 0, 0, 4948, 4949, 7, 2, 0, 0, 4949, 4950, 7, 9, 0, 0, 4950, 4951, + 7, 6, 0, 0, 4951, 4952, 5, 95, 0, 0, 4952, 4953, 7, 2, 0, 0, 4953, 4954, + 7, 10, 0, 0, 4954, 4955, 5, 95, 0, 0, 4955, 4956, 7, 13, 0, 0, 4956, 4957, + 7, 2, 0, 0, 4957, 4958, 7, 17, 0, 0, 4958, 4959, 7, 17, 0, 0, 4959, 4960, + 7, 8, 0, 0, 4960, 4961, 7, 4, 0, 0, 4961, 428, 1, 0, 0, 0, 4962, 4963, + 7, 13, 0, 0, 4963, 4964, 7, 12, 0, 0, 4964, 4965, 7, 3, 0, 0, 4965, 4966, + 7, 9, 0, 0, 4966, 4967, 7, 2, 0, 0, 4967, 4968, 7, 3, 0, 0, 4968, 4969, + 5, 95, 0, 0, 4969, 4970, 7, 14, 0, 0, 4970, 4971, 7, 6, 0, 0, 4971, 4972, + 7, 5, 0, 0, 4972, 4973, 7, 0, 0, 0, 4973, 4974, 7, 12, 0, 0, 4974, 4975, + 7, 11, 0, 0, 4975, 4976, 7, 4, 0, 0, 4976, 430, 1, 0, 0, 0, 4977, 4978, + 7, 13, 0, 0, 4978, 4979, 7, 12, 0, 0, 4979, 4980, 7, 3, 0, 0, 4980, 4981, + 7, 9, 0, 0, 4981, 4982, 7, 2, 0, 0, 4982, 4983, 7, 3, 0, 0, 4983, 4984, + 5, 95, 0, 0, 4984, 4985, 7, 9, 0, 0, 4985, 4986, 7, 4, 0, 0, 4986, 4987, + 7, 0, 0, 0, 4987, 4988, 7, 4, 0, 0, 4988, 4989, 7, 12, 0, 0, 4989, 4990, + 7, 9, 0, 0, 4990, 432, 1, 0, 0, 0, 4991, 4992, 7, 13, 0, 0, 4992, 4993, + 7, 16, 0, 0, 4993, 4994, 7, 13, 0, 0, 4994, 4995, 7, 11, 0, 0, 4995, 4996, + 7, 6, 0, 0, 4996, 434, 1, 0, 0, 0, 4997, 4998, 7, 14, 0, 0, 4998, 4999, + 7, 0, 0, 0, 4999, 5000, 7, 4, 0, 0, 5000, 5001, 7, 0, 0, 0, 5001, 436, + 1, 0, 0, 0, 5002, 5003, 7, 14, 0, 0, 5003, 5004, 7, 0, 0, 0, 5004, 5005, + 7, 4, 0, 0, 5005, 5006, 7, 0, 0, 0, 5006, 5007, 7, 1, 0, 0, 5007, 5008, + 7, 0, 0, 0, 5008, 5009, 7, 9, 0, 0, 5009, 5010, 7, 6, 0, 0, 5010, 438, + 1, 0, 0, 0, 5011, 5012, 7, 14, 0, 0, 5012, 5013, 7, 0, 0, 0, 5013, 5014, + 7, 4, 0, 0, 5014, 5015, 7, 0, 0, 0, 5015, 5016, 7, 1, 0, 0, 5016, 5017, + 7, 0, 0, 0, 5017, 5018, 7, 9, 0, 0, 5018, 5019, 7, 6, 0, 0, 5019, 5020, + 7, 20, 0, 0, 5020, 5021, 7, 3, 0, 0, 5021, 5022, 7, 2, 0, 0, 5022, 5023, + 7, 20, 0, 0, 5023, 5024, 7, 6, 0, 0, 5024, 5025, 7, 3, 0, 0, 5025, 5026, + 7, 4, 0, 0, 5026, 5027, 7, 16, 0, 0, 5027, 5028, 7, 6, 0, 0, 5028, 5029, + 7, 22, 0, 0, 5029, 440, 1, 0, 0, 0, 5030, 5031, 7, 14, 0, 0, 5031, 5032, + 7, 0, 0, 0, 5032, 5033, 7, 4, 0, 0, 5033, 5034, 7, 0, 0, 0, 5034, 5035, + 7, 1, 0, 0, 5035, 5036, 7, 0, 0, 0, 5036, 5037, 7, 9, 0, 0, 5037, 5038, + 7, 6, 0, 0, 5038, 5039, 5, 95, 0, 0, 5039, 5040, 7, 17, 0, 0, 5040, 5041, + 7, 8, 0, 0, 5041, 5042, 7, 3, 0, 0, 5042, 5043, 7, 3, 0, 0, 5043, 5044, + 7, 2, 0, 0, 5044, 5045, 7, 3, 0, 0, 5045, 5046, 7, 8, 0, 0, 5046, 5047, + 7, 10, 0, 0, 5047, 5048, 7, 18, 0, 0, 5048, 442, 1, 0, 0, 0, 5049, 5050, + 7, 14, 0, 0, 5050, 5051, 7, 0, 0, 0, 5051, 5052, 7, 4, 0, 0, 5052, 5053, + 7, 0, 0, 0, 5053, 5054, 7, 1, 0, 0, 5054, 5055, 7, 0, 0, 0, 5055, 5056, + 7, 9, 0, 0, 5056, 5057, 7, 6, 0, 0, 5057, 5058, 5, 95, 0, 0, 5058, 5059, + 7, 20, 0, 0, 5059, 5060, 7, 3, 0, 0, 5060, 5061, 7, 8, 0, 0, 5061, 5062, + 7, 10, 0, 0, 5062, 5063, 7, 13, 0, 0, 5063, 5064, 7, 8, 0, 0, 5064, 5065, + 7, 20, 0, 0, 5065, 5066, 7, 0, 0, 0, 5066, 5067, 7, 11, 0, 0, 5067, 5068, + 5, 95, 0, 0, 5068, 5069, 7, 8, 0, 0, 5069, 5070, 7, 14, 0, 0, 5070, 444, + 1, 0, 0, 0, 5071, 5072, 7, 14, 0, 0, 5072, 5073, 7, 0, 0, 0, 5073, 5074, + 7, 4, 0, 0, 5074, 5075, 7, 0, 0, 0, 5075, 5076, 7, 11, 0, 0, 5076, 5077, + 7, 6, 0, 0, 5077, 5078, 7, 10, 0, 0, 5078, 5079, 7, 18, 0, 0, 5079, 5080, + 7, 4, 0, 0, 5080, 5081, 7, 19, 0, 0, 5081, 446, 1, 0, 0, 0, 5082, 5083, + 7, 14, 0, 0, 5083, 5084, 7, 0, 0, 0, 5084, 5085, 7, 4, 0, 0, 5085, 5086, + 7, 0, 0, 0, 5086, 5087, 7, 9, 0, 0, 5087, 5088, 7, 20, 0, 0, 5088, 5089, + 7, 0, 0, 0, 5089, 5090, 7, 13, 0, 0, 5090, 5091, 7, 6, 0, 0, 5091, 448, + 1, 0, 0, 0, 5092, 5093, 7, 14, 0, 0, 5093, 5094, 7, 0, 0, 0, 5094, 5095, + 7, 4, 0, 0, 5095, 5096, 7, 0, 0, 0, 5096, 5097, 5, 95, 0, 0, 5097, 5098, + 7, 13, 0, 0, 5098, 5099, 7, 2, 0, 0, 5099, 5100, 7, 17, 0, 0, 5100, 5101, + 7, 20, 0, 0, 5101, 5102, 7, 3, 0, 0, 5102, 5103, 7, 6, 0, 0, 5103, 5104, + 7, 9, 0, 0, 5104, 5105, 7, 9, 0, 0, 5105, 5106, 7, 8, 0, 0, 5106, 5107, + 7, 2, 0, 0, 5107, 5108, 7, 10, 0, 0, 5108, 450, 1, 0, 0, 0, 5109, 5110, + 7, 14, 0, 0, 5110, 5111, 7, 0, 0, 0, 5111, 5112, 7, 4, 0, 0, 5112, 5113, + 7, 0, 0, 0, 5113, 5114, 5, 95, 0, 0, 5114, 5115, 7, 20, 0, 0, 5115, 5116, + 7, 12, 0, 0, 5116, 5117, 7, 3, 0, 0, 5117, 5118, 7, 8, 0, 0, 5118, 5119, + 7, 4, 0, 0, 5119, 5120, 7, 16, 0, 0, 5120, 452, 1, 0, 0, 0, 5121, 5122, + 7, 14, 0, 0, 5122, 5123, 7, 0, 0, 0, 5123, 5124, 7, 4, 0, 0, 5124, 5125, + 7, 0, 0, 0, 5125, 5126, 5, 95, 0, 0, 5126, 5127, 7, 9, 0, 0, 5127, 5128, + 7, 2, 0, 0, 5128, 5129, 7, 12, 0, 0, 5129, 5130, 7, 3, 0, 0, 5130, 5131, + 7, 13, 0, 0, 5131, 5132, 7, 6, 0, 0, 5132, 454, 1, 0, 0, 0, 5133, 5134, + 7, 14, 0, 0, 5134, 5135, 7, 0, 0, 0, 5135, 5136, 7, 4, 0, 0, 5136, 5137, + 7, 6, 0, 0, 5137, 5138, 7, 0, 0, 0, 5138, 5139, 7, 14, 0, 0, 5139, 5140, + 7, 14, 0, 0, 5140, 456, 1, 0, 0, 0, 5141, 5142, 7, 14, 0, 0, 5142, 5143, + 7, 0, 0, 0, 5143, 5144, 7, 4, 0, 0, 5144, 5145, 7, 6, 0, 0, 5145, 5146, + 7, 14, 0, 0, 5146, 5147, 7, 8, 0, 0, 5147, 5148, 7, 5, 0, 0, 5148, 5149, + 7, 5, 0, 0, 5149, 458, 1, 0, 0, 0, 5150, 5151, 7, 14, 0, 0, 5151, 5152, + 7, 0, 0, 0, 5152, 5153, 7, 4, 0, 0, 5153, 5154, 7, 6, 0, 0, 5154, 5155, + 7, 10, 0, 0, 5155, 5156, 7, 0, 0, 0, 5156, 5157, 7, 17, 0, 0, 5157, 5158, + 7, 6, 0, 0, 5158, 460, 1, 0, 0, 0, 5159, 5160, 7, 14, 0, 0, 5160, 5161, + 7, 0, 0, 0, 5161, 5162, 7, 4, 0, 0, 5162, 5163, 7, 6, 0, 0, 5163, 5164, + 7, 20, 0, 0, 5164, 5165, 7, 0, 0, 0, 5165, 5166, 7, 3, 0, 0, 5166, 5167, + 7, 4, 0, 0, 5167, 462, 1, 0, 0, 0, 5168, 5169, 7, 14, 0, 0, 5169, 5170, + 7, 0, 0, 0, 5170, 5171, 7, 4, 0, 0, 5171, 5172, 7, 6, 0, 0, 5172, 5173, + 5, 95, 0, 0, 5173, 5174, 7, 13, 0, 0, 5174, 5175, 7, 2, 0, 0, 5175, 5176, + 7, 3, 0, 0, 5176, 5177, 7, 3, 0, 0, 5177, 5178, 7, 6, 0, 0, 5178, 5179, + 7, 11, 0, 0, 5179, 5180, 7, 0, 0, 0, 5180, 5181, 7, 4, 0, 0, 5181, 5182, + 7, 8, 0, 0, 5182, 5183, 7, 2, 0, 0, 5183, 5184, 7, 10, 0, 0, 5184, 5185, + 5, 95, 0, 0, 5185, 5186, 7, 2, 0, 0, 5186, 5187, 7, 20, 0, 0, 5187, 5188, + 7, 4, 0, 0, 5188, 5189, 7, 8, 0, 0, 5189, 5190, 7, 17, 0, 0, 5190, 5191, + 7, 8, 0, 0, 5191, 5192, 7, 23, 0, 0, 5192, 5193, 7, 0, 0, 0, 5193, 5194, + 7, 4, 0, 0, 5194, 5195, 7, 8, 0, 0, 5195, 5196, 7, 2, 0, 0, 5196, 5197, + 7, 10, 0, 0, 5197, 464, 1, 0, 0, 0, 5198, 5199, 7, 14, 0, 0, 5199, 5200, + 7, 0, 0, 0, 5200, 5201, 7, 16, 0, 0, 5201, 5202, 7, 9, 0, 0, 5202, 466, + 1, 0, 0, 0, 5203, 5204, 7, 14, 0, 0, 5204, 5205, 7, 1, 0, 0, 5205, 5206, + 7, 13, 0, 0, 5206, 5207, 7, 13, 0, 0, 5207, 468, 1, 0, 0, 0, 5208, 5209, + 7, 14, 0, 0, 5209, 5210, 7, 1, 0, 0, 5210, 5211, 7, 3, 0, 0, 5211, 5212, + 7, 6, 0, 0, 5212, 5213, 7, 8, 0, 0, 5213, 5214, 7, 10, 0, 0, 5214, 5215, + 7, 14, 0, 0, 5215, 5216, 7, 6, 0, 0, 5216, 5217, 7, 22, 0, 0, 5217, 470, + 1, 0, 0, 0, 5218, 5219, 7, 14, 0, 0, 5219, 5220, 7, 1, 0, 0, 5220, 5221, + 5, 95, 0, 0, 5221, 5222, 7, 13, 0, 0, 5222, 5223, 7, 19, 0, 0, 5223, 5224, + 7, 0, 0, 0, 5224, 5225, 7, 8, 0, 0, 5225, 5226, 7, 10, 0, 0, 5226, 5227, + 7, 8, 0, 0, 5227, 5228, 7, 10, 0, 0, 5228, 5229, 7, 18, 0, 0, 5229, 472, + 1, 0, 0, 0, 5230, 5231, 7, 14, 0, 0, 5231, 5232, 7, 1, 0, 0, 5232, 5233, + 5, 95, 0, 0, 5233, 5234, 7, 5, 0, 0, 5234, 5235, 7, 0, 0, 0, 5235, 5236, + 7, 8, 0, 0, 5236, 5237, 7, 11, 0, 0, 5237, 5238, 7, 2, 0, 0, 5238, 5239, + 7, 15, 0, 0, 5239, 5240, 7, 6, 0, 0, 5240, 5241, 7, 3, 0, 0, 5241, 474, + 1, 0, 0, 0, 5242, 5243, 7, 14, 0, 0, 5243, 5244, 7, 1, 0, 0, 5244, 5245, + 5, 95, 0, 0, 5245, 5246, 7, 8, 0, 0, 5246, 5247, 7, 14, 0, 0, 5247, 476, + 1, 0, 0, 0, 5248, 5249, 7, 14, 0, 0, 5249, 5250, 7, 1, 0, 0, 5250, 5251, + 5, 95, 0, 0, 5251, 5252, 7, 10, 0, 0, 5252, 5253, 7, 0, 0, 0, 5253, 5254, + 7, 17, 0, 0, 5254, 5255, 7, 6, 0, 0, 5255, 478, 1, 0, 0, 0, 5256, 5257, + 7, 14, 0, 0, 5257, 5258, 7, 14, 0, 0, 5258, 5259, 7, 11, 0, 0, 5259, 480, + 1, 0, 0, 0, 5260, 5261, 7, 14, 0, 0, 5261, 5262, 7, 6, 0, 0, 5262, 5263, + 7, 0, 0, 0, 5263, 5264, 7, 11, 0, 0, 5264, 5265, 7, 11, 0, 0, 5265, 5266, + 7, 2, 0, 0, 5266, 5267, 7, 13, 0, 0, 5267, 5268, 7, 0, 0, 0, 5268, 5269, + 7, 4, 0, 0, 5269, 5270, 7, 6, 0, 0, 5270, 482, 1, 0, 0, 0, 5271, 5272, + 7, 14, 0, 0, 5272, 5273, 7, 6, 0, 0, 5273, 5274, 7, 13, 0, 0, 5274, 5275, + 7, 11, 0, 0, 5275, 5276, 7, 0, 0, 0, 5276, 5277, 7, 3, 0, 0, 5277, 5278, + 7, 6, 0, 0, 5278, 484, 1, 0, 0, 0, 5279, 5280, 7, 14, 0, 0, 5280, 5281, + 7, 6, 0, 0, 5281, 5282, 7, 13, 0, 0, 5282, 5283, 7, 2, 0, 0, 5283, 5284, + 7, 17, 0, 0, 5284, 5285, 7, 20, 0, 0, 5285, 5286, 7, 3, 0, 0, 5286, 5287, + 7, 6, 0, 0, 5287, 5288, 7, 9, 0, 0, 5288, 5289, 7, 9, 0, 0, 5289, 486, + 1, 0, 0, 0, 5290, 5291, 7, 14, 0, 0, 5291, 5292, 7, 6, 0, 0, 5292, 5293, + 7, 13, 0, 0, 5293, 5294, 7, 3, 0, 0, 5294, 5295, 7, 16, 0, 0, 5295, 5296, + 7, 20, 0, 0, 5296, 5297, 7, 4, 0, 0, 5297, 5298, 7, 8, 0, 0, 5298, 5299, + 7, 2, 0, 0, 5299, 5300, 7, 10, 0, 0, 5300, 488, 1, 0, 0, 0, 5301, 5302, + 7, 14, 0, 0, 5302, 5303, 7, 6, 0, 0, 5303, 5304, 7, 5, 0, 0, 5304, 5305, + 7, 0, 0, 0, 5305, 5306, 7, 12, 0, 0, 5306, 5307, 7, 11, 0, 0, 5307, 5308, + 7, 4, 0, 0, 5308, 490, 1, 0, 0, 0, 5309, 5310, 7, 14, 0, 0, 5310, 5311, + 7, 6, 0, 0, 5311, 5312, 7, 5, 0, 0, 5312, 5313, 7, 0, 0, 0, 5313, 5314, + 7, 12, 0, 0, 5314, 5315, 7, 11, 0, 0, 5315, 5316, 7, 4, 0, 0, 5316, 5317, + 5, 95, 0, 0, 5317, 5318, 7, 14, 0, 0, 5318, 5319, 7, 0, 0, 0, 5319, 5320, + 7, 4, 0, 0, 5320, 5321, 7, 0, 0, 0, 5321, 5322, 7, 1, 0, 0, 5322, 5323, + 7, 0, 0, 0, 5323, 5324, 7, 9, 0, 0, 5324, 5325, 7, 6, 0, 0, 5325, 492, + 1, 0, 0, 0, 5326, 5327, 7, 26, 0, 0, 5327, 5328, 7, 14, 0, 0, 5328, 5329, + 7, 6, 0, 0, 5329, 5330, 7, 5, 0, 0, 5330, 5331, 7, 0, 0, 0, 5331, 5332, + 7, 12, 0, 0, 5332, 5333, 7, 11, 0, 0, 5333, 5334, 7, 4, 0, 0, 5334, 5335, + 1, 0, 0, 0, 5335, 5336, 7, 26, 0, 0, 5336, 494, 1, 0, 0, 0, 5337, 5338, + 7, 14, 0, 0, 5338, 5339, 7, 6, 0, 0, 5339, 5340, 7, 5, 0, 0, 5340, 5341, + 7, 0, 0, 0, 5341, 5342, 7, 12, 0, 0, 5342, 5343, 7, 11, 0, 0, 5343, 5344, + 7, 4, 0, 0, 5344, 5345, 5, 95, 0, 0, 5345, 5346, 7, 5, 0, 0, 5346, 5347, + 7, 12, 0, 0, 5347, 5348, 7, 11, 0, 0, 5348, 5349, 7, 11, 0, 0, 5349, 5350, + 7, 4, 0, 0, 5350, 5351, 7, 6, 0, 0, 5351, 5352, 7, 22, 0, 0, 5352, 5353, + 7, 4, 0, 0, 5353, 5354, 5, 95, 0, 0, 5354, 5355, 7, 11, 0, 0, 5355, 5356, + 7, 0, 0, 0, 5356, 5357, 7, 10, 0, 0, 5357, 5358, 7, 18, 0, 0, 5358, 5359, + 7, 12, 0, 0, 5359, 5360, 7, 0, 0, 0, 5360, 5361, 7, 18, 0, 0, 5361, 5362, + 7, 6, 0, 0, 5362, 496, 1, 0, 0, 0, 5363, 5364, 7, 14, 0, 0, 5364, 5365, + 7, 6, 0, 0, 5365, 5366, 7, 5, 0, 0, 5366, 5367, 7, 0, 0, 0, 5367, 5368, + 7, 12, 0, 0, 5368, 5369, 7, 11, 0, 0, 5369, 5370, 7, 4, 0, 0, 5370, 5371, + 5, 95, 0, 0, 5371, 5372, 7, 11, 0, 0, 5372, 5373, 7, 0, 0, 0, 5373, 5374, + 7, 10, 0, 0, 5374, 5375, 7, 18, 0, 0, 5375, 5376, 7, 12, 0, 0, 5376, 5377, + 7, 0, 0, 0, 5377, 5378, 7, 18, 0, 0, 5378, 5379, 7, 6, 0, 0, 5379, 498, + 1, 0, 0, 0, 5380, 5381, 7, 14, 0, 0, 5381, 5382, 7, 6, 0, 0, 5382, 5383, + 7, 5, 0, 0, 5383, 5384, 7, 0, 0, 0, 5384, 5385, 7, 12, 0, 0, 5385, 5386, + 7, 11, 0, 0, 5386, 5387, 7, 4, 0, 0, 5387, 5388, 5, 95, 0, 0, 5388, 5389, + 7, 9, 0, 0, 5389, 5390, 7, 13, 0, 0, 5390, 5391, 7, 19, 0, 0, 5391, 5392, + 7, 6, 0, 0, 5392, 5393, 7, 17, 0, 0, 5393, 5394, 7, 0, 0, 0, 5394, 500, + 1, 0, 0, 0, 5395, 5396, 7, 14, 0, 0, 5396, 5397, 7, 6, 0, 0, 5397, 5398, + 7, 5, 0, 0, 5398, 5399, 7, 8, 0, 0, 5399, 5400, 7, 10, 0, 0, 5400, 5401, + 7, 8, 0, 0, 5401, 5402, 7, 4, 0, 0, 5402, 5403, 7, 8, 0, 0, 5403, 5404, + 7, 2, 0, 0, 5404, 5405, 7, 10, 0, 0, 5405, 502, 1, 0, 0, 0, 5406, 5407, + 7, 14, 0, 0, 5407, 5408, 7, 6, 0, 0, 5408, 5409, 7, 11, 0, 0, 5409, 5410, + 7, 0, 0, 0, 5410, 5411, 7, 16, 0, 0, 5411, 504, 1, 0, 0, 0, 5412, 5413, + 7, 14, 0, 0, 5413, 5414, 7, 6, 0, 0, 5414, 5415, 7, 11, 0, 0, 5415, 5416, + 7, 0, 0, 0, 5416, 5417, 7, 16, 0, 0, 5417, 5418, 7, 6, 0, 0, 5418, 5419, + 7, 14, 0, 0, 5419, 5420, 5, 95, 0, 0, 5420, 5421, 7, 14, 0, 0, 5421, 5422, + 7, 12, 0, 0, 5422, 5423, 7, 3, 0, 0, 5423, 5424, 7, 0, 0, 0, 5424, 5425, + 7, 1, 0, 0, 5425, 5426, 7, 8, 0, 0, 5426, 5427, 7, 11, 0, 0, 5427, 5428, + 7, 8, 0, 0, 5428, 5429, 7, 4, 0, 0, 5429, 5430, 7, 16, 0, 0, 5430, 506, + 1, 0, 0, 0, 5431, 5432, 7, 14, 0, 0, 5432, 5433, 7, 6, 0, 0, 5433, 5434, + 7, 11, 0, 0, 5434, 5435, 7, 6, 0, 0, 5435, 5436, 7, 4, 0, 0, 5436, 5437, + 7, 6, 0, 0, 5437, 508, 1, 0, 0, 0, 5438, 5439, 7, 14, 0, 0, 5439, 5440, + 7, 6, 0, 0, 5440, 5441, 7, 11, 0, 0, 5441, 5442, 7, 6, 0, 0, 5442, 5443, + 7, 4, 0, 0, 5443, 5444, 7, 6, 0, 0, 5444, 5445, 7, 14, 0, 0, 5445, 510, + 1, 0, 0, 0, 5446, 5447, 7, 14, 0, 0, 5447, 5448, 7, 6, 0, 0, 5448, 5449, + 7, 10, 0, 0, 5449, 5450, 7, 9, 0, 0, 5450, 5451, 7, 6, 0, 0, 5451, 5452, + 5, 95, 0, 0, 5452, 5453, 7, 3, 0, 0, 5453, 5454, 7, 0, 0, 0, 5454, 5455, + 7, 10, 0, 0, 5455, 5456, 7, 21, 0, 0, 5456, 512, 1, 0, 0, 0, 5457, 5458, + 7, 14, 0, 0, 5458, 5459, 7, 6, 0, 0, 5459, 5460, 7, 10, 0, 0, 5460, 5461, + 7, 16, 0, 0, 5461, 514, 1, 0, 0, 0, 5462, 5463, 7, 14, 0, 0, 5463, 5464, + 7, 6, 0, 0, 5464, 5465, 7, 20, 0, 0, 5465, 5466, 7, 6, 0, 0, 5466, 5467, + 7, 10, 0, 0, 5467, 5468, 7, 14, 0, 0, 5468, 5469, 7, 6, 0, 0, 5469, 5470, + 7, 10, 0, 0, 5470, 5471, 7, 4, 0, 0, 5471, 5472, 7, 9, 0, 0, 5472, 516, + 1, 0, 0, 0, 5473, 5474, 7, 14, 0, 0, 5474, 5475, 7, 6, 0, 0, 5475, 5476, + 7, 9, 0, 0, 5476, 518, 1, 0, 0, 0, 5477, 5478, 7, 14, 0, 0, 5478, 5479, + 7, 6, 0, 0, 5479, 5480, 7, 9, 0, 0, 5480, 5481, 7, 13, 0, 0, 5481, 520, + 1, 0, 0, 0, 5482, 5483, 7, 14, 0, 0, 5483, 5484, 7, 6, 0, 0, 5484, 5485, + 7, 9, 0, 0, 5485, 5486, 7, 13, 0, 0, 5486, 5487, 7, 3, 0, 0, 5487, 5488, + 7, 8, 0, 0, 5488, 5489, 7, 20, 0, 0, 5489, 5490, 7, 4, 0, 0, 5490, 5491, + 7, 8, 0, 0, 5491, 5492, 7, 2, 0, 0, 5492, 5493, 7, 10, 0, 0, 5493, 522, + 1, 0, 0, 0, 5494, 5495, 7, 14, 0, 0, 5495, 5496, 7, 6, 0, 0, 5496, 5497, + 7, 9, 0, 0, 5497, 5498, 7, 22, 0, 0, 5498, 524, 1, 0, 0, 0, 5499, 5500, + 7, 14, 0, 0, 5500, 5501, 7, 6, 0, 0, 5501, 5502, 7, 4, 0, 0, 5502, 5503, + 7, 6, 0, 0, 5503, 5504, 7, 3, 0, 0, 5504, 5505, 7, 17, 0, 0, 5505, 5506, + 7, 8, 0, 0, 5506, 5507, 7, 10, 0, 0, 5507, 5508, 7, 8, 0, 0, 5508, 5509, + 7, 9, 0, 0, 5509, 5510, 7, 4, 0, 0, 5510, 5511, 7, 8, 0, 0, 5511, 5512, + 7, 13, 0, 0, 5512, 526, 1, 0, 0, 0, 5513, 5514, 7, 14, 0, 0, 5514, 5515, + 7, 19, 0, 0, 5515, 5516, 7, 13, 0, 0, 5516, 5517, 7, 20, 0, 0, 5517, 528, + 1, 0, 0, 0, 5518, 5519, 7, 14, 0, 0, 5519, 5520, 7, 8, 0, 0, 5520, 5521, + 7, 0, 0, 0, 5521, 5522, 7, 18, 0, 0, 5522, 5523, 7, 10, 0, 0, 5523, 5524, + 7, 2, 0, 0, 5524, 5525, 7, 9, 0, 0, 5525, 5526, 7, 4, 0, 0, 5526, 5527, + 7, 8, 0, 0, 5527, 5528, 7, 13, 0, 0, 5528, 5529, 7, 9, 0, 0, 5529, 530, + 1, 0, 0, 0, 5530, 5531, 7, 14, 0, 0, 5531, 5532, 7, 8, 0, 0, 5532, 5533, + 7, 0, 0, 0, 5533, 5534, 7, 11, 0, 0, 5534, 5535, 7, 2, 0, 0, 5535, 5536, + 7, 18, 0, 0, 5536, 532, 1, 0, 0, 0, 5537, 5538, 7, 14, 0, 0, 5538, 5539, + 7, 8, 0, 0, 5539, 5540, 7, 5, 0, 0, 5540, 5541, 7, 5, 0, 0, 5541, 5542, + 7, 6, 0, 0, 5542, 5543, 7, 3, 0, 0, 5543, 5544, 7, 6, 0, 0, 5544, 5545, + 7, 10, 0, 0, 5545, 5546, 7, 13, 0, 0, 5546, 5547, 7, 6, 0, 0, 5547, 534, + 1, 0, 0, 0, 5548, 5549, 7, 14, 0, 0, 5549, 5550, 7, 8, 0, 0, 5550, 5551, + 7, 5, 0, 0, 5551, 5552, 7, 5, 0, 0, 5552, 5553, 7, 6, 0, 0, 5553, 5554, + 7, 3, 0, 0, 5554, 5555, 7, 6, 0, 0, 5555, 5556, 7, 10, 0, 0, 5556, 5557, + 7, 4, 0, 0, 5557, 5558, 7, 8, 0, 0, 5558, 5559, 7, 0, 0, 0, 5559, 5560, + 7, 11, 0, 0, 5560, 536, 1, 0, 0, 0, 5561, 5562, 7, 14, 0, 0, 5562, 5563, + 7, 8, 0, 0, 5563, 5564, 7, 3, 0, 0, 5564, 5565, 7, 6, 0, 0, 5565, 5566, + 7, 13, 0, 0, 5566, 5567, 7, 4, 0, 0, 5567, 5568, 7, 2, 0, 0, 5568, 5569, + 7, 3, 0, 0, 5569, 5570, 7, 16, 0, 0, 5570, 5571, 5, 95, 0, 0, 5571, 5572, + 7, 10, 0, 0, 5572, 5573, 7, 0, 0, 0, 5573, 5574, 7, 17, 0, 0, 5574, 5575, + 7, 6, 0, 0, 5575, 538, 1, 0, 0, 0, 5576, 5577, 7, 14, 0, 0, 5577, 5578, + 7, 8, 0, 0, 5578, 5579, 7, 9, 0, 0, 5579, 5580, 7, 0, 0, 0, 5580, 5581, + 7, 1, 0, 0, 5581, 5582, 7, 11, 0, 0, 5582, 5583, 7, 6, 0, 0, 5583, 540, + 1, 0, 0, 0, 5584, 5585, 7, 14, 0, 0, 5585, 5586, 7, 8, 0, 0, 5586, 5587, + 7, 9, 0, 0, 5587, 5588, 7, 0, 0, 0, 5588, 5589, 7, 1, 0, 0, 5589, 5590, + 7, 11, 0, 0, 5590, 5591, 7, 6, 0, 0, 5591, 5592, 7, 14, 0, 0, 5592, 542, + 1, 0, 0, 0, 5593, 5594, 7, 14, 0, 0, 5594, 5595, 7, 8, 0, 0, 5595, 5596, + 7, 9, 0, 0, 5596, 5597, 7, 0, 0, 0, 5597, 5598, 7, 1, 0, 0, 5598, 5599, + 7, 11, 0, 0, 5599, 5600, 7, 6, 0, 0, 5600, 5601, 5, 95, 0, 0, 5601, 5602, + 7, 1, 0, 0, 5602, 5603, 7, 3, 0, 0, 5603, 5604, 7, 2, 0, 0, 5604, 5605, + 7, 21, 0, 0, 5605, 5606, 7, 6, 0, 0, 5606, 5607, 7, 3, 0, 0, 5607, 544, + 1, 0, 0, 0, 5608, 5609, 7, 14, 0, 0, 5609, 5610, 7, 8, 0, 0, 5610, 5611, + 7, 9, 0, 0, 5611, 5612, 7, 21, 0, 0, 5612, 546, 1, 0, 0, 0, 5613, 5614, + 7, 14, 0, 0, 5614, 5615, 7, 8, 0, 0, 5615, 5616, 7, 9, 0, 0, 5616, 5617, + 7, 4, 0, 0, 5617, 5618, 7, 8, 0, 0, 5618, 5619, 7, 10, 0, 0, 5619, 5620, + 7, 13, 0, 0, 5620, 5621, 7, 4, 0, 0, 5621, 548, 1, 0, 0, 0, 5622, 5623, + 7, 14, 0, 0, 5623, 5624, 7, 8, 0, 0, 5624, 5625, 7, 9, 0, 0, 5625, 5626, + 7, 4, 0, 0, 5626, 5627, 7, 3, 0, 0, 5627, 5628, 7, 8, 0, 0, 5628, 5629, + 7, 1, 0, 0, 5629, 5630, 7, 12, 0, 0, 5630, 5631, 7, 4, 0, 0, 5631, 5632, + 7, 6, 0, 0, 5632, 5633, 7, 14, 0, 0, 5633, 550, 1, 0, 0, 0, 5634, 5635, + 7, 14, 0, 0, 5635, 5636, 7, 8, 0, 0, 5636, 5637, 7, 9, 0, 0, 5637, 5638, + 7, 4, 0, 0, 5638, 5639, 7, 3, 0, 0, 5639, 5640, 7, 8, 0, 0, 5640, 5641, + 7, 1, 0, 0, 5641, 5642, 7, 12, 0, 0, 5642, 5643, 7, 4, 0, 0, 5643, 5644, + 7, 8, 0, 0, 5644, 5645, 7, 2, 0, 0, 5645, 5646, 7, 10, 0, 0, 5646, 552, + 1, 0, 0, 0, 5647, 5648, 7, 14, 0, 0, 5648, 5649, 7, 2, 0, 0, 5649, 5650, + 7, 13, 0, 0, 5650, 5651, 7, 12, 0, 0, 5651, 5652, 7, 17, 0, 0, 5652, 5653, + 7, 6, 0, 0, 5653, 5654, 7, 10, 0, 0, 5654, 5655, 7, 4, 0, 0, 5655, 554, + 1, 0, 0, 0, 5656, 5657, 5, 36, 0, 0, 5657, 5658, 7, 20, 0, 0, 5658, 5659, + 7, 0, 0, 0, 5659, 5660, 7, 3, 0, 0, 5660, 5661, 7, 4, 0, 0, 5661, 5662, + 7, 8, 0, 0, 5662, 5663, 7, 4, 0, 0, 5663, 5664, 7, 8, 0, 0, 5664, 5665, + 7, 2, 0, 0, 5665, 5666, 7, 10, 0, 0, 5666, 556, 1, 0, 0, 0, 5667, 5668, + 7, 14, 0, 0, 5668, 5669, 7, 2, 0, 0, 5669, 5670, 7, 12, 0, 0, 5670, 5671, + 7, 1, 0, 0, 5671, 5672, 7, 11, 0, 0, 5672, 5673, 7, 6, 0, 0, 5673, 558, + 1, 0, 0, 0, 5674, 5675, 5, 92, 0, 0, 5675, 5676, 5, 92, 0, 0, 5676, 560, + 1, 0, 0, 0, 5677, 5678, 5, 47, 0, 0, 5678, 5679, 5, 47, 0, 0, 5679, 562, + 1, 0, 0, 0, 5680, 5681, 7, 14, 0, 0, 5681, 5682, 7, 3, 0, 0, 5682, 5683, + 7, 2, 0, 0, 5683, 5684, 7, 20, 0, 0, 5684, 564, 1, 0, 0, 0, 5685, 5686, + 7, 14, 0, 0, 5686, 5687, 7, 3, 0, 0, 5687, 5688, 7, 2, 0, 0, 5688, 5689, + 7, 20, 0, 0, 5689, 5690, 7, 13, 0, 0, 5690, 5691, 7, 11, 0, 0, 5691, 5692, + 7, 6, 0, 0, 5692, 5693, 7, 0, 0, 0, 5693, 5694, 7, 10, 0, 0, 5694, 5695, + 7, 1, 0, 0, 5695, 5696, 7, 12, 0, 0, 5696, 5697, 7, 5, 0, 0, 5697, 5698, + 7, 5, 0, 0, 5698, 5699, 7, 6, 0, 0, 5699, 5700, 7, 3, 0, 0, 5700, 5701, + 7, 9, 0, 0, 5701, 566, 1, 0, 0, 0, 5702, 5703, 7, 14, 0, 0, 5703, 5704, + 7, 3, 0, 0, 5704, 5705, 7, 2, 0, 0, 5705, 5706, 7, 20, 0, 0, 5706, 5707, + 5, 95, 0, 0, 5707, 5708, 7, 6, 0, 0, 5708, 5709, 7, 22, 0, 0, 5709, 5710, + 7, 8, 0, 0, 5710, 5711, 7, 9, 0, 0, 5711, 5712, 7, 4, 0, 0, 5712, 5713, + 7, 8, 0, 0, 5713, 5714, 7, 10, 0, 0, 5714, 5715, 7, 18, 0, 0, 5715, 568, + 1, 0, 0, 0, 5716, 5717, 7, 14, 0, 0, 5717, 5718, 7, 4, 0, 0, 5718, 5719, + 7, 13, 0, 0, 5719, 5720, 5, 95, 0, 0, 5720, 5721, 7, 9, 0, 0, 5721, 5722, + 7, 12, 0, 0, 5722, 5723, 7, 20, 0, 0, 5723, 5724, 7, 20, 0, 0, 5724, 5725, + 7, 2, 0, 0, 5725, 5726, 7, 3, 0, 0, 5726, 5727, 7, 4, 0, 0, 5727, 570, + 1, 0, 0, 0, 5728, 5729, 7, 14, 0, 0, 5729, 5730, 7, 12, 0, 0, 5730, 5731, + 7, 17, 0, 0, 5731, 5732, 7, 20, 0, 0, 5732, 572, 1, 0, 0, 0, 5733, 5734, + 7, 14, 0, 0, 5734, 5735, 7, 16, 0, 0, 5735, 5736, 7, 10, 0, 0, 5736, 5737, + 7, 0, 0, 0, 5737, 5738, 7, 17, 0, 0, 5738, 5739, 7, 8, 0, 0, 5739, 5740, + 7, 13, 0, 0, 5740, 574, 1, 0, 0, 0, 5741, 5742, 7, 6, 0, 0, 5742, 5743, + 7, 11, 0, 0, 5743, 5744, 7, 6, 0, 0, 5744, 5745, 7, 17, 0, 0, 5745, 5746, + 7, 6, 0, 0, 5746, 5747, 7, 10, 0, 0, 5747, 5748, 7, 4, 0, 0, 5748, 5749, + 7, 9, 0, 0, 5749, 576, 1, 0, 0, 0, 5750, 5751, 7, 6, 0, 0, 5751, 5752, + 7, 11, 0, 0, 5752, 5753, 7, 9, 0, 0, 5753, 5754, 7, 6, 0, 0, 5754, 578, + 1, 0, 0, 0, 5755, 5756, 7, 6, 0, 0, 5756, 5757, 7, 17, 0, 0, 5757, 5758, + 7, 6, 0, 0, 5758, 5759, 7, 3, 0, 0, 5759, 5760, 7, 18, 0, 0, 5760, 5761, + 7, 6, 0, 0, 5761, 5762, 7, 10, 0, 0, 5762, 5763, 7, 13, 0, 0, 5763, 5764, + 7, 16, 0, 0, 5764, 580, 1, 0, 0, 0, 5765, 5766, 7, 6, 0, 0, 5766, 5767, + 7, 17, 0, 0, 5767, 5768, 7, 20, 0, 0, 5768, 5769, 7, 4, 0, 0, 5769, 5770, + 7, 16, 0, 0, 5770, 582, 1, 0, 0, 0, 5771, 5772, 7, 6, 0, 0, 5772, 5773, + 7, 10, 0, 0, 5773, 5774, 7, 0, 0, 0, 5774, 5775, 7, 1, 0, 0, 5775, 5776, + 7, 11, 0, 0, 5776, 5777, 7, 6, 0, 0, 5777, 584, 1, 0, 0, 0, 5778, 5779, + 7, 6, 0, 0, 5779, 5780, 7, 10, 0, 0, 5780, 5781, 7, 0, 0, 0, 5781, 5782, + 7, 1, 0, 0, 5782, 5783, 7, 11, 0, 0, 5783, 5784, 7, 6, 0, 0, 5784, 5785, + 7, 14, 0, 0, 5785, 586, 1, 0, 0, 0, 5786, 5787, 7, 6, 0, 0, 5787, 5788, + 7, 10, 0, 0, 5788, 5789, 7, 0, 0, 0, 5789, 5790, 7, 1, 0, 0, 5790, 5791, + 7, 11, 0, 0, 5791, 5792, 7, 6, 0, 0, 5792, 5793, 5, 95, 0, 0, 5793, 5794, + 7, 1, 0, 0, 5794, 5795, 7, 3, 0, 0, 5795, 5796, 7, 2, 0, 0, 5796, 5797, + 7, 21, 0, 0, 5797, 5798, 7, 6, 0, 0, 5798, 5799, 7, 3, 0, 0, 5799, 588, + 1, 0, 0, 0, 5800, 5801, 7, 6, 0, 0, 5801, 5802, 7, 10, 0, 0, 5802, 5803, + 7, 13, 0, 0, 5803, 5804, 7, 3, 0, 0, 5804, 5805, 7, 16, 0, 0, 5805, 5806, + 7, 20, 0, 0, 5806, 5807, 7, 4, 0, 0, 5807, 5808, 7, 6, 0, 0, 5808, 5809, + 7, 14, 0, 0, 5809, 590, 1, 0, 0, 0, 5810, 5811, 7, 6, 0, 0, 5811, 5812, + 7, 10, 0, 0, 5812, 5813, 7, 13, 0, 0, 5813, 5814, 7, 3, 0, 0, 5814, 5815, + 7, 16, 0, 0, 5815, 5816, 7, 20, 0, 0, 5816, 5817, 7, 4, 0, 0, 5817, 5818, + 7, 6, 0, 0, 5818, 5819, 7, 14, 0, 0, 5819, 5820, 5, 95, 0, 0, 5820, 5821, + 7, 15, 0, 0, 5821, 5822, 7, 0, 0, 0, 5822, 5823, 7, 11, 0, 0, 5823, 5824, + 7, 12, 0, 0, 5824, 5825, 7, 6, 0, 0, 5825, 592, 1, 0, 0, 0, 5826, 5827, + 7, 6, 0, 0, 5827, 5828, 7, 10, 0, 0, 5828, 5829, 7, 13, 0, 0, 5829, 5830, + 7, 3, 0, 0, 5830, 5831, 7, 16, 0, 0, 5831, 5832, 7, 20, 0, 0, 5832, 5833, + 7, 4, 0, 0, 5833, 5834, 7, 8, 0, 0, 5834, 5835, 7, 2, 0, 0, 5835, 5836, + 7, 10, 0, 0, 5836, 594, 1, 0, 0, 0, 5837, 5838, 7, 6, 0, 0, 5838, 5839, + 7, 10, 0, 0, 5839, 5840, 7, 13, 0, 0, 5840, 5841, 7, 3, 0, 0, 5841, 5842, + 7, 16, 0, 0, 5842, 5843, 7, 20, 0, 0, 5843, 5844, 7, 4, 0, 0, 5844, 5845, + 7, 8, 0, 0, 5845, 5846, 7, 2, 0, 0, 5846, 5847, 7, 10, 0, 0, 5847, 5848, + 5, 95, 0, 0, 5848, 5849, 7, 4, 0, 0, 5849, 5850, 7, 16, 0, 0, 5850, 5851, + 7, 20, 0, 0, 5851, 5852, 7, 6, 0, 0, 5852, 596, 1, 0, 0, 0, 5853, 5854, + 7, 6, 0, 0, 5854, 5855, 7, 10, 0, 0, 5855, 5856, 7, 14, 0, 0, 5856, 598, + 1, 0, 0, 0, 5857, 5858, 7, 6, 0, 0, 5858, 5859, 7, 10, 0, 0, 5859, 5860, + 7, 14, 0, 0, 5860, 5861, 7, 20, 0, 0, 5861, 5862, 7, 2, 0, 0, 5862, 5863, + 7, 8, 0, 0, 5863, 5864, 7, 10, 0, 0, 5864, 5865, 7, 4, 0, 0, 5865, 600, + 1, 0, 0, 0, 5866, 5867, 7, 6, 0, 0, 5867, 5868, 7, 10, 0, 0, 5868, 5869, + 7, 14, 0, 0, 5869, 5870, 7, 20, 0, 0, 5870, 5871, 7, 2, 0, 0, 5871, 5872, + 7, 8, 0, 0, 5872, 5873, 7, 10, 0, 0, 5873, 5874, 7, 4, 0, 0, 5874, 5875, + 5, 95, 0, 0, 5875, 5876, 7, 12, 0, 0, 5876, 5877, 7, 3, 0, 0, 5877, 5878, + 7, 11, 0, 0, 5878, 602, 1, 0, 0, 0, 5879, 5880, 7, 6, 0, 0, 5880, 5881, + 7, 3, 0, 0, 5881, 5882, 7, 3, 0, 0, 5882, 5883, 7, 11, 0, 0, 5883, 5884, + 7, 15, 0, 0, 5884, 5885, 7, 11, 0, 0, 5885, 604, 1, 0, 0, 0, 5886, 5887, + 7, 6, 0, 0, 5887, 5888, 7, 3, 0, 0, 5888, 5889, 7, 3, 0, 0, 5889, 5890, + 7, 2, 0, 0, 5890, 5891, 7, 3, 0, 0, 5891, 606, 1, 0, 0, 0, 5892, 5893, + 7, 6, 0, 0, 5893, 5894, 7, 3, 0, 0, 5894, 5895, 7, 3, 0, 0, 5895, 5896, + 7, 2, 0, 0, 5896, 5897, 7, 3, 0, 0, 5897, 5898, 5, 95, 0, 0, 5898, 5899, + 7, 1, 0, 0, 5899, 5900, 7, 3, 0, 0, 5900, 5901, 7, 2, 0, 0, 5901, 5902, + 7, 21, 0, 0, 5902, 5903, 7, 6, 0, 0, 5903, 5904, 7, 3, 0, 0, 5904, 5905, + 5, 95, 0, 0, 5905, 5906, 7, 13, 0, 0, 5906, 5907, 7, 2, 0, 0, 5907, 5908, + 7, 10, 0, 0, 5908, 5909, 7, 15, 0, 0, 5909, 5910, 7, 6, 0, 0, 5910, 5911, + 7, 3, 0, 0, 5911, 5912, 7, 9, 0, 0, 5912, 5913, 7, 0, 0, 0, 5913, 5914, + 7, 4, 0, 0, 5914, 5915, 7, 8, 0, 0, 5915, 5916, 7, 2, 0, 0, 5916, 5917, + 7, 10, 0, 0, 5917, 5918, 7, 9, 0, 0, 5918, 608, 1, 0, 0, 0, 5919, 5920, + 7, 6, 0, 0, 5920, 5921, 7, 3, 0, 0, 5921, 5922, 7, 3, 0, 0, 5922, 5923, + 7, 2, 0, 0, 5923, 5924, 7, 3, 0, 0, 5924, 5925, 5, 95, 0, 0, 5925, 5926, + 7, 11, 0, 0, 5926, 5927, 7, 8, 0, 0, 5927, 5928, 7, 10, 0, 0, 5928, 5929, + 7, 6, 0, 0, 5929, 610, 1, 0, 0, 0, 5930, 5931, 7, 6, 0, 0, 5931, 5932, + 7, 3, 0, 0, 5932, 5933, 7, 3, 0, 0, 5933, 5934, 7, 2, 0, 0, 5934, 5935, + 7, 3, 0, 0, 5935, 5936, 5, 95, 0, 0, 5936, 5937, 7, 17, 0, 0, 5937, 5938, + 7, 6, 0, 0, 5938, 5939, 7, 9, 0, 0, 5939, 5940, 7, 9, 0, 0, 5940, 5941, + 7, 0, 0, 0, 5941, 5942, 7, 18, 0, 0, 5942, 5943, 7, 6, 0, 0, 5943, 612, + 1, 0, 0, 0, 5944, 5945, 7, 6, 0, 0, 5945, 5946, 7, 3, 0, 0, 5946, 5947, + 7, 3, 0, 0, 5947, 5948, 7, 2, 0, 0, 5948, 5949, 7, 3, 0, 0, 5949, 5950, + 5, 95, 0, 0, 5950, 5951, 7, 10, 0, 0, 5951, 5952, 7, 12, 0, 0, 5952, 5953, + 7, 17, 0, 0, 5953, 5954, 7, 1, 0, 0, 5954, 5955, 7, 6, 0, 0, 5955, 5956, + 7, 3, 0, 0, 5956, 614, 1, 0, 0, 0, 5957, 5958, 7, 6, 0, 0, 5958, 5959, + 7, 3, 0, 0, 5959, 5960, 7, 3, 0, 0, 5960, 5961, 7, 2, 0, 0, 5961, 5962, + 7, 3, 0, 0, 5962, 5963, 5, 95, 0, 0, 5963, 5964, 7, 20, 0, 0, 5964, 5965, + 7, 3, 0, 0, 5965, 5966, 7, 2, 0, 0, 5966, 5967, 7, 13, 0, 0, 5967, 5968, + 7, 6, 0, 0, 5968, 5969, 7, 14, 0, 0, 5969, 5970, 7, 12, 0, 0, 5970, 5971, + 7, 3, 0, 0, 5971, 5972, 7, 6, 0, 0, 5972, 616, 1, 0, 0, 0, 5973, 5974, + 7, 6, 0, 0, 5974, 5975, 7, 3, 0, 0, 5975, 5976, 7, 3, 0, 0, 5976, 5977, + 7, 2, 0, 0, 5977, 5978, 7, 3, 0, 0, 5978, 5979, 5, 95, 0, 0, 5979, 5980, + 7, 9, 0, 0, 5980, 5981, 7, 6, 0, 0, 5981, 5982, 7, 15, 0, 0, 5982, 5983, + 7, 6, 0, 0, 5983, 5984, 7, 3, 0, 0, 5984, 5985, 7, 8, 0, 0, 5985, 5986, + 7, 4, 0, 0, 5986, 5987, 7, 16, 0, 0, 5987, 618, 1, 0, 0, 0, 5988, 5989, + 7, 6, 0, 0, 5989, 5990, 7, 3, 0, 0, 5990, 5991, 7, 3, 0, 0, 5991, 5992, + 7, 2, 0, 0, 5992, 5993, 7, 3, 0, 0, 5993, 5994, 5, 95, 0, 0, 5994, 5995, + 7, 9, 0, 0, 5995, 5996, 7, 4, 0, 0, 5996, 5997, 7, 0, 0, 0, 5997, 5998, + 7, 4, 0, 0, 5998, 5999, 7, 6, 0, 0, 5999, 620, 1, 0, 0, 0, 6000, 6001, + 7, 6, 0, 0, 6001, 6002, 7, 9, 0, 0, 6002, 6003, 7, 13, 0, 0, 6003, 6004, + 7, 0, 0, 0, 6004, 6005, 7, 20, 0, 0, 6005, 6006, 7, 6, 0, 0, 6006, 622, + 1, 0, 0, 0, 6007, 6008, 7, 6, 0, 0, 6008, 6009, 7, 9, 0, 0, 6009, 6010, + 7, 4, 0, 0, 6010, 6011, 7, 8, 0, 0, 6011, 6012, 7, 17, 0, 0, 6012, 6013, + 7, 0, 0, 0, 6013, 6014, 7, 4, 0, 0, 6014, 6015, 7, 6, 0, 0, 6015, 6016, + 7, 2, 0, 0, 6016, 6017, 7, 10, 0, 0, 6017, 6018, 7, 11, 0, 0, 6018, 6019, + 7, 16, 0, 0, 6019, 624, 1, 0, 0, 0, 6020, 6021, 7, 6, 0, 0, 6021, 6022, + 7, 15, 0, 0, 6022, 6023, 7, 6, 0, 0, 6023, 6024, 7, 10, 0, 0, 6024, 6025, + 7, 4, 0, 0, 6025, 626, 1, 0, 0, 0, 6026, 6027, 7, 6, 0, 0, 6027, 6028, + 7, 15, 0, 0, 6028, 6029, 7, 6, 0, 0, 6029, 6030, 7, 10, 0, 0, 6030, 6031, + 7, 4, 0, 0, 6031, 6032, 7, 14, 0, 0, 6032, 6033, 7, 0, 0, 0, 6033, 6034, + 7, 4, 0, 0, 6034, 6035, 7, 0, 0, 0, 6035, 628, 1, 0, 0, 0, 6036, 6037, + 7, 6, 0, 0, 6037, 6038, 7, 15, 0, 0, 6038, 6039, 7, 6, 0, 0, 6039, 6040, + 7, 10, 0, 0, 6040, 6041, 7, 4, 0, 0, 6041, 6042, 5, 95, 0, 0, 6042, 6043, + 7, 3, 0, 0, 6043, 6044, 7, 6, 0, 0, 6044, 6045, 7, 4, 0, 0, 6045, 6046, + 7, 6, 0, 0, 6046, 6047, 7, 10, 0, 0, 6047, 6048, 7, 4, 0, 0, 6048, 6049, + 7, 8, 0, 0, 6049, 6050, 7, 2, 0, 0, 6050, 6051, 7, 10, 0, 0, 6051, 6052, + 5, 95, 0, 0, 6052, 6053, 7, 17, 0, 0, 6053, 6054, 7, 2, 0, 0, 6054, 6055, + 7, 14, 0, 0, 6055, 6056, 7, 6, 0, 0, 6056, 630, 1, 0, 0, 0, 6057, 6058, + 7, 6, 0, 0, 6058, 6059, 7, 22, 0, 0, 6059, 6060, 7, 13, 0, 0, 6060, 6061, + 7, 6, 0, 0, 6061, 6062, 7, 20, 0, 0, 6062, 6063, 7, 4, 0, 0, 6063, 632, + 1, 0, 0, 0, 6064, 6065, 7, 6, 0, 0, 6065, 6066, 7, 22, 0, 0, 6066, 6067, + 7, 13, 0, 0, 6067, 6068, 7, 11, 0, 0, 6068, 6069, 7, 12, 0, 0, 6069, 6070, + 7, 9, 0, 0, 6070, 6071, 7, 8, 0, 0, 6071, 6072, 7, 15, 0, 0, 6072, 6073, + 7, 6, 0, 0, 6073, 634, 1, 0, 0, 0, 6074, 6075, 7, 6, 0, 0, 6075, 6076, + 7, 22, 0, 0, 6076, 6077, 7, 6, 0, 0, 6077, 6078, 7, 13, 0, 0, 6078, 6079, + 7, 12, 0, 0, 6079, 6080, 7, 4, 0, 0, 6080, 6081, 7, 0, 0, 0, 6081, 6082, + 7, 1, 0, 0, 6082, 6083, 7, 11, 0, 0, 6083, 6084, 7, 6, 0, 0, 6084, 636, + 1, 0, 0, 0, 6085, 6086, 7, 6, 0, 0, 6086, 6087, 7, 22, 0, 0, 6087, 6088, + 7, 6, 0, 0, 6088, 6089, 7, 13, 0, 0, 6089, 6090, 7, 12, 0, 0, 6090, 6091, + 7, 4, 0, 0, 6091, 6092, 7, 0, 0, 0, 6092, 6093, 7, 1, 0, 0, 6093, 6094, + 7, 11, 0, 0, 6094, 6095, 7, 6, 0, 0, 6095, 6096, 5, 95, 0, 0, 6096, 6097, + 7, 5, 0, 0, 6097, 6098, 7, 8, 0, 0, 6098, 6099, 7, 11, 0, 0, 6099, 6100, + 7, 6, 0, 0, 6100, 638, 1, 0, 0, 0, 6101, 6102, 7, 6, 0, 0, 6102, 6103, + 7, 22, 0, 0, 6103, 6104, 7, 6, 0, 0, 6104, 6105, 7, 13, 0, 0, 6105, 6109, + 1, 0, 0, 0, 6106, 6107, 7, 12, 0, 0, 6107, 6108, 7, 4, 0, 0, 6108, 6110, + 7, 6, 0, 0, 6109, 6106, 1, 0, 0, 0, 6109, 6110, 1, 0, 0, 0, 6110, 640, + 1, 0, 0, 0, 6111, 6112, 7, 6, 0, 0, 6112, 6113, 7, 22, 0, 0, 6113, 6114, + 7, 8, 0, 0, 6114, 6115, 7, 9, 0, 0, 6115, 6116, 7, 4, 0, 0, 6116, 642, + 1, 0, 0, 0, 6117, 6118, 7, 6, 0, 0, 6118, 6119, 7, 22, 0, 0, 6119, 6120, + 7, 8, 0, 0, 6120, 6121, 7, 9, 0, 0, 6121, 6122, 7, 4, 0, 0, 6122, 6123, + 7, 9, 0, 0, 6123, 644, 1, 0, 0, 0, 6124, 6125, 5, 91, 0, 0, 6125, 6126, + 7, 6, 0, 0, 6126, 6127, 7, 22, 0, 0, 6127, 6128, 7, 8, 0, 0, 6128, 6129, + 7, 9, 0, 0, 6129, 6130, 7, 4, 0, 0, 6130, 6131, 5, 93, 0, 0, 6131, 646, + 1, 0, 0, 0, 6132, 6133, 7, 6, 0, 0, 6133, 6134, 7, 22, 0, 0, 6134, 6135, + 7, 8, 0, 0, 6135, 6136, 7, 4, 0, 0, 6136, 648, 1, 0, 0, 0, 6137, 6138, + 7, 6, 0, 0, 6138, 6139, 7, 22, 0, 0, 6139, 6140, 7, 20, 0, 0, 6140, 6141, + 7, 0, 0, 0, 6141, 6142, 7, 10, 0, 0, 6142, 6143, 7, 14, 0, 0, 6143, 650, + 1, 0, 0, 0, 6144, 6145, 7, 6, 0, 0, 6145, 6146, 7, 22, 0, 0, 6146, 6147, + 7, 20, 0, 0, 6147, 6148, 7, 8, 0, 0, 6148, 6149, 7, 3, 0, 0, 6149, 6150, + 7, 6, 0, 0, 6150, 6151, 7, 14, 0, 0, 6151, 6152, 7, 0, 0, 0, 6152, 6153, + 7, 4, 0, 0, 6153, 6154, 7, 6, 0, 0, 6154, 652, 1, 0, 0, 0, 6155, 6156, + 7, 6, 0, 0, 6156, 6157, 7, 22, 0, 0, 6157, 6158, 7, 20, 0, 0, 6158, 6159, + 7, 8, 0, 0, 6159, 6160, 7, 3, 0, 0, 6160, 6161, 7, 16, 0, 0, 6161, 6162, + 5, 95, 0, 0, 6162, 6163, 7, 14, 0, 0, 6163, 6164, 7, 0, 0, 0, 6164, 6165, + 7, 4, 0, 0, 6165, 6166, 7, 6, 0, 0, 6166, 654, 1, 0, 0, 0, 6167, 6168, + 7, 6, 0, 0, 6168, 6169, 7, 22, 0, 0, 6169, 6170, 7, 20, 0, 0, 6170, 6171, + 7, 11, 0, 0, 6171, 6172, 7, 8, 0, 0, 6172, 6173, 7, 13, 0, 0, 6173, 6174, + 7, 8, 0, 0, 6174, 6175, 7, 4, 0, 0, 6175, 656, 1, 0, 0, 0, 6176, 6177, + 7, 6, 0, 0, 6177, 6178, 7, 22, 0, 0, 6178, 6179, 7, 4, 0, 0, 6179, 6180, + 7, 6, 0, 0, 6180, 6181, 7, 10, 0, 0, 6181, 6182, 7, 14, 0, 0, 6182, 6183, + 7, 6, 0, 0, 6183, 6184, 7, 14, 0, 0, 6184, 6185, 5, 95, 0, 0, 6185, 6186, + 7, 11, 0, 0, 6186, 6187, 7, 2, 0, 0, 6187, 6188, 7, 18, 0, 0, 6188, 6189, + 7, 8, 0, 0, 6189, 6190, 7, 13, 0, 0, 6190, 6191, 7, 0, 0, 0, 6191, 6192, + 7, 11, 0, 0, 6192, 6193, 5, 95, 0, 0, 6193, 6194, 7, 13, 0, 0, 6194, 6195, + 7, 19, 0, 0, 6195, 6196, 7, 6, 0, 0, 6196, 6197, 7, 13, 0, 0, 6197, 6198, + 7, 21, 0, 0, 6198, 6199, 7, 9, 0, 0, 6199, 658, 1, 0, 0, 0, 6200, 6201, + 7, 6, 0, 0, 6201, 6202, 7, 22, 0, 0, 6202, 6203, 7, 4, 0, 0, 6203, 6204, + 7, 6, 0, 0, 6204, 6205, 7, 10, 0, 0, 6205, 6206, 7, 9, 0, 0, 6206, 6207, + 7, 8, 0, 0, 6207, 6208, 7, 2, 0, 0, 6208, 6209, 7, 10, 0, 0, 6209, 660, + 1, 0, 0, 0, 6210, 6211, 7, 6, 0, 0, 6211, 6212, 7, 22, 0, 0, 6212, 6213, + 7, 4, 0, 0, 6213, 6214, 7, 6, 0, 0, 6214, 6215, 7, 3, 0, 0, 6215, 6216, + 7, 10, 0, 0, 6216, 6217, 7, 0, 0, 0, 6217, 6218, 7, 11, 0, 0, 6218, 662, + 1, 0, 0, 0, 6219, 6220, 7, 6, 0, 0, 6220, 6221, 7, 22, 0, 0, 6221, 6222, + 7, 4, 0, 0, 6222, 6223, 7, 6, 0, 0, 6223, 6224, 7, 3, 0, 0, 6224, 6225, + 7, 10, 0, 0, 6225, 6226, 7, 0, 0, 0, 6226, 6227, 7, 11, 0, 0, 6227, 6228, + 5, 95, 0, 0, 6228, 6229, 7, 0, 0, 0, 6229, 6230, 7, 13, 0, 0, 6230, 6231, + 7, 13, 0, 0, 6231, 6232, 7, 6, 0, 0, 6232, 6233, 7, 9, 0, 0, 6233, 6234, + 7, 9, 0, 0, 6234, 664, 1, 0, 0, 0, 6235, 6236, 7, 5, 0, 0, 6236, 6237, + 7, 0, 0, 0, 6237, 6238, 7, 8, 0, 0, 6238, 6239, 7, 11, 0, 0, 6239, 6240, + 7, 2, 0, 0, 6240, 6241, 7, 15, 0, 0, 6241, 6242, 7, 6, 0, 0, 6242, 6243, + 7, 3, 0, 0, 6243, 666, 1, 0, 0, 0, 6244, 6245, 7, 5, 0, 0, 6245, 6246, + 7, 0, 0, 0, 6246, 6247, 7, 8, 0, 0, 6247, 6248, 7, 11, 0, 0, 6248, 6249, + 7, 2, 0, 0, 6249, 6250, 7, 15, 0, 0, 6250, 6251, 7, 6, 0, 0, 6251, 6252, + 7, 3, 0, 0, 6252, 6253, 5, 95, 0, 0, 6253, 6254, 7, 17, 0, 0, 6254, 6255, + 7, 2, 0, 0, 6255, 6256, 7, 14, 0, 0, 6256, 6257, 7, 6, 0, 0, 6257, 668, + 1, 0, 0, 0, 6258, 6259, 7, 5, 0, 0, 6259, 6260, 7, 0, 0, 0, 6260, 6261, + 7, 8, 0, 0, 6261, 6262, 7, 11, 0, 0, 6262, 6263, 7, 12, 0, 0, 6263, 6264, + 7, 3, 0, 0, 6264, 6265, 7, 6, 0, 0, 6265, 670, 1, 0, 0, 0, 6266, 6267, + 7, 5, 0, 0, 6267, 6268, 7, 0, 0, 0, 6268, 6269, 7, 8, 0, 0, 6269, 6270, + 7, 11, 0, 0, 6270, 6271, 7, 12, 0, 0, 6271, 6272, 7, 3, 0, 0, 6272, 6273, + 7, 6, 0, 0, 6273, 6274, 7, 13, 0, 0, 6274, 6275, 7, 2, 0, 0, 6275, 6276, + 7, 10, 0, 0, 6276, 6277, 7, 14, 0, 0, 6277, 6278, 7, 8, 0, 0, 6278, 6279, + 7, 4, 0, 0, 6279, 6280, 7, 8, 0, 0, 6280, 6281, 7, 2, 0, 0, 6281, 6282, + 7, 10, 0, 0, 6282, 6283, 7, 11, 0, 0, 6283, 6284, 7, 6, 0, 0, 6284, 6285, + 7, 15, 0, 0, 6285, 6286, 7, 6, 0, 0, 6286, 6287, 7, 11, 0, 0, 6287, 672, + 1, 0, 0, 0, 6288, 6289, 7, 5, 0, 0, 6289, 6290, 7, 0, 0, 0, 6290, 6291, + 7, 8, 0, 0, 6291, 6292, 7, 11, 0, 0, 6292, 6293, 7, 12, 0, 0, 6293, 6294, + 7, 3, 0, 0, 6294, 6295, 7, 6, 0, 0, 6295, 6296, 5, 95, 0, 0, 6296, 6297, + 7, 13, 0, 0, 6297, 6298, 7, 2, 0, 0, 6298, 6299, 7, 10, 0, 0, 6299, 6300, + 7, 14, 0, 0, 6300, 6301, 7, 8, 0, 0, 6301, 6302, 7, 4, 0, 0, 6302, 6303, + 7, 8, 0, 0, 6303, 6304, 7, 2, 0, 0, 6304, 6305, 7, 10, 0, 0, 6305, 6306, + 5, 95, 0, 0, 6306, 6307, 7, 11, 0, 0, 6307, 6308, 7, 6, 0, 0, 6308, 6309, + 7, 15, 0, 0, 6309, 6310, 7, 6, 0, 0, 6310, 6311, 7, 11, 0, 0, 6311, 674, + 1, 0, 0, 0, 6312, 6313, 7, 5, 0, 0, 6313, 6314, 7, 0, 0, 0, 6314, 6315, + 7, 8, 0, 0, 6315, 6316, 7, 11, 0, 0, 6316, 6317, 5, 95, 0, 0, 6317, 6318, + 7, 2, 0, 0, 6318, 6319, 7, 20, 0, 0, 6319, 6320, 7, 6, 0, 0, 6320, 6321, + 7, 3, 0, 0, 6321, 6322, 7, 0, 0, 0, 6322, 6323, 7, 4, 0, 0, 6323, 6324, + 7, 8, 0, 0, 6324, 6325, 7, 2, 0, 0, 6325, 6326, 7, 10, 0, 0, 6326, 676, + 1, 0, 0, 0, 6327, 6328, 7, 5, 0, 0, 6328, 6329, 7, 0, 0, 0, 6329, 6330, + 7, 10, 0, 0, 6330, 6331, 5, 95, 0, 0, 6331, 6332, 7, 8, 0, 0, 6332, 6333, + 7, 10, 0, 0, 6333, 678, 1, 0, 0, 0, 6334, 6335, 7, 5, 0, 0, 6335, 6336, + 7, 0, 0, 0, 6336, 6337, 7, 9, 0, 0, 6337, 6338, 7, 4, 0, 0, 6338, 680, + 1, 0, 0, 0, 6339, 6340, 7, 5, 0, 0, 6340, 6341, 7, 0, 0, 0, 6341, 6342, + 7, 9, 0, 0, 6342, 6343, 7, 4, 0, 0, 6343, 6344, 5, 95, 0, 0, 6344, 6345, + 7, 5, 0, 0, 6345, 6346, 7, 2, 0, 0, 6346, 6347, 7, 3, 0, 0, 6347, 6348, + 7, 7, 0, 0, 6348, 6349, 7, 0, 0, 0, 6349, 6350, 7, 3, 0, 0, 6350, 6351, + 7, 14, 0, 0, 6351, 682, 1, 0, 0, 0, 6352, 6353, 7, 5, 0, 0, 6353, 6354, + 7, 6, 0, 0, 6354, 6355, 7, 4, 0, 0, 6355, 6356, 7, 13, 0, 0, 6356, 6357, + 7, 19, 0, 0, 6357, 684, 1, 0, 0, 0, 6358, 6359, 7, 5, 0, 0, 6359, 6360, + 7, 8, 0, 0, 6360, 6361, 7, 11, 0, 0, 6361, 6362, 7, 6, 0, 0, 6362, 686, + 1, 0, 0, 0, 6363, 6364, 7, 5, 0, 0, 6364, 6365, 7, 8, 0, 0, 6365, 6366, + 7, 11, 0, 0, 6366, 6367, 7, 6, 0, 0, 6367, 6368, 7, 18, 0, 0, 6368, 6369, + 7, 3, 0, 0, 6369, 6370, 7, 2, 0, 0, 6370, 6371, 7, 12, 0, 0, 6371, 6372, + 7, 20, 0, 0, 6372, 688, 1, 0, 0, 0, 6373, 6374, 7, 5, 0, 0, 6374, 6375, + 7, 8, 0, 0, 6375, 6376, 7, 11, 0, 0, 6376, 6377, 7, 6, 0, 0, 6377, 6378, + 7, 18, 0, 0, 6378, 6379, 7, 3, 0, 0, 6379, 6380, 7, 2, 0, 0, 6380, 6381, + 7, 12, 0, 0, 6381, 6382, 7, 20, 0, 0, 6382, 6383, 7, 20, 0, 0, 6383, 6384, + 7, 3, 0, 0, 6384, 6385, 7, 2, 0, 0, 6385, 6386, 7, 20, 0, 0, 6386, 6387, + 7, 6, 0, 0, 6387, 6388, 7, 3, 0, 0, 6388, 6389, 7, 4, 0, 0, 6389, 6390, + 7, 16, 0, 0, 6390, 690, 1, 0, 0, 0, 6391, 6392, 7, 5, 0, 0, 6392, 6393, + 7, 8, 0, 0, 6393, 6394, 7, 11, 0, 0, 6394, 6395, 7, 6, 0, 0, 6395, 6396, + 7, 18, 0, 0, 6396, 6397, 7, 3, 0, 0, 6397, 6398, 7, 2, 0, 0, 6398, 6399, + 7, 12, 0, 0, 6399, 6400, 7, 20, 0, 0, 6400, 6401, 5, 95, 0, 0, 6401, 6402, + 7, 8, 0, 0, 6402, 6403, 7, 14, 0, 0, 6403, 692, 1, 0, 0, 0, 6404, 6405, + 7, 5, 0, 0, 6405, 6406, 7, 8, 0, 0, 6406, 6407, 7, 11, 0, 0, 6407, 6408, + 7, 6, 0, 0, 6408, 6409, 7, 18, 0, 0, 6409, 6410, 7, 3, 0, 0, 6410, 6411, + 7, 2, 0, 0, 6411, 6412, 7, 12, 0, 0, 6412, 6413, 7, 20, 0, 0, 6413, 6414, + 5, 95, 0, 0, 6414, 6415, 7, 10, 0, 0, 6415, 6416, 7, 0, 0, 0, 6416, 6417, + 7, 17, 0, 0, 6417, 6418, 7, 6, 0, 0, 6418, 694, 1, 0, 0, 0, 6419, 6420, + 7, 5, 0, 0, 6420, 6421, 7, 8, 0, 0, 6421, 6422, 7, 11, 0, 0, 6422, 6423, + 7, 6, 0, 0, 6423, 6424, 7, 18, 0, 0, 6424, 6425, 7, 3, 0, 0, 6425, 6426, + 7, 2, 0, 0, 6426, 6427, 7, 7, 0, 0, 6427, 6428, 7, 4, 0, 0, 6428, 6429, + 7, 19, 0, 0, 6429, 696, 1, 0, 0, 0, 6430, 6431, 7, 5, 0, 0, 6431, 6432, + 7, 8, 0, 0, 6432, 6433, 7, 11, 0, 0, 6433, 6434, 7, 6, 0, 0, 6434, 6435, + 7, 10, 0, 0, 6435, 6436, 7, 0, 0, 0, 6436, 6437, 7, 17, 0, 0, 6437, 6438, + 7, 6, 0, 0, 6438, 698, 1, 0, 0, 0, 6439, 6440, 7, 5, 0, 0, 6440, 6441, + 7, 8, 0, 0, 6441, 6442, 7, 11, 0, 0, 6442, 6443, 7, 6, 0, 0, 6443, 6444, + 7, 20, 0, 0, 6444, 6445, 7, 0, 0, 0, 6445, 6446, 7, 4, 0, 0, 6446, 6447, + 7, 19, 0, 0, 6447, 700, 1, 0, 0, 0, 6448, 6449, 7, 5, 0, 0, 6449, 6450, + 7, 8, 0, 0, 6450, 6451, 7, 11, 0, 0, 6451, 6452, 7, 6, 0, 0, 6452, 6453, + 7, 20, 0, 0, 6453, 6454, 7, 3, 0, 0, 6454, 6455, 7, 2, 0, 0, 6455, 6456, + 7, 20, 0, 0, 6456, 6457, 7, 6, 0, 0, 6457, 6458, 7, 3, 0, 0, 6458, 6459, + 7, 4, 0, 0, 6459, 6460, 7, 16, 0, 0, 6460, 702, 1, 0, 0, 0, 6461, 6462, + 7, 5, 0, 0, 6462, 6463, 7, 8, 0, 0, 6463, 6464, 7, 11, 0, 0, 6464, 6465, + 7, 6, 0, 0, 6465, 6466, 7, 20, 0, 0, 6466, 6467, 7, 3, 0, 0, 6467, 6468, + 7, 2, 0, 0, 6468, 6469, 7, 20, 0, 0, 6469, 6470, 7, 6, 0, 0, 6470, 6471, + 7, 3, 0, 0, 6471, 6472, 7, 4, 0, 0, 6472, 6473, 7, 16, 0, 0, 6473, 6474, + 7, 6, 0, 0, 6474, 6475, 7, 22, 0, 0, 6475, 704, 1, 0, 0, 0, 6476, 6477, + 7, 5, 0, 0, 6477, 6478, 7, 8, 0, 0, 6478, 6479, 7, 11, 0, 0, 6479, 6480, + 7, 6, 0, 0, 6480, 6481, 7, 9, 0, 0, 6481, 6482, 7, 4, 0, 0, 6482, 6483, + 7, 3, 0, 0, 6483, 6484, 7, 6, 0, 0, 6484, 6485, 7, 0, 0, 0, 6485, 6486, + 7, 17, 0, 0, 6486, 706, 1, 0, 0, 0, 6487, 6488, 7, 5, 0, 0, 6488, 6489, + 7, 8, 0, 0, 6489, 6490, 7, 11, 0, 0, 6490, 6491, 7, 6, 0, 0, 6491, 6492, + 7, 9, 0, 0, 6492, 6493, 7, 4, 0, 0, 6493, 6494, 7, 3, 0, 0, 6494, 6495, + 7, 6, 0, 0, 6495, 6496, 7, 0, 0, 0, 6496, 6497, 7, 17, 0, 0, 6497, 6498, + 5, 95, 0, 0, 6498, 6499, 7, 2, 0, 0, 6499, 6500, 7, 10, 0, 0, 6500, 708, + 1, 0, 0, 0, 6501, 6502, 7, 5, 0, 0, 6502, 6503, 7, 8, 0, 0, 6503, 6504, + 7, 11, 0, 0, 6504, 6505, 7, 6, 0, 0, 6505, 6506, 5, 95, 0, 0, 6506, 6507, + 7, 8, 0, 0, 6507, 6508, 7, 14, 0, 0, 6508, 710, 1, 0, 0, 0, 6509, 6510, + 7, 5, 0, 0, 6510, 6511, 7, 8, 0, 0, 6511, 6512, 7, 11, 0, 0, 6512, 6513, + 7, 6, 0, 0, 6513, 6514, 5, 95, 0, 0, 6514, 6515, 7, 8, 0, 0, 6515, 6516, + 7, 14, 0, 0, 6516, 6517, 7, 6, 0, 0, 6517, 6518, 7, 22, 0, 0, 6518, 712, + 1, 0, 0, 0, 6519, 6520, 7, 5, 0, 0, 6520, 6521, 7, 8, 0, 0, 6521, 6522, + 7, 11, 0, 0, 6522, 6523, 7, 6, 0, 0, 6523, 6524, 5, 95, 0, 0, 6524, 6525, + 7, 10, 0, 0, 6525, 6526, 7, 0, 0, 0, 6526, 6527, 7, 17, 0, 0, 6527, 6528, + 7, 6, 0, 0, 6528, 714, 1, 0, 0, 0, 6529, 6530, 7, 5, 0, 0, 6530, 6531, + 7, 8, 0, 0, 6531, 6532, 7, 11, 0, 0, 6532, 6533, 7, 6, 0, 0, 6533, 6534, + 5, 95, 0, 0, 6534, 6535, 7, 9, 0, 0, 6535, 6536, 7, 10, 0, 0, 6536, 6537, + 7, 0, 0, 0, 6537, 6538, 7, 20, 0, 0, 6538, 6539, 7, 9, 0, 0, 6539, 6540, + 7, 19, 0, 0, 6540, 6541, 7, 2, 0, 0, 6541, 6542, 7, 4, 0, 0, 6542, 716, + 1, 0, 0, 0, 6543, 6544, 7, 5, 0, 0, 6544, 6545, 7, 8, 0, 0, 6545, 6546, + 7, 11, 0, 0, 6546, 6547, 7, 11, 0, 0, 6547, 6548, 7, 5, 0, 0, 6548, 6549, + 7, 0, 0, 0, 6549, 6550, 7, 13, 0, 0, 6550, 6551, 7, 4, 0, 0, 6551, 6552, + 7, 2, 0, 0, 6552, 6553, 7, 3, 0, 0, 6553, 718, 1, 0, 0, 0, 6554, 6555, + 7, 5, 0, 0, 6555, 6556, 7, 8, 0, 0, 6556, 6557, 7, 11, 0, 0, 6557, 6558, + 7, 4, 0, 0, 6558, 6559, 7, 6, 0, 0, 6559, 6560, 7, 3, 0, 0, 6560, 720, + 1, 0, 0, 0, 6561, 6562, 7, 5, 0, 0, 6562, 6563, 7, 8, 0, 0, 6563, 6564, + 7, 3, 0, 0, 6564, 6565, 7, 9, 0, 0, 6565, 6566, 7, 4, 0, 0, 6566, 722, + 1, 0, 0, 0, 6567, 6568, 7, 5, 0, 0, 6568, 6569, 7, 8, 0, 0, 6569, 6570, + 7, 3, 0, 0, 6570, 6571, 7, 9, 0, 0, 6571, 6572, 7, 4, 0, 0, 6572, 6573, + 5, 95, 0, 0, 6573, 6574, 7, 15, 0, 0, 6574, 6575, 7, 0, 0, 0, 6575, 6576, + 7, 11, 0, 0, 6576, 6577, 7, 12, 0, 0, 6577, 6578, 7, 6, 0, 0, 6578, 724, + 1, 0, 0, 0, 6579, 6580, 7, 5, 0, 0, 6580, 6581, 7, 17, 0, 0, 6581, 6582, + 7, 4, 0, 0, 6582, 6583, 7, 2, 0, 0, 6583, 6584, 7, 10, 0, 0, 6584, 6585, + 7, 11, 0, 0, 6585, 6586, 7, 16, 0, 0, 6586, 726, 1, 0, 0, 0, 6587, 6588, + 7, 5, 0, 0, 6588, 6589, 7, 2, 0, 0, 6589, 6590, 7, 11, 0, 0, 6590, 6591, + 7, 11, 0, 0, 6591, 6592, 7, 2, 0, 0, 6592, 6593, 7, 7, 0, 0, 6593, 6594, + 7, 8, 0, 0, 6594, 6595, 7, 10, 0, 0, 6595, 6596, 7, 18, 0, 0, 6596, 728, + 1, 0, 0, 0, 6597, 6598, 7, 5, 0, 0, 6598, 6599, 7, 2, 0, 0, 6599, 6600, + 7, 3, 0, 0, 6600, 730, 1, 0, 0, 0, 6601, 6602, 7, 5, 0, 0, 6602, 6603, + 7, 2, 0, 0, 6603, 6604, 7, 3, 0, 0, 6604, 6605, 7, 13, 0, 0, 6605, 6606, + 7, 6, 0, 0, 6606, 732, 1, 0, 0, 0, 6607, 6608, 7, 5, 0, 0, 6608, 6609, + 7, 2, 0, 0, 6609, 6610, 7, 3, 0, 0, 6610, 6611, 7, 13, 0, 0, 6611, 6612, + 7, 6, 0, 0, 6612, 6613, 7, 14, 0, 0, 6613, 734, 1, 0, 0, 0, 6614, 6615, + 7, 5, 0, 0, 6615, 6616, 7, 2, 0, 0, 6616, 6617, 7, 3, 0, 0, 6617, 6618, + 7, 13, 0, 0, 6618, 6619, 7, 6, 0, 0, 6619, 6620, 7, 20, 0, 0, 6620, 6621, + 7, 11, 0, 0, 6621, 6622, 7, 0, 0, 0, 6622, 6623, 7, 10, 0, 0, 6623, 736, + 1, 0, 0, 0, 6624, 6625, 7, 5, 0, 0, 6625, 6626, 7, 2, 0, 0, 6626, 6627, + 7, 3, 0, 0, 6627, 6628, 7, 13, 0, 0, 6628, 6629, 7, 6, 0, 0, 6629, 6630, + 7, 9, 0, 0, 6630, 6631, 7, 13, 0, 0, 6631, 6632, 7, 0, 0, 0, 6632, 6633, + 7, 10, 0, 0, 6633, 738, 1, 0, 0, 0, 6634, 6635, 7, 5, 0, 0, 6635, 6636, + 7, 2, 0, 0, 6636, 6637, 7, 3, 0, 0, 6637, 6638, 7, 13, 0, 0, 6638, 6639, + 7, 6, 0, 0, 6639, 6640, 7, 9, 0, 0, 6640, 6641, 7, 6, 0, 0, 6641, 6642, + 7, 6, 0, 0, 6642, 6643, 7, 21, 0, 0, 6643, 740, 1, 0, 0, 0, 6644, 6645, + 7, 5, 0, 0, 6645, 6646, 7, 2, 0, 0, 6646, 6647, 7, 3, 0, 0, 6647, 6648, + 7, 13, 0, 0, 6648, 6649, 7, 6, 0, 0, 6649, 6650, 5, 95, 0, 0, 6650, 6651, + 7, 5, 0, 0, 6651, 6652, 7, 0, 0, 0, 6652, 6653, 7, 8, 0, 0, 6653, 6654, + 7, 11, 0, 0, 6654, 6655, 7, 2, 0, 0, 6655, 6656, 7, 15, 0, 0, 6656, 6657, + 7, 6, 0, 0, 6657, 6658, 7, 3, 0, 0, 6658, 6659, 5, 95, 0, 0, 6659, 6660, + 7, 0, 0, 0, 6660, 6661, 7, 11, 0, 0, 6661, 6662, 7, 11, 0, 0, 6662, 6663, + 7, 2, 0, 0, 6663, 6664, 7, 7, 0, 0, 6664, 6665, 5, 95, 0, 0, 6665, 6666, + 7, 14, 0, 0, 6666, 6667, 7, 0, 0, 0, 6667, 6668, 7, 4, 0, 0, 6668, 6669, + 7, 0, 0, 0, 6669, 6670, 5, 95, 0, 0, 6670, 6671, 7, 11, 0, 0, 6671, 6672, + 7, 2, 0, 0, 6672, 6673, 7, 9, 0, 0, 6673, 6674, 7, 9, 0, 0, 6674, 742, + 1, 0, 0, 0, 6675, 6676, 7, 5, 0, 0, 6676, 6677, 7, 2, 0, 0, 6677, 6678, + 7, 3, 0, 0, 6678, 6679, 7, 13, 0, 0, 6679, 6680, 7, 6, 0, 0, 6680, 6681, + 5, 95, 0, 0, 6681, 6682, 7, 9, 0, 0, 6682, 6683, 7, 6, 0, 0, 6683, 6684, + 7, 3, 0, 0, 6684, 6685, 7, 15, 0, 0, 6685, 6686, 7, 8, 0, 0, 6686, 6687, + 7, 13, 0, 0, 6687, 6688, 7, 6, 0, 0, 6688, 6689, 5, 95, 0, 0, 6689, 6690, + 7, 0, 0, 0, 6690, 6691, 7, 11, 0, 0, 6691, 6692, 7, 11, 0, 0, 6692, 6693, + 7, 2, 0, 0, 6693, 6694, 7, 7, 0, 0, 6694, 6695, 5, 95, 0, 0, 6695, 6696, + 7, 14, 0, 0, 6696, 6697, 7, 0, 0, 0, 6697, 6698, 7, 4, 0, 0, 6698, 6699, + 7, 0, 0, 0, 6699, 6700, 5, 95, 0, 0, 6700, 6701, 7, 11, 0, 0, 6701, 6702, + 7, 2, 0, 0, 6702, 6703, 7, 9, 0, 0, 6703, 6704, 7, 9, 0, 0, 6704, 744, + 1, 0, 0, 0, 6705, 6706, 7, 5, 0, 0, 6706, 6707, 7, 2, 0, 0, 6707, 6708, + 7, 3, 0, 0, 6708, 6709, 7, 6, 0, 0, 6709, 6710, 7, 8, 0, 0, 6710, 6711, + 7, 18, 0, 0, 6711, 6712, 7, 10, 0, 0, 6712, 746, 1, 0, 0, 0, 6713, 6714, + 7, 5, 0, 0, 6714, 6715, 7, 2, 0, 0, 6715, 6716, 7, 3, 0, 0, 6716, 6717, + 7, 17, 0, 0, 6717, 6718, 7, 0, 0, 0, 6718, 6719, 7, 4, 0, 0, 6719, 748, + 1, 0, 0, 0, 6720, 6721, 7, 5, 0, 0, 6721, 6722, 7, 2, 0, 0, 6722, 6723, + 7, 3, 0, 0, 6723, 6724, 7, 17, 0, 0, 6724, 6725, 7, 0, 0, 0, 6725, 6726, + 7, 4, 0, 0, 6726, 6727, 7, 17, 0, 0, 6727, 6728, 7, 6, 0, 0, 6728, 6729, + 7, 9, 0, 0, 6729, 6730, 7, 9, 0, 0, 6730, 6731, 7, 0, 0, 0, 6731, 6732, + 7, 18, 0, 0, 6732, 6733, 7, 6, 0, 0, 6733, 750, 1, 0, 0, 0, 6734, 6735, + 7, 5, 0, 0, 6735, 6736, 7, 2, 0, 0, 6736, 6737, 7, 3, 0, 0, 6737, 6738, + 7, 7, 0, 0, 6738, 6739, 7, 0, 0, 0, 6739, 6740, 7, 3, 0, 0, 6740, 6741, + 7, 14, 0, 0, 6741, 6742, 5, 95, 0, 0, 6742, 6743, 7, 2, 0, 0, 6743, 6744, + 7, 10, 0, 0, 6744, 6745, 7, 11, 0, 0, 6745, 6746, 7, 16, 0, 0, 6746, 752, + 1, 0, 0, 0, 6747, 6748, 7, 5, 0, 0, 6748, 6749, 7, 3, 0, 0, 6749, 6750, + 7, 6, 0, 0, 6750, 6751, 7, 6, 0, 0, 6751, 754, 1, 0, 0, 0, 6752, 6753, + 7, 5, 0, 0, 6753, 6754, 7, 3, 0, 0, 6754, 6755, 7, 6, 0, 0, 6755, 6756, + 7, 6, 0, 0, 6756, 6757, 7, 4, 0, 0, 6757, 6758, 7, 6, 0, 0, 6758, 6759, + 7, 22, 0, 0, 6759, 6760, 7, 4, 0, 0, 6760, 756, 1, 0, 0, 0, 6761, 6762, + 7, 5, 0, 0, 6762, 6763, 7, 3, 0, 0, 6763, 6764, 7, 6, 0, 0, 6764, 6765, + 7, 6, 0, 0, 6765, 6766, 7, 4, 0, 0, 6766, 6767, 7, 6, 0, 0, 6767, 6768, + 7, 22, 0, 0, 6768, 6769, 7, 4, 0, 0, 6769, 6770, 7, 4, 0, 0, 6770, 6771, + 7, 0, 0, 0, 6771, 6772, 7, 1, 0, 0, 6772, 6773, 7, 11, 0, 0, 6773, 6774, + 7, 6, 0, 0, 6774, 758, 1, 0, 0, 0, 6775, 6776, 7, 5, 0, 0, 6776, 6777, + 7, 3, 0, 0, 6777, 6778, 7, 2, 0, 0, 6778, 6779, 7, 17, 0, 0, 6779, 760, + 1, 0, 0, 0, 6780, 6781, 7, 5, 0, 0, 6781, 6782, 7, 12, 0, 0, 6782, 6783, + 7, 11, 0, 0, 6783, 6784, 7, 11, 0, 0, 6784, 762, 1, 0, 0, 0, 6785, 6786, + 7, 5, 0, 0, 6786, 6787, 7, 12, 0, 0, 6787, 6788, 7, 11, 0, 0, 6788, 6789, + 7, 11, 0, 0, 6789, 6790, 7, 9, 0, 0, 6790, 6791, 7, 13, 0, 0, 6791, 6792, + 7, 0, 0, 0, 6792, 6793, 7, 10, 0, 0, 6793, 764, 1, 0, 0, 0, 6794, 6795, + 7, 5, 0, 0, 6795, 6796, 7, 12, 0, 0, 6796, 6797, 7, 11, 0, 0, 6797, 6798, + 7, 11, 0, 0, 6798, 6799, 7, 4, 0, 0, 6799, 6800, 7, 6, 0, 0, 6800, 6801, + 7, 22, 0, 0, 6801, 6802, 7, 4, 0, 0, 6802, 766, 1, 0, 0, 0, 6803, 6804, + 7, 5, 0, 0, 6804, 6805, 7, 12, 0, 0, 6805, 6806, 7, 11, 0, 0, 6806, 6807, + 7, 11, 0, 0, 6807, 6808, 7, 4, 0, 0, 6808, 6809, 7, 6, 0, 0, 6809, 6810, + 7, 22, 0, 0, 6810, 6811, 7, 4, 0, 0, 6811, 6812, 7, 13, 0, 0, 6812, 6813, + 7, 0, 0, 0, 6813, 6814, 7, 4, 0, 0, 6814, 6815, 7, 0, 0, 0, 6815, 6816, + 7, 11, 0, 0, 6816, 6817, 7, 2, 0, 0, 6817, 6818, 7, 18, 0, 0, 6818, 6819, + 7, 20, 0, 0, 6819, 6820, 7, 3, 0, 0, 6820, 6821, 7, 2, 0, 0, 6821, 6822, + 7, 20, 0, 0, 6822, 6823, 7, 6, 0, 0, 6823, 6824, 7, 3, 0, 0, 6824, 6825, + 7, 4, 0, 0, 6825, 6826, 7, 16, 0, 0, 6826, 768, 1, 0, 0, 0, 6827, 6828, + 7, 5, 0, 0, 6828, 6829, 7, 12, 0, 0, 6829, 6830, 7, 11, 0, 0, 6830, 6831, + 7, 11, 0, 0, 6831, 6832, 7, 4, 0, 0, 6832, 6833, 7, 6, 0, 0, 6833, 6834, + 7, 22, 0, 0, 6834, 6835, 7, 4, 0, 0, 6835, 6836, 7, 9, 0, 0, 6836, 6837, + 7, 6, 0, 0, 6837, 6838, 7, 3, 0, 0, 6838, 6839, 7, 15, 0, 0, 6839, 6840, + 7, 8, 0, 0, 6840, 6841, 7, 13, 0, 0, 6841, 6842, 7, 6, 0, 0, 6842, 6843, + 7, 20, 0, 0, 6843, 6844, 7, 3, 0, 0, 6844, 6845, 7, 2, 0, 0, 6845, 6846, + 7, 20, 0, 0, 6846, 6847, 7, 6, 0, 0, 6847, 6848, 7, 3, 0, 0, 6848, 6849, + 7, 4, 0, 0, 6849, 6850, 7, 16, 0, 0, 6850, 770, 1, 0, 0, 0, 6851, 6852, + 7, 5, 0, 0, 6852, 6853, 7, 12, 0, 0, 6853, 6854, 7, 10, 0, 0, 6854, 6855, + 7, 13, 0, 0, 6855, 6856, 7, 4, 0, 0, 6856, 6857, 7, 8, 0, 0, 6857, 6858, + 7, 2, 0, 0, 6858, 6859, 7, 10, 0, 0, 6859, 772, 1, 0, 0, 0, 6860, 6861, + 7, 18, 0, 0, 6861, 6862, 7, 1, 0, 0, 6862, 774, 1, 0, 0, 0, 6863, 6864, + 7, 18, 0, 0, 6864, 6865, 7, 6, 0, 0, 6865, 6866, 7, 10, 0, 0, 6866, 6867, + 7, 6, 0, 0, 6867, 6868, 7, 3, 0, 0, 6868, 6869, 7, 0, 0, 0, 6869, 6870, + 7, 4, 0, 0, 6870, 6871, 7, 6, 0, 0, 6871, 6872, 7, 14, 0, 0, 6872, 776, + 1, 0, 0, 0, 6873, 6874, 7, 18, 0, 0, 6874, 6875, 7, 6, 0, 0, 6875, 6876, + 7, 2, 0, 0, 6876, 6877, 7, 18, 0, 0, 6877, 6878, 7, 3, 0, 0, 6878, 6879, + 7, 0, 0, 0, 6879, 6880, 7, 20, 0, 0, 6880, 6881, 7, 19, 0, 0, 6881, 6882, + 7, 16, 0, 0, 6882, 778, 1, 0, 0, 0, 6883, 6884, 7, 18, 0, 0, 6884, 6885, + 7, 6, 0, 0, 6885, 6886, 7, 2, 0, 0, 6886, 6887, 7, 18, 0, 0, 6887, 6888, + 7, 3, 0, 0, 6888, 6889, 7, 0, 0, 0, 6889, 6890, 7, 20, 0, 0, 6890, 6891, + 7, 19, 0, 0, 6891, 6892, 7, 16, 0, 0, 6892, 6893, 5, 95, 0, 0, 6893, 6894, + 7, 0, 0, 0, 6894, 6895, 7, 12, 0, 0, 6895, 6896, 7, 4, 0, 0, 6896, 6897, + 7, 2, 0, 0, 6897, 6898, 5, 95, 0, 0, 6898, 6899, 7, 18, 0, 0, 6899, 6900, + 7, 3, 0, 0, 6900, 6901, 7, 8, 0, 0, 6901, 6902, 7, 14, 0, 0, 6902, 780, + 1, 0, 0, 0, 6903, 6904, 7, 18, 0, 0, 6904, 6905, 7, 6, 0, 0, 6905, 6906, + 7, 2, 0, 0, 6906, 6907, 7, 18, 0, 0, 6907, 6908, 7, 3, 0, 0, 6908, 6909, + 7, 0, 0, 0, 6909, 6910, 7, 20, 0, 0, 6910, 6911, 7, 19, 0, 0, 6911, 6912, + 7, 16, 0, 0, 6912, 6913, 5, 95, 0, 0, 6913, 6914, 7, 18, 0, 0, 6914, 6915, + 7, 3, 0, 0, 6915, 6916, 7, 8, 0, 0, 6916, 6917, 7, 14, 0, 0, 6917, 782, + 1, 0, 0, 0, 6918, 6919, 7, 18, 0, 0, 6919, 6920, 7, 6, 0, 0, 6920, 6921, + 7, 2, 0, 0, 6921, 6922, 7, 17, 0, 0, 6922, 6923, 7, 6, 0, 0, 6923, 6924, + 7, 4, 0, 0, 6924, 6925, 7, 3, 0, 0, 6925, 6926, 7, 16, 0, 0, 6926, 784, + 1, 0, 0, 0, 6927, 6928, 7, 18, 0, 0, 6928, 6929, 7, 6, 0, 0, 6929, 6930, + 7, 2, 0, 0, 6930, 6931, 7, 17, 0, 0, 6931, 6932, 7, 6, 0, 0, 6932, 6933, + 7, 4, 0, 0, 6933, 6934, 7, 3, 0, 0, 6934, 6935, 7, 16, 0, 0, 6935, 6936, + 5, 95, 0, 0, 6936, 6937, 7, 0, 0, 0, 6937, 6938, 7, 12, 0, 0, 6938, 6939, + 7, 4, 0, 0, 6939, 6940, 7, 2, 0, 0, 6940, 6941, 5, 95, 0, 0, 6941, 6942, + 7, 18, 0, 0, 6942, 6943, 7, 3, 0, 0, 6943, 6944, 7, 8, 0, 0, 6944, 6945, + 7, 14, 0, 0, 6945, 786, 1, 0, 0, 0, 6946, 6947, 7, 18, 0, 0, 6947, 6948, + 7, 6, 0, 0, 6948, 6949, 7, 2, 0, 0, 6949, 6950, 7, 17, 0, 0, 6950, 6951, + 7, 6, 0, 0, 6951, 6952, 7, 4, 0, 0, 6952, 6953, 7, 3, 0, 0, 6953, 6954, + 7, 16, 0, 0, 6954, 6955, 5, 95, 0, 0, 6955, 6956, 7, 18, 0, 0, 6956, 6957, + 7, 3, 0, 0, 6957, 6958, 7, 8, 0, 0, 6958, 6959, 7, 14, 0, 0, 6959, 788, + 1, 0, 0, 0, 6960, 6961, 7, 18, 0, 0, 6961, 6962, 7, 6, 0, 0, 6962, 6963, + 7, 4, 0, 0, 6963, 790, 1, 0, 0, 0, 6964, 6965, 7, 18, 0, 0, 6965, 6966, + 7, 3, 0, 0, 6966, 6967, 7, 8, 0, 0, 6967, 6968, 7, 14, 0, 0, 6968, 6969, + 7, 9, 0, 0, 6969, 792, 1, 0, 0, 0, 6970, 6971, 7, 18, 0, 0, 6971, 6972, + 7, 6, 0, 0, 6972, 6973, 7, 4, 0, 0, 6973, 6974, 7, 0, 0, 0, 6974, 6975, + 7, 10, 0, 0, 6975, 6976, 7, 13, 0, 0, 6976, 6977, 7, 6, 0, 0, 6977, 6978, + 7, 9, 0, 0, 6978, 6979, 7, 4, 0, 0, 6979, 6980, 7, 2, 0, 0, 6980, 6981, + 7, 3, 0, 0, 6981, 794, 1, 0, 0, 0, 6982, 6983, 7, 18, 0, 0, 6983, 6984, + 7, 6, 0, 0, 6984, 6985, 7, 4, 0, 0, 6985, 6986, 7, 0, 0, 0, 6986, 6987, + 7, 10, 0, 0, 6987, 6988, 7, 9, 0, 0, 6988, 6989, 7, 8, 0, 0, 6989, 6990, + 7, 10, 0, 0, 6990, 6991, 7, 12, 0, 0, 6991, 6992, 7, 11, 0, 0, 6992, 6993, + 7, 11, 0, 0, 6993, 796, 1, 0, 0, 0, 6994, 6995, 7, 18, 0, 0, 6995, 6996, + 7, 6, 0, 0, 6996, 6997, 7, 4, 0, 0, 6997, 6998, 7, 14, 0, 0, 6998, 6999, + 7, 0, 0, 0, 6999, 7000, 7, 4, 0, 0, 7000, 7001, 7, 6, 0, 0, 7001, 798, + 1, 0, 0, 0, 7002, 7003, 7, 18, 0, 0, 7003, 7004, 7, 6, 0, 0, 7004, 7005, + 7, 4, 0, 0, 7005, 7006, 7, 14, 0, 0, 7006, 7007, 7, 6, 0, 0, 7007, 7008, + 7, 9, 0, 0, 7008, 7009, 7, 13, 0, 0, 7009, 7010, 7, 6, 0, 0, 7010, 7011, + 7, 10, 0, 0, 7011, 7012, 7, 14, 0, 0, 7012, 7013, 7, 0, 0, 0, 7013, 7014, + 7, 10, 0, 0, 7014, 7015, 7, 4, 0, 0, 7015, 800, 1, 0, 0, 0, 7016, 7017, + 7, 18, 0, 0, 7017, 7018, 7, 6, 0, 0, 7018, 7019, 7, 4, 0, 0, 7019, 7020, + 7, 11, 0, 0, 7020, 7021, 7, 6, 0, 0, 7021, 7022, 7, 15, 0, 0, 7022, 7023, + 7, 6, 0, 0, 7023, 7024, 7, 11, 0, 0, 7024, 802, 1, 0, 0, 0, 7025, 7026, + 7, 18, 0, 0, 7026, 7027, 7, 6, 0, 0, 7027, 7028, 7, 4, 0, 0, 7028, 7029, + 7, 3, 0, 0, 7029, 7030, 7, 6, 0, 0, 7030, 7031, 7, 20, 0, 0, 7031, 7032, + 7, 0, 0, 0, 7032, 7033, 7, 3, 0, 0, 7033, 7034, 7, 6, 0, 0, 7034, 7035, + 7, 10, 0, 0, 7035, 7036, 7, 4, 0, 0, 7036, 7037, 7, 6, 0, 0, 7037, 7038, + 7, 14, 0, 0, 7038, 7039, 7, 15, 0, 0, 7039, 7040, 7, 0, 0, 0, 7040, 7041, + 7, 11, 0, 0, 7041, 7042, 7, 12, 0, 0, 7042, 7043, 7, 6, 0, 0, 7043, 804, + 1, 0, 0, 0, 7044, 7045, 7, 18, 0, 0, 7045, 7046, 7, 6, 0, 0, 7046, 7047, + 7, 4, 0, 0, 7047, 7048, 7, 3, 0, 0, 7048, 7049, 7, 2, 0, 0, 7049, 7050, + 7, 2, 0, 0, 7050, 7051, 7, 4, 0, 0, 7051, 806, 1, 0, 0, 0, 7052, 7053, + 7, 18, 0, 0, 7053, 7054, 7, 6, 0, 0, 7054, 7055, 7, 4, 0, 0, 7055, 7056, + 7, 12, 0, 0, 7056, 7057, 7, 4, 0, 0, 7057, 7058, 7, 13, 0, 0, 7058, 7059, + 7, 14, 0, 0, 7059, 7060, 7, 0, 0, 0, 7060, 7061, 7, 4, 0, 0, 7061, 7062, + 7, 6, 0, 0, 7062, 808, 1, 0, 0, 0, 7063, 7064, 7, 18, 0, 0, 7064, 7065, + 7, 6, 0, 0, 7065, 7066, 7, 4, 0, 0, 7066, 7067, 5, 95, 0, 0, 7067, 7068, + 7, 5, 0, 0, 7068, 7069, 7, 8, 0, 0, 7069, 7070, 7, 11, 0, 0, 7070, 7071, + 7, 6, 0, 0, 7071, 7072, 7, 9, 0, 0, 7072, 7073, 7, 4, 0, 0, 7073, 7074, + 7, 3, 0, 0, 7074, 7075, 7, 6, 0, 0, 7075, 7076, 7, 0, 0, 0, 7076, 7077, + 7, 17, 0, 0, 7077, 7078, 5, 95, 0, 0, 7078, 7079, 7, 4, 0, 0, 7079, 7080, + 7, 3, 0, 0, 7080, 7081, 7, 0, 0, 0, 7081, 7082, 7, 10, 0, 0, 7082, 7083, + 7, 9, 0, 0, 7083, 7084, 7, 0, 0, 0, 7084, 7085, 7, 13, 0, 0, 7085, 7086, + 7, 4, 0, 0, 7086, 7087, 7, 8, 0, 0, 7087, 7088, 7, 2, 0, 0, 7088, 7089, + 7, 10, 0, 0, 7089, 7090, 5, 95, 0, 0, 7090, 7091, 7, 13, 0, 0, 7091, 7092, + 7, 2, 0, 0, 7092, 7093, 7, 10, 0, 0, 7093, 7094, 7, 4, 0, 0, 7094, 7095, + 7, 6, 0, 0, 7095, 7096, 7, 22, 0, 0, 7096, 7097, 7, 4, 0, 0, 7097, 810, + 1, 0, 0, 0, 7098, 7099, 7, 18, 0, 0, 7099, 7100, 7, 11, 0, 0, 7100, 7101, + 7, 2, 0, 0, 7101, 7102, 7, 1, 0, 0, 7102, 7103, 7, 0, 0, 0, 7103, 7104, + 7, 11, 0, 0, 7104, 812, 1, 0, 0, 0, 7105, 7106, 7, 18, 0, 0, 7106, 7107, + 7, 2, 0, 0, 7107, 814, 1, 0, 0, 0, 7108, 7109, 7, 18, 0, 0, 7109, 7110, + 7, 2, 0, 0, 7110, 7111, 7, 4, 0, 0, 7111, 7112, 7, 2, 0, 0, 7112, 816, + 1, 0, 0, 0, 7113, 7114, 7, 18, 0, 0, 7114, 7115, 7, 2, 0, 0, 7115, 7116, + 7, 15, 0, 0, 7116, 7117, 7, 6, 0, 0, 7117, 7118, 7, 3, 0, 0, 7118, 7119, + 7, 10, 0, 0, 7119, 7120, 7, 2, 0, 0, 7120, 7121, 7, 3, 0, 0, 7121, 818, + 1, 0, 0, 0, 7122, 7123, 7, 18, 0, 0, 7123, 7124, 7, 3, 0, 0, 7124, 7125, + 7, 0, 0, 0, 7125, 7126, 7, 10, 0, 0, 7126, 7127, 7, 4, 0, 0, 7127, 820, + 1, 0, 0, 0, 7128, 7129, 7, 18, 0, 0, 7129, 7130, 7, 3, 0, 0, 7130, 7131, + 7, 6, 0, 0, 7131, 7132, 7, 0, 0, 0, 7132, 7133, 7, 4, 0, 0, 7133, 7134, + 7, 6, 0, 0, 7134, 7135, 7, 9, 0, 0, 7135, 7136, 7, 4, 0, 0, 7136, 822, + 1, 0, 0, 0, 7137, 7138, 7, 18, 0, 0, 7138, 7139, 7, 3, 0, 0, 7139, 7140, + 7, 2, 0, 0, 7140, 7141, 7, 12, 0, 0, 7141, 7142, 7, 20, 0, 0, 7142, 824, + 1, 0, 0, 0, 7143, 7144, 7, 18, 0, 0, 7144, 7145, 7, 3, 0, 0, 7145, 7146, + 7, 2, 0, 0, 7146, 7147, 7, 12, 0, 0, 7147, 7148, 7, 20, 0, 0, 7148, 7149, + 7, 8, 0, 0, 7149, 7150, 7, 10, 0, 0, 7150, 7151, 7, 18, 0, 0, 7151, 826, + 1, 0, 0, 0, 7152, 7153, 7, 18, 0, 0, 7153, 7154, 7, 3, 0, 0, 7154, 7155, + 7, 2, 0, 0, 7155, 7156, 7, 12, 0, 0, 7156, 7157, 7, 20, 0, 0, 7157, 7158, + 7, 8, 0, 0, 7158, 7159, 7, 10, 0, 0, 7159, 7160, 7, 18, 0, 0, 7160, 7161, + 5, 95, 0, 0, 7161, 7162, 7, 8, 0, 0, 7162, 7163, 7, 14, 0, 0, 7163, 828, + 1, 0, 0, 0, 7164, 7165, 7, 18, 0, 0, 7165, 7166, 7, 3, 0, 0, 7166, 7167, + 7, 2, 0, 0, 7167, 7168, 7, 12, 0, 0, 7168, 7169, 7, 20, 0, 0, 7169, 7170, + 5, 95, 0, 0, 7170, 7171, 7, 17, 0, 0, 7171, 7172, 7, 0, 0, 0, 7172, 7173, + 7, 22, 0, 0, 7173, 7174, 5, 95, 0, 0, 7174, 7175, 7, 3, 0, 0, 7175, 7176, + 7, 6, 0, 0, 7176, 7177, 7, 25, 0, 0, 7177, 7178, 7, 12, 0, 0, 7178, 7179, + 7, 6, 0, 0, 7179, 7180, 7, 9, 0, 0, 7180, 7181, 7, 4, 0, 0, 7181, 7182, + 7, 9, 0, 0, 7182, 830, 1, 0, 0, 0, 7183, 7184, 7, 19, 0, 0, 7184, 7185, + 7, 0, 0, 0, 7185, 7186, 7, 14, 0, 0, 7186, 7187, 7, 3, 0, 0, 7187, 832, + 1, 0, 0, 0, 7188, 7189, 7, 19, 0, 0, 7189, 7190, 7, 0, 0, 0, 7190, 7191, + 7, 9, 0, 0, 7191, 7192, 7, 19, 0, 0, 7192, 834, 1, 0, 0, 0, 7193, 7194, + 7, 19, 0, 0, 7194, 7195, 7, 0, 0, 0, 7195, 7196, 7, 9, 0, 0, 7196, 7197, + 7, 19, 0, 0, 7197, 7198, 7, 6, 0, 0, 7198, 7199, 7, 14, 0, 0, 7199, 836, + 1, 0, 0, 0, 7200, 7201, 7, 19, 0, 0, 7201, 7202, 7, 0, 0, 0, 7202, 7203, + 7, 9, 0, 0, 7203, 7204, 5, 95, 0, 0, 7204, 7205, 7, 14, 0, 0, 7205, 7206, + 7, 1, 0, 0, 7206, 7207, 7, 0, 0, 0, 7207, 7208, 7, 13, 0, 0, 7208, 7209, + 7, 13, 0, 0, 7209, 7210, 7, 6, 0, 0, 7210, 7211, 7, 9, 0, 0, 7211, 7212, + 7, 9, 0, 0, 7212, 838, 1, 0, 0, 0, 7213, 7214, 7, 19, 0, 0, 7214, 7215, + 7, 0, 0, 0, 7215, 7216, 7, 9, 0, 0, 7216, 7217, 5, 95, 0, 0, 7217, 7218, + 7, 20, 0, 0, 7218, 7219, 7, 6, 0, 0, 7219, 7220, 7, 3, 0, 0, 7220, 7221, + 7, 17, 0, 0, 7221, 7222, 7, 9, 0, 0, 7222, 7223, 5, 95, 0, 0, 7223, 7224, + 7, 1, 0, 0, 7224, 7225, 7, 16, 0, 0, 7225, 7226, 5, 95, 0, 0, 7226, 7227, + 7, 10, 0, 0, 7227, 7228, 7, 0, 0, 0, 7228, 7229, 7, 17, 0, 0, 7229, 7230, + 7, 6, 0, 0, 7230, 840, 1, 0, 0, 0, 7231, 7232, 7, 19, 0, 0, 7232, 7233, + 7, 0, 0, 0, 7233, 7234, 7, 15, 0, 0, 7234, 7235, 7, 8, 0, 0, 7235, 7236, + 7, 10, 0, 0, 7236, 7237, 7, 18, 0, 0, 7237, 842, 1, 0, 0, 0, 7238, 7239, + 7, 19, 0, 0, 7239, 7240, 7, 6, 0, 0, 7240, 7241, 7, 0, 0, 0, 7241, 7242, + 7, 11, 0, 0, 7242, 7243, 7, 4, 0, 0, 7243, 7244, 7, 19, 0, 0, 7244, 7245, + 7, 13, 0, 0, 7245, 7246, 7, 19, 0, 0, 7246, 7247, 7, 6, 0, 0, 7247, 7248, + 7, 13, 0, 0, 7248, 7249, 7, 21, 0, 0, 7249, 7250, 7, 4, 0, 0, 7250, 7251, + 7, 8, 0, 0, 7251, 7252, 7, 17, 0, 0, 7252, 7253, 7, 6, 0, 0, 7253, 7254, + 7, 2, 0, 0, 7254, 7255, 7, 12, 0, 0, 7255, 7256, 7, 4, 0, 0, 7256, 844, + 1, 0, 0, 0, 7257, 7258, 7, 19, 0, 0, 7258, 7259, 7, 6, 0, 0, 7259, 7260, + 7, 0, 0, 0, 7260, 7261, 7, 11, 0, 0, 7261, 7262, 7, 4, 0, 0, 7262, 7263, + 7, 19, 0, 0, 7263, 7264, 5, 95, 0, 0, 7264, 7265, 7, 13, 0, 0, 7265, 7266, + 7, 19, 0, 0, 7266, 7267, 7, 6, 0, 0, 7267, 7268, 7, 13, 0, 0, 7268, 7269, + 7, 21, 0, 0, 7269, 7270, 5, 95, 0, 0, 7270, 7271, 7, 4, 0, 0, 7271, 7272, + 7, 8, 0, 0, 7272, 7273, 7, 17, 0, 0, 7273, 7274, 7, 6, 0, 0, 7274, 7275, + 7, 2, 0, 0, 7275, 7276, 7, 12, 0, 0, 7276, 7277, 7, 4, 0, 0, 7277, 846, + 1, 0, 0, 0, 7278, 7279, 7, 19, 0, 0, 7279, 7280, 7, 6, 0, 0, 7280, 7281, + 7, 0, 0, 0, 7281, 7282, 7, 20, 0, 0, 7282, 848, 1, 0, 0, 0, 7283, 7284, + 7, 19, 0, 0, 7284, 7285, 7, 8, 0, 0, 7285, 7286, 7, 14, 0, 0, 7286, 7287, + 7, 14, 0, 0, 7287, 7288, 7, 6, 0, 0, 7288, 7289, 7, 10, 0, 0, 7289, 850, + 1, 0, 0, 0, 7290, 7291, 7, 19, 0, 0, 7291, 7292, 7, 8, 0, 0, 7292, 7293, + 7, 6, 0, 0, 7293, 7294, 7, 3, 0, 0, 7294, 7295, 7, 0, 0, 0, 7295, 7296, + 7, 3, 0, 0, 7296, 7297, 7, 13, 0, 0, 7297, 7298, 7, 19, 0, 0, 7298, 7299, + 7, 16, 0, 0, 7299, 7300, 7, 8, 0, 0, 7300, 7301, 7, 14, 0, 0, 7301, 852, + 1, 0, 0, 0, 7302, 7303, 7, 19, 0, 0, 7303, 7304, 7, 8, 0, 0, 7304, 7305, + 7, 18, 0, 0, 7305, 7306, 7, 19, 0, 0, 7306, 854, 1, 0, 0, 0, 7307, 7308, + 7, 19, 0, 0, 7308, 7309, 7, 2, 0, 0, 7309, 7310, 7, 11, 0, 0, 7310, 7311, + 7, 14, 0, 0, 7311, 7312, 7, 11, 0, 0, 7312, 7313, 7, 2, 0, 0, 7313, 7314, + 7, 13, 0, 0, 7314, 7315, 7, 21, 0, 0, 7315, 856, 1, 0, 0, 0, 7316, 7317, + 7, 19, 0, 0, 7317, 7318, 7, 2, 0, 0, 7318, 7319, 7, 10, 0, 0, 7319, 7320, + 7, 2, 0, 0, 7320, 7321, 7, 3, 0, 0, 7321, 7322, 5, 95, 0, 0, 7322, 7323, + 7, 1, 0, 0, 7323, 7324, 7, 3, 0, 0, 7324, 7325, 7, 2, 0, 0, 7325, 7326, + 7, 21, 0, 0, 7326, 7327, 7, 6, 0, 0, 7327, 7328, 7, 3, 0, 0, 7328, 7329, + 5, 95, 0, 0, 7329, 7330, 7, 20, 0, 0, 7330, 7331, 7, 3, 0, 0, 7331, 7332, + 7, 8, 0, 0, 7332, 7333, 7, 2, 0, 0, 7333, 7334, 7, 3, 0, 0, 7334, 7335, + 7, 8, 0, 0, 7335, 7336, 7, 4, 0, 0, 7336, 7337, 7, 16, 0, 0, 7337, 858, + 1, 0, 0, 0, 7338, 7339, 7, 19, 0, 0, 7339, 7340, 7, 2, 0, 0, 7340, 7341, + 7, 9, 0, 0, 7341, 7342, 7, 4, 0, 0, 7342, 7343, 5, 95, 0, 0, 7343, 7344, + 7, 8, 0, 0, 7344, 7345, 7, 14, 0, 0, 7345, 860, 1, 0, 0, 0, 7346, 7347, + 7, 19, 0, 0, 7347, 7348, 7, 2, 0, 0, 7348, 7349, 7, 9, 0, 0, 7349, 7350, + 7, 4, 0, 0, 7350, 7351, 5, 95, 0, 0, 7351, 7352, 7, 10, 0, 0, 7352, 7353, + 7, 0, 0, 0, 7353, 7354, 7, 17, 0, 0, 7354, 7355, 7, 6, 0, 0, 7355, 862, + 1, 0, 0, 0, 7356, 7357, 7, 19, 0, 0, 7357, 7358, 7, 2, 0, 0, 7358, 7359, + 7, 12, 0, 0, 7359, 7360, 7, 3, 0, 0, 7360, 7361, 7, 9, 0, 0, 7361, 864, + 1, 0, 0, 0, 7362, 7363, 7, 8, 0, 0, 7363, 7364, 7, 14, 0, 0, 7364, 7365, + 7, 6, 0, 0, 7365, 7366, 7, 10, 0, 0, 7366, 7367, 7, 4, 0, 0, 7367, 7368, + 7, 8, 0, 0, 7368, 7369, 7, 4, 0, 0, 7369, 7370, 7, 16, 0, 0, 7370, 866, + 1, 0, 0, 0, 7371, 7372, 7, 8, 0, 0, 7372, 7373, 7, 14, 0, 0, 7373, 7374, + 7, 6, 0, 0, 7374, 7375, 7, 10, 0, 0, 7375, 7376, 7, 4, 0, 0, 7376, 7377, + 7, 8, 0, 0, 7377, 7378, 7, 4, 0, 0, 7378, 7379, 7, 16, 0, 0, 7379, 7380, + 7, 13, 0, 0, 7380, 7381, 7, 2, 0, 0, 7381, 7382, 7, 11, 0, 0, 7382, 868, + 1, 0, 0, 0, 7383, 7384, 7, 8, 0, 0, 7384, 7385, 7, 14, 0, 0, 7385, 7386, + 7, 6, 0, 0, 7386, 7387, 7, 10, 0, 0, 7387, 7388, 7, 4, 0, 0, 7388, 7389, + 7, 8, 0, 0, 7389, 7390, 7, 4, 0, 0, 7390, 7391, 7, 16, 0, 0, 7391, 7392, + 5, 95, 0, 0, 7392, 7393, 7, 8, 0, 0, 7393, 7394, 7, 10, 0, 0, 7394, 7395, + 7, 9, 0, 0, 7395, 7396, 7, 6, 0, 0, 7396, 7397, 7, 3, 0, 0, 7397, 7398, + 7, 4, 0, 0, 7398, 870, 1, 0, 0, 0, 7399, 7400, 7, 8, 0, 0, 7400, 7401, + 7, 14, 0, 0, 7401, 7402, 7, 6, 0, 0, 7402, 7403, 7, 10, 0, 0, 7403, 7404, + 7, 4, 0, 0, 7404, 7405, 7, 8, 0, 0, 7405, 7406, 7, 4, 0, 0, 7406, 7407, + 7, 16, 0, 0, 7407, 7408, 5, 95, 0, 0, 7408, 7409, 7, 15, 0, 0, 7409, 7410, + 7, 0, 0, 0, 7410, 7411, 7, 11, 0, 0, 7411, 7412, 7, 12, 0, 0, 7412, 7413, + 7, 6, 0, 0, 7413, 872, 1, 0, 0, 0, 7414, 7415, 7, 8, 0, 0, 7415, 7416, + 7, 14, 0, 0, 7416, 7417, 7, 6, 0, 0, 7417, 7418, 7, 10, 0, 0, 7418, 7419, + 7, 4, 0, 0, 7419, 7420, 5, 95, 0, 0, 7420, 7421, 7, 13, 0, 0, 7421, 7422, + 7, 12, 0, 0, 7422, 7423, 7, 3, 0, 0, 7423, 7424, 7, 3, 0, 0, 7424, 7425, + 7, 6, 0, 0, 7425, 7426, 7, 10, 0, 0, 7426, 7427, 7, 4, 0, 0, 7427, 874, + 1, 0, 0, 0, 7428, 7429, 7, 8, 0, 0, 7429, 7430, 7, 14, 0, 0, 7430, 7431, + 7, 6, 0, 0, 7431, 7432, 7, 10, 0, 0, 7432, 7433, 7, 4, 0, 0, 7433, 7434, + 5, 95, 0, 0, 7434, 7435, 7, 8, 0, 0, 7435, 7436, 7, 10, 0, 0, 7436, 7437, + 7, 13, 0, 0, 7437, 7438, 7, 3, 0, 0, 7438, 876, 1, 0, 0, 0, 7439, 7440, + 7, 8, 0, 0, 7440, 7441, 7, 14, 0, 0, 7441, 7442, 7, 6, 0, 0, 7442, 7443, + 7, 10, 0, 0, 7443, 7444, 7, 4, 0, 0, 7444, 7445, 5, 95, 0, 0, 7445, 7446, + 7, 9, 0, 0, 7446, 7447, 7, 6, 0, 0, 7447, 7448, 7, 6, 0, 0, 7448, 7449, + 7, 14, 0, 0, 7449, 878, 1, 0, 0, 0, 7450, 7451, 7, 8, 0, 0, 7451, 7452, + 7, 5, 0, 0, 7452, 880, 1, 0, 0, 0, 7453, 7454, 7, 8, 0, 0, 7454, 7455, + 7, 18, 0, 0, 7455, 7456, 7, 10, 0, 0, 7456, 7457, 7, 2, 0, 0, 7457, 7458, + 7, 3, 0, 0, 7458, 7459, 7, 6, 0, 0, 7459, 7460, 5, 95, 0, 0, 7460, 7461, + 7, 13, 0, 0, 7461, 7462, 7, 2, 0, 0, 7462, 7463, 7, 10, 0, 0, 7463, 7464, + 7, 9, 0, 0, 7464, 7465, 7, 4, 0, 0, 7465, 7466, 7, 3, 0, 0, 7466, 7467, + 7, 0, 0, 0, 7467, 7468, 7, 8, 0, 0, 7468, 7469, 7, 10, 0, 0, 7469, 7470, + 7, 4, 0, 0, 7470, 7471, 7, 9, 0, 0, 7471, 882, 1, 0, 0, 0, 7472, 7473, + 7, 8, 0, 0, 7473, 7474, 7, 18, 0, 0, 7474, 7475, 7, 10, 0, 0, 7475, 7476, + 7, 2, 0, 0, 7476, 7477, 7, 3, 0, 0, 7477, 7478, 7, 6, 0, 0, 7478, 7479, + 5, 95, 0, 0, 7479, 7480, 7, 14, 0, 0, 7480, 7481, 7, 12, 0, 0, 7481, 7482, + 7, 20, 0, 0, 7482, 7483, 5, 95, 0, 0, 7483, 7484, 7, 21, 0, 0, 7484, 7485, + 7, 6, 0, 0, 7485, 7486, 7, 16, 0, 0, 7486, 884, 1, 0, 0, 0, 7487, 7488, + 7, 8, 0, 0, 7488, 7489, 7, 18, 0, 0, 7489, 7490, 7, 10, 0, 0, 7490, 7491, + 7, 2, 0, 0, 7491, 7492, 7, 3, 0, 0, 7492, 7493, 7, 6, 0, 0, 7493, 7494, + 5, 95, 0, 0, 7494, 7495, 7, 10, 0, 0, 7495, 7496, 7, 2, 0, 0, 7496, 7497, + 7, 10, 0, 0, 7497, 7498, 7, 13, 0, 0, 7498, 7499, 7, 11, 0, 0, 7499, 7500, + 7, 12, 0, 0, 7500, 7501, 7, 9, 0, 0, 7501, 7502, 7, 4, 0, 0, 7502, 7503, + 7, 6, 0, 0, 7503, 7504, 7, 3, 0, 0, 7504, 7505, 7, 6, 0, 0, 7505, 7506, + 7, 14, 0, 0, 7506, 7507, 5, 95, 0, 0, 7507, 7508, 7, 13, 0, 0, 7508, 7509, + 7, 2, 0, 0, 7509, 7510, 7, 11, 0, 0, 7510, 7511, 7, 12, 0, 0, 7511, 7512, + 7, 17, 0, 0, 7512, 7513, 7, 10, 0, 0, 7513, 7514, 7, 9, 0, 0, 7514, 7515, + 7, 4, 0, 0, 7515, 7516, 7, 2, 0, 0, 7516, 7517, 7, 3, 0, 0, 7517, 7518, + 7, 6, 0, 0, 7518, 7519, 5, 95, 0, 0, 7519, 7520, 7, 8, 0, 0, 7520, 7521, + 7, 10, 0, 0, 7521, 7522, 7, 14, 0, 0, 7522, 7523, 7, 6, 0, 0, 7523, 7524, + 7, 22, 0, 0, 7524, 886, 1, 0, 0, 0, 7525, 7526, 7, 8, 0, 0, 7526, 7527, + 7, 18, 0, 0, 7527, 7528, 7, 10, 0, 0, 7528, 7529, 7, 2, 0, 0, 7529, 7530, + 7, 3, 0, 0, 7530, 7531, 7, 6, 0, 0, 7531, 7532, 5, 95, 0, 0, 7532, 7533, + 7, 3, 0, 0, 7533, 7534, 7, 6, 0, 0, 7534, 7535, 7, 20, 0, 0, 7535, 7536, + 7, 11, 0, 0, 7536, 7537, 7, 8, 0, 0, 7537, 7538, 7, 13, 0, 0, 7538, 7539, + 7, 0, 0, 0, 7539, 7540, 7, 4, 0, 0, 7540, 7541, 7, 6, 0, 0, 7541, 7542, + 7, 14, 0, 0, 7542, 7543, 5, 95, 0, 0, 7543, 7544, 7, 4, 0, 0, 7544, 7545, + 7, 0, 0, 0, 7545, 7546, 7, 1, 0, 0, 7546, 7547, 7, 11, 0, 0, 7547, 7548, + 7, 6, 0, 0, 7548, 7549, 5, 95, 0, 0, 7549, 7550, 7, 13, 0, 0, 7550, 7551, + 7, 0, 0, 0, 7551, 7552, 7, 13, 0, 0, 7552, 7553, 7, 19, 0, 0, 7553, 7554, + 7, 6, 0, 0, 7554, 888, 1, 0, 0, 0, 7555, 7556, 7, 8, 0, 0, 7556, 7557, + 7, 18, 0, 0, 7557, 7558, 7, 10, 0, 0, 7558, 7559, 7, 2, 0, 0, 7559, 7560, + 7, 3, 0, 0, 7560, 7561, 7, 6, 0, 0, 7561, 7562, 5, 95, 0, 0, 7562, 7563, + 7, 4, 0, 0, 7563, 7564, 7, 3, 0, 0, 7564, 7565, 7, 8, 0, 0, 7565, 7566, + 7, 18, 0, 0, 7566, 7567, 7, 18, 0, 0, 7567, 7568, 7, 6, 0, 0, 7568, 7569, + 7, 3, 0, 0, 7569, 7570, 7, 9, 0, 0, 7570, 890, 1, 0, 0, 0, 7571, 7572, + 7, 8, 0, 0, 7572, 7573, 7, 8, 0, 0, 7573, 7574, 7, 5, 0, 0, 7574, 892, + 1, 0, 0, 0, 7575, 7576, 7, 8, 0, 0, 7576, 7577, 7, 17, 0, 0, 7577, 7578, + 7, 17, 0, 0, 7578, 7579, 7, 6, 0, 0, 7579, 7580, 7, 14, 0, 0, 7580, 7581, + 7, 8, 0, 0, 7581, 7582, 7, 0, 0, 0, 7582, 7583, 7, 4, 0, 0, 7583, 7584, + 7, 6, 0, 0, 7584, 894, 1, 0, 0, 0, 7585, 7586, 7, 8, 0, 0, 7586, 7587, + 7, 17, 0, 0, 7587, 7588, 7, 20, 0, 0, 7588, 7589, 7, 6, 0, 0, 7589, 7590, + 7, 3, 0, 0, 7590, 7591, 7, 9, 0, 0, 7591, 7592, 7, 2, 0, 0, 7592, 7593, + 7, 10, 0, 0, 7593, 7594, 7, 0, 0, 0, 7594, 7595, 7, 4, 0, 0, 7595, 7596, + 7, 6, 0, 0, 7596, 896, 1, 0, 0, 0, 7597, 7598, 7, 8, 0, 0, 7598, 7599, + 7, 17, 0, 0, 7599, 7600, 7, 20, 0, 0, 7600, 7601, 7, 11, 0, 0, 7601, 7602, + 7, 8, 0, 0, 7602, 7603, 7, 13, 0, 0, 7603, 7604, 7, 8, 0, 0, 7604, 7605, + 7, 4, 0, 0, 7605, 7606, 5, 95, 0, 0, 7606, 7607, 7, 4, 0, 0, 7607, 7608, + 7, 3, 0, 0, 7608, 7609, 7, 0, 0, 0, 7609, 7610, 7, 10, 0, 0, 7610, 7611, + 7, 9, 0, 0, 7611, 7612, 7, 0, 0, 0, 7612, 7613, 7, 13, 0, 0, 7613, 7614, + 7, 4, 0, 0, 7614, 7615, 7, 8, 0, 0, 7615, 7616, 7, 2, 0, 0, 7616, 7617, + 7, 10, 0, 0, 7617, 7618, 7, 9, 0, 0, 7618, 898, 1, 0, 0, 0, 7619, 7620, + 7, 8, 0, 0, 7620, 7621, 7, 17, 0, 0, 7621, 7622, 7, 20, 0, 0, 7622, 7623, + 7, 2, 0, 0, 7623, 7624, 7, 3, 0, 0, 7624, 7625, 7, 4, 0, 0, 7625, 7626, + 7, 0, 0, 0, 7626, 7627, 7, 10, 0, 0, 7627, 7628, 7, 13, 0, 0, 7628, 7629, + 7, 6, 0, 0, 7629, 900, 1, 0, 0, 0, 7630, 7631, 7, 8, 0, 0, 7631, 7632, + 7, 10, 0, 0, 7632, 902, 1, 0, 0, 0, 7633, 7634, 7, 8, 0, 0, 7634, 7635, + 7, 10, 0, 0, 7635, 7636, 7, 13, 0, 0, 7636, 7637, 7, 11, 0, 0, 7637, 7638, + 7, 12, 0, 0, 7638, 7639, 7, 14, 0, 0, 7639, 7640, 7, 6, 0, 0, 7640, 904, + 1, 0, 0, 0, 7641, 7642, 7, 8, 0, 0, 7642, 7643, 7, 10, 0, 0, 7643, 7644, + 7, 13, 0, 0, 7644, 7645, 7, 11, 0, 0, 7645, 7646, 7, 12, 0, 0, 7646, 7647, + 7, 14, 0, 0, 7647, 7648, 7, 6, 0, 0, 7648, 7649, 5, 95, 0, 0, 7649, 7650, + 7, 10, 0, 0, 7650, 7651, 7, 12, 0, 0, 7651, 7652, 7, 11, 0, 0, 7652, 7653, + 7, 11, 0, 0, 7653, 7654, 5, 95, 0, 0, 7654, 7655, 7, 15, 0, 0, 7655, 7656, + 7, 0, 0, 0, 7656, 7657, 7, 11, 0, 0, 7657, 7658, 7, 12, 0, 0, 7658, 7659, + 7, 6, 0, 0, 7659, 7660, 7, 9, 0, 0, 7660, 906, 1, 0, 0, 0, 7661, 7662, + 7, 8, 0, 0, 7662, 7663, 7, 10, 0, 0, 7663, 7664, 7, 13, 0, 0, 7664, 7665, + 7, 3, 0, 0, 7665, 7666, 7, 6, 0, 0, 7666, 7667, 7, 17, 0, 0, 7667, 7668, + 7, 6, 0, 0, 7668, 7669, 7, 10, 0, 0, 7669, 7670, 7, 4, 0, 0, 7670, 908, + 1, 0, 0, 0, 7671, 7672, 7, 8, 0, 0, 7672, 7673, 7, 10, 0, 0, 7673, 7674, + 7, 13, 0, 0, 7674, 7675, 7, 3, 0, 0, 7675, 7676, 7, 6, 0, 0, 7676, 7677, + 7, 17, 0, 0, 7677, 7678, 7, 6, 0, 0, 7678, 7679, 7, 10, 0, 0, 7679, 7680, + 7, 4, 0, 0, 7680, 7681, 7, 0, 0, 0, 7681, 7682, 7, 11, 0, 0, 7682, 910, + 1, 0, 0, 0, 7683, 7684, 7, 8, 0, 0, 7684, 7685, 7, 10, 0, 0, 7685, 7686, + 7, 14, 0, 0, 7686, 7687, 7, 6, 0, 0, 7687, 7688, 7, 22, 0, 0, 7688, 912, + 1, 0, 0, 0, 7689, 7690, 7, 8, 0, 0, 7690, 7691, 7, 10, 0, 0, 7691, 7692, + 7, 14, 0, 0, 7692, 7693, 7, 6, 0, 0, 7693, 7694, 7, 22, 0, 0, 7694, 7695, + 7, 21, 0, 0, 7695, 7696, 7, 6, 0, 0, 7696, 7697, 7, 16, 0, 0, 7697, 7698, + 5, 95, 0, 0, 7698, 7699, 7, 20, 0, 0, 7699, 7700, 7, 3, 0, 0, 7700, 7701, + 7, 2, 0, 0, 7701, 7702, 7, 20, 0, 0, 7702, 7703, 7, 6, 0, 0, 7703, 7704, + 7, 3, 0, 0, 7704, 7705, 7, 4, 0, 0, 7705, 7706, 7, 16, 0, 0, 7706, 914, + 1, 0, 0, 0, 7707, 7708, 7, 8, 0, 0, 7708, 7709, 7, 10, 0, 0, 7709, 7710, + 7, 14, 0, 0, 7710, 7711, 7, 6, 0, 0, 7711, 7712, 7, 22, 0, 0, 7712, 7713, + 7, 20, 0, 0, 7713, 7714, 7, 3, 0, 0, 7714, 7715, 7, 2, 0, 0, 7715, 7716, + 7, 20, 0, 0, 7716, 7717, 7, 6, 0, 0, 7717, 7718, 7, 3, 0, 0, 7718, 7719, + 7, 4, 0, 0, 7719, 7720, 7, 16, 0, 0, 7720, 916, 1, 0, 0, 0, 7721, 7722, + 7, 8, 0, 0, 7722, 7723, 7, 10, 0, 0, 7723, 7724, 7, 14, 0, 0, 7724, 7725, + 7, 6, 0, 0, 7725, 7726, 7, 22, 0, 0, 7726, 7727, 5, 95, 0, 0, 7727, 7728, + 7, 13, 0, 0, 7728, 7729, 7, 2, 0, 0, 7729, 7730, 7, 11, 0, 0, 7730, 918, + 1, 0, 0, 0, 7731, 7732, 7, 8, 0, 0, 7732, 7733, 7, 10, 0, 0, 7733, 7734, + 7, 5, 0, 0, 7734, 7735, 7, 8, 0, 0, 7735, 7736, 7, 10, 0, 0, 7736, 7737, + 7, 8, 0, 0, 7737, 7738, 7, 4, 0, 0, 7738, 7739, 7, 6, 0, 0, 7739, 920, + 1, 0, 0, 0, 7740, 7741, 7, 8, 0, 0, 7741, 7742, 7, 10, 0, 0, 7742, 7743, + 7, 8, 0, 0, 7743, 7744, 7, 4, 0, 0, 7744, 922, 1, 0, 0, 0, 7745, 7746, + 7, 8, 0, 0, 7746, 7747, 7, 10, 0, 0, 7747, 7748, 7, 8, 0, 0, 7748, 7749, + 7, 4, 0, 0, 7749, 7750, 7, 8, 0, 0, 7750, 7751, 7, 0, 0, 0, 7751, 7752, + 7, 4, 0, 0, 7752, 7753, 7, 2, 0, 0, 7753, 7754, 7, 3, 0, 0, 7754, 924, + 1, 0, 0, 0, 7755, 7756, 7, 8, 0, 0, 7756, 7757, 7, 10, 0, 0, 7757, 7758, + 7, 10, 0, 0, 7758, 7759, 7, 6, 0, 0, 7759, 7760, 7, 3, 0, 0, 7760, 926, + 1, 0, 0, 0, 7761, 7762, 7, 8, 0, 0, 7762, 7763, 7, 10, 0, 0, 7763, 7764, + 7, 20, 0, 0, 7764, 7765, 7, 12, 0, 0, 7765, 7766, 7, 4, 0, 0, 7766, 928, + 1, 0, 0, 0, 7767, 7768, 7, 8, 0, 0, 7768, 7769, 7, 10, 0, 0, 7769, 7770, + 7, 9, 0, 0, 7770, 7771, 7, 6, 0, 0, 7771, 7772, 7, 10, 0, 0, 7772, 7773, + 7, 9, 0, 0, 7773, 7774, 7, 8, 0, 0, 7774, 7775, 7, 4, 0, 0, 7775, 7776, + 7, 8, 0, 0, 7776, 7777, 7, 15, 0, 0, 7777, 7778, 7, 6, 0, 0, 7778, 930, + 1, 0, 0, 0, 7779, 7780, 7, 8, 0, 0, 7780, 7781, 7, 10, 0, 0, 7781, 7782, + 7, 9, 0, 0, 7782, 7783, 7, 6, 0, 0, 7783, 7784, 7, 3, 0, 0, 7784, 7785, + 7, 4, 0, 0, 7785, 932, 1, 0, 0, 0, 7786, 7787, 7, 8, 0, 0, 7787, 7788, + 7, 10, 0, 0, 7788, 7789, 7, 9, 0, 0, 7789, 7790, 7, 6, 0, 0, 7790, 7791, + 7, 3, 0, 0, 7791, 7792, 7, 4, 0, 0, 7792, 7793, 7, 6, 0, 0, 7793, 7794, + 7, 14, 0, 0, 7794, 934, 1, 0, 0, 0, 7795, 7796, 7, 8, 0, 0, 7796, 7797, + 7, 10, 0, 0, 7797, 7798, 7, 9, 0, 0, 7798, 7799, 7, 4, 0, 0, 7799, 7800, + 7, 6, 0, 0, 7800, 7801, 7, 0, 0, 0, 7801, 7802, 7, 14, 0, 0, 7802, 936, + 1, 0, 0, 0, 7803, 7804, 7, 8, 0, 0, 7804, 7805, 7, 10, 0, 0, 7805, 7806, + 7, 4, 0, 0, 7806, 938, 1, 0, 0, 0, 7807, 7808, 7, 8, 0, 0, 7808, 7809, + 7, 10, 0, 0, 7809, 7810, 7, 4, 0, 0, 7810, 7811, 7, 6, 0, 0, 7811, 7812, + 7, 3, 0, 0, 7812, 7813, 7, 9, 0, 0, 7813, 7814, 7, 6, 0, 0, 7814, 7815, + 7, 13, 0, 0, 7815, 7816, 7, 4, 0, 0, 7816, 940, 1, 0, 0, 0, 7817, 7818, + 7, 8, 0, 0, 7818, 7819, 7, 10, 0, 0, 7819, 7820, 7, 4, 0, 0, 7820, 7821, + 7, 2, 0, 0, 7821, 942, 1, 0, 0, 0, 7822, 7823, 7, 8, 0, 0, 7823, 7824, + 7, 2, 0, 0, 7824, 944, 1, 0, 0, 0, 7825, 7826, 7, 8, 0, 0, 7826, 7827, + 7, 20, 0, 0, 7827, 946, 1, 0, 0, 0, 7828, 7829, 7, 8, 0, 0, 7829, 7830, + 7, 9, 0, 0, 7830, 948, 1, 0, 0, 0, 7831, 7832, 7, 8, 0, 0, 7832, 7833, + 7, 9, 0, 0, 7833, 7834, 7, 14, 0, 0, 7834, 7835, 7, 6, 0, 0, 7835, 7836, + 7, 9, 0, 0, 7836, 7837, 7, 13, 0, 0, 7837, 7838, 7, 6, 0, 0, 7838, 7839, + 7, 10, 0, 0, 7839, 7840, 7, 14, 0, 0, 7840, 7841, 7, 0, 0, 0, 7841, 7842, + 7, 10, 0, 0, 7842, 7843, 7, 4, 0, 0, 7843, 7844, 7, 2, 0, 0, 7844, 7845, + 7, 5, 0, 0, 7845, 950, 1, 0, 0, 0, 7846, 7847, 7, 8, 0, 0, 7847, 7848, + 7, 9, 0, 0, 7848, 7849, 7, 24, 0, 0, 7849, 7850, 7, 9, 0, 0, 7850, 7851, + 7, 2, 0, 0, 7851, 7852, 7, 10, 0, 0, 7852, 952, 1, 0, 0, 0, 7853, 7854, + 7, 8, 0, 0, 7854, 7855, 7, 9, 0, 0, 7855, 7856, 7, 10, 0, 0, 7856, 7857, + 7, 12, 0, 0, 7857, 7858, 7, 11, 0, 0, 7858, 7859, 7, 11, 0, 0, 7859, 954, + 1, 0, 0, 0, 7860, 7861, 7, 8, 0, 0, 7861, 7862, 7, 9, 0, 0, 7862, 7863, + 7, 10, 0, 0, 7863, 7864, 7, 12, 0, 0, 7864, 7865, 7, 17, 0, 0, 7865, 7866, + 7, 6, 0, 0, 7866, 7867, 7, 3, 0, 0, 7867, 7868, 7, 8, 0, 0, 7868, 7869, + 7, 13, 0, 0, 7869, 956, 1, 0, 0, 0, 7870, 7871, 7, 8, 0, 0, 7871, 7872, + 7, 9, 0, 0, 7872, 7873, 7, 2, 0, 0, 7873, 7874, 7, 11, 0, 0, 7874, 7875, + 7, 0, 0, 0, 7875, 7876, 7, 4, 0, 0, 7876, 7877, 7, 8, 0, 0, 7877, 7878, + 7, 2, 0, 0, 7878, 7879, 7, 10, 0, 0, 7879, 958, 1, 0, 0, 0, 7880, 7881, + 7, 8, 0, 0, 7881, 7882, 7, 9, 0, 0, 7882, 7883, 5, 95, 0, 0, 7883, 7884, + 7, 17, 0, 0, 7884, 7885, 7, 6, 0, 0, 7885, 7886, 7, 17, 0, 0, 7886, 7887, + 7, 1, 0, 0, 7887, 7888, 7, 6, 0, 0, 7888, 7889, 7, 3, 0, 0, 7889, 960, + 1, 0, 0, 0, 7890, 7891, 7, 8, 0, 0, 7891, 7892, 7, 9, 0, 0, 7892, 7893, + 5, 95, 0, 0, 7893, 7894, 7, 3, 0, 0, 7894, 7895, 7, 2, 0, 0, 7895, 7896, + 7, 11, 0, 0, 7896, 7897, 7, 6, 0, 0, 7897, 7898, 7, 17, 0, 0, 7898, 7899, + 7, 6, 0, 0, 7899, 7900, 7, 17, 0, 0, 7900, 7901, 7, 1, 0, 0, 7901, 7902, + 7, 6, 0, 0, 7902, 7903, 7, 3, 0, 0, 7903, 962, 1, 0, 0, 0, 7904, 7905, + 7, 8, 0, 0, 7905, 7906, 7, 9, 0, 0, 7906, 7907, 5, 95, 0, 0, 7907, 7908, + 7, 9, 0, 0, 7908, 7909, 7, 3, 0, 0, 7909, 7910, 7, 15, 0, 0, 7910, 7911, + 7, 3, 0, 0, 7911, 7912, 7, 2, 0, 0, 7912, 7913, 7, 11, 0, 0, 7913, 7914, + 7, 6, 0, 0, 7914, 7915, 7, 17, 0, 0, 7915, 7916, 7, 6, 0, 0, 7916, 7917, + 7, 17, 0, 0, 7917, 7918, 7, 1, 0, 0, 7918, 7919, 7, 6, 0, 0, 7919, 7920, + 7, 3, 0, 0, 7920, 964, 1, 0, 0, 0, 7921, 7922, 7, 24, 0, 0, 7922, 7923, + 7, 2, 0, 0, 7923, 7924, 7, 1, 0, 0, 7924, 966, 1, 0, 0, 0, 7925, 7926, + 7, 24, 0, 0, 7926, 7927, 7, 2, 0, 0, 7927, 7928, 7, 8, 0, 0, 7928, 7929, + 7, 10, 0, 0, 7929, 968, 1, 0, 0, 0, 7930, 7931, 7, 24, 0, 0, 7931, 7932, + 7, 9, 0, 0, 7932, 7933, 7, 2, 0, 0, 7933, 7934, 7, 10, 0, 0, 7934, 970, + 1, 0, 0, 0, 7935, 7936, 7, 24, 0, 0, 7936, 7937, 7, 9, 0, 0, 7937, 7938, + 7, 2, 0, 0, 7938, 7939, 7, 10, 0, 0, 7939, 7940, 5, 95, 0, 0, 7940, 7941, + 7, 0, 0, 0, 7941, 7942, 7, 3, 0, 0, 7942, 7943, 7, 3, 0, 0, 7943, 7944, + 7, 0, 0, 0, 7944, 7945, 7, 16, 0, 0, 7945, 972, 1, 0, 0, 0, 7946, 7947, + 7, 24, 0, 0, 7947, 7948, 7, 9, 0, 0, 7948, 7949, 7, 2, 0, 0, 7949, 7950, + 7, 10, 0, 0, 7950, 7951, 5, 95, 0, 0, 7951, 7952, 7, 17, 0, 0, 7952, 7953, + 7, 2, 0, 0, 7953, 7954, 7, 14, 0, 0, 7954, 7955, 7, 8, 0, 0, 7955, 7956, + 7, 5, 0, 0, 7956, 7957, 7, 16, 0, 0, 7957, 974, 1, 0, 0, 0, 7958, 7959, + 7, 24, 0, 0, 7959, 7960, 7, 9, 0, 0, 7960, 7961, 7, 2, 0, 0, 7961, 7962, + 7, 10, 0, 0, 7962, 7963, 5, 95, 0, 0, 7963, 7964, 7, 2, 0, 0, 7964, 7965, + 7, 1, 0, 0, 7965, 7966, 7, 24, 0, 0, 7966, 7967, 7, 6, 0, 0, 7967, 7968, + 7, 13, 0, 0, 7968, 7969, 7, 4, 0, 0, 7969, 976, 1, 0, 0, 0, 7970, 7971, + 7, 24, 0, 0, 7971, 7972, 7, 9, 0, 0, 7972, 7973, 7, 2, 0, 0, 7973, 7974, + 7, 10, 0, 0, 7974, 7975, 5, 95, 0, 0, 7975, 7976, 7, 20, 0, 0, 7976, 7977, + 7, 0, 0, 0, 7977, 7978, 7, 4, 0, 0, 7978, 7979, 7, 19, 0, 0, 7979, 7980, + 5, 95, 0, 0, 7980, 7981, 7, 6, 0, 0, 7981, 7982, 7, 22, 0, 0, 7982, 7983, + 7, 8, 0, 0, 7983, 7984, 7, 9, 0, 0, 7984, 7985, 7, 4, 0, 0, 7985, 7986, + 7, 9, 0, 0, 7986, 978, 1, 0, 0, 0, 7987, 7988, 7, 24, 0, 0, 7988, 7989, + 7, 9, 0, 0, 7989, 7990, 7, 2, 0, 0, 7990, 7991, 7, 10, 0, 0, 7991, 7992, + 5, 95, 0, 0, 7992, 7993, 7, 25, 0, 0, 7993, 7994, 7, 12, 0, 0, 7994, 7995, + 7, 6, 0, 0, 7995, 7996, 7, 3, 0, 0, 7996, 7997, 7, 16, 0, 0, 7997, 980, + 1, 0, 0, 0, 7998, 7999, 7, 24, 0, 0, 7999, 8000, 7, 9, 0, 0, 8000, 8001, + 7, 2, 0, 0, 8001, 8002, 7, 10, 0, 0, 8002, 8003, 5, 95, 0, 0, 8003, 8004, + 7, 15, 0, 0, 8004, 8005, 7, 0, 0, 0, 8005, 8006, 7, 11, 0, 0, 8006, 8007, + 7, 12, 0, 0, 8007, 8008, 7, 6, 0, 0, 8008, 982, 1, 0, 0, 0, 8009, 8010, + 7, 21, 0, 0, 8010, 8011, 7, 1, 0, 0, 8011, 984, 1, 0, 0, 0, 8012, 8013, + 7, 21, 0, 0, 8013, 8014, 7, 6, 0, 0, 8014, 8015, 7, 6, 0, 0, 8015, 8016, + 7, 20, 0, 0, 8016, 986, 1, 0, 0, 0, 8017, 8018, 7, 21, 0, 0, 8018, 8019, + 7, 6, 0, 0, 8019, 8020, 7, 6, 0, 0, 8020, 8021, 7, 20, 0, 0, 8021, 8022, + 7, 14, 0, 0, 8022, 8023, 7, 6, 0, 0, 8023, 8024, 7, 5, 0, 0, 8024, 8025, + 7, 0, 0, 0, 8025, 8026, 7, 12, 0, 0, 8026, 8027, 7, 11, 0, 0, 8027, 8028, + 7, 4, 0, 0, 8028, 8029, 7, 9, 0, 0, 8029, 988, 1, 0, 0, 0, 8030, 8031, + 7, 21, 0, 0, 8031, 8032, 7, 6, 0, 0, 8032, 8033, 7, 6, 0, 0, 8033, 8034, + 7, 20, 0, 0, 8034, 8035, 7, 5, 0, 0, 8035, 8036, 7, 8, 0, 0, 8036, 8037, + 7, 22, 0, 0, 8037, 8038, 7, 6, 0, 0, 8038, 8039, 7, 14, 0, 0, 8039, 990, + 1, 0, 0, 0, 8040, 8041, 7, 21, 0, 0, 8041, 8042, 7, 6, 0, 0, 8042, 8043, + 7, 6, 0, 0, 8043, 8044, 7, 20, 0, 0, 8044, 8045, 7, 8, 0, 0, 8045, 8046, + 7, 14, 0, 0, 8046, 8047, 7, 6, 0, 0, 8047, 8048, 7, 10, 0, 0, 8048, 8049, + 7, 4, 0, 0, 8049, 8050, 7, 8, 0, 0, 8050, 8051, 7, 4, 0, 0, 8051, 8052, + 7, 16, 0, 0, 8052, 992, 1, 0, 0, 0, 8053, 8054, 7, 21, 0, 0, 8054, 8055, + 7, 6, 0, 0, 8055, 8056, 7, 3, 0, 0, 8056, 8057, 7, 1, 0, 0, 8057, 8058, + 7, 6, 0, 0, 8058, 8059, 7, 3, 0, 0, 8059, 8060, 7, 2, 0, 0, 8060, 8061, + 7, 9, 0, 0, 8061, 994, 1, 0, 0, 0, 8062, 8063, 7, 21, 0, 0, 8063, 8064, + 7, 6, 0, 0, 8064, 8065, 7, 16, 0, 0, 8065, 996, 1, 0, 0, 0, 8066, 8067, + 7, 21, 0, 0, 8067, 8068, 7, 6, 0, 0, 8068, 8069, 7, 16, 0, 0, 8069, 8070, + 7, 9, 0, 0, 8070, 998, 1, 0, 0, 0, 8071, 8072, 7, 21, 0, 0, 8072, 8073, + 7, 6, 0, 0, 8073, 8074, 7, 16, 0, 0, 8074, 8075, 7, 9, 0, 0, 8075, 8076, + 7, 6, 0, 0, 8076, 8077, 7, 4, 0, 0, 8077, 1000, 1, 0, 0, 0, 8078, 8079, + 7, 21, 0, 0, 8079, 8080, 7, 6, 0, 0, 8080, 8081, 7, 16, 0, 0, 8081, 8082, + 5, 95, 0, 0, 8082, 8083, 7, 20, 0, 0, 8083, 8084, 7, 0, 0, 0, 8084, 8085, + 7, 4, 0, 0, 8085, 8086, 7, 19, 0, 0, 8086, 1002, 1, 0, 0, 0, 8087, 8088, + 7, 21, 0, 0, 8088, 8089, 7, 6, 0, 0, 8089, 8090, 7, 16, 0, 0, 8090, 8091, + 5, 95, 0, 0, 8091, 8092, 7, 9, 0, 0, 8092, 8093, 7, 2, 0, 0, 8093, 8094, + 7, 12, 0, 0, 8094, 8095, 7, 3, 0, 0, 8095, 8096, 7, 13, 0, 0, 8096, 8097, + 7, 6, 0, 0, 8097, 1004, 1, 0, 0, 0, 8098, 8099, 7, 21, 0, 0, 8099, 8100, + 7, 6, 0, 0, 8100, 8101, 7, 16, 0, 0, 8101, 8102, 5, 95, 0, 0, 8102, 8103, + 7, 9, 0, 0, 8103, 8104, 7, 4, 0, 0, 8104, 8105, 7, 2, 0, 0, 8105, 8106, + 7, 3, 0, 0, 8106, 8107, 7, 6, 0, 0, 8107, 8108, 5, 95, 0, 0, 8108, 8109, + 7, 20, 0, 0, 8109, 8110, 7, 3, 0, 0, 8110, 8111, 7, 2, 0, 0, 8111, 8112, + 7, 15, 0, 0, 8112, 8113, 7, 8, 0, 0, 8113, 8114, 7, 14, 0, 0, 8114, 8115, + 7, 6, 0, 0, 8115, 8116, 7, 3, 0, 0, 8116, 8117, 5, 95, 0, 0, 8117, 8118, + 7, 10, 0, 0, 8118, 8119, 7, 0, 0, 0, 8119, 8120, 7, 17, 0, 0, 8120, 8121, + 7, 6, 0, 0, 8121, 1006, 1, 0, 0, 0, 8122, 8123, 7, 21, 0, 0, 8123, 8124, + 7, 8, 0, 0, 8124, 8125, 7, 11, 0, 0, 8125, 8126, 7, 11, 0, 0, 8126, 1008, + 1, 0, 0, 0, 8127, 8128, 7, 11, 0, 0, 8128, 8129, 7, 0, 0, 0, 8129, 8130, + 7, 18, 0, 0, 8130, 1010, 1, 0, 0, 0, 8131, 8132, 7, 11, 0, 0, 8132, 8133, + 7, 0, 0, 0, 8133, 8134, 7, 10, 0, 0, 8134, 8135, 7, 18, 0, 0, 8135, 8136, + 7, 12, 0, 0, 8136, 8137, 7, 0, 0, 0, 8137, 8138, 7, 18, 0, 0, 8138, 8139, + 7, 6, 0, 0, 8139, 1012, 1, 0, 0, 0, 8140, 8141, 7, 11, 0, 0, 8141, 8142, + 7, 0, 0, 0, 8142, 8143, 7, 9, 0, 0, 8143, 8144, 7, 4, 0, 0, 8144, 1014, + 1, 0, 0, 0, 8145, 8146, 7, 11, 0, 0, 8146, 8147, 7, 0, 0, 0, 8147, 8148, + 7, 9, 0, 0, 8148, 8149, 7, 4, 0, 0, 8149, 8150, 5, 95, 0, 0, 8150, 8151, + 7, 15, 0, 0, 8151, 8152, 7, 0, 0, 0, 8152, 8153, 7, 11, 0, 0, 8153, 8154, + 7, 12, 0, 0, 8154, 8155, 7, 6, 0, 0, 8155, 1016, 1, 0, 0, 0, 8156, 8157, + 7, 11, 0, 0, 8157, 8158, 7, 6, 0, 0, 8158, 8159, 7, 0, 0, 0, 8159, 8160, + 7, 14, 0, 0, 8160, 1018, 1, 0, 0, 0, 8161, 8162, 7, 11, 0, 0, 8162, 8163, + 7, 6, 0, 0, 8163, 8164, 7, 0, 0, 0, 8164, 8165, 7, 9, 0, 0, 8165, 8166, + 7, 4, 0, 0, 8166, 1020, 1, 0, 0, 0, 8167, 8168, 7, 11, 0, 0, 8168, 8169, + 7, 6, 0, 0, 8169, 8170, 7, 5, 0, 0, 8170, 8171, 7, 4, 0, 0, 8171, 1022, + 1, 0, 0, 0, 8172, 8173, 7, 11, 0, 0, 8173, 8174, 7, 6, 0, 0, 8174, 8175, + 7, 10, 0, 0, 8175, 1024, 1, 0, 0, 0, 8176, 8177, 7, 11, 0, 0, 8177, 8178, + 7, 6, 0, 0, 8178, 8179, 7, 15, 0, 0, 8179, 8180, 7, 6, 0, 0, 8180, 8181, + 7, 11, 0, 0, 8181, 1026, 1, 0, 0, 0, 8182, 8183, 7, 11, 0, 0, 8183, 8184, + 7, 6, 0, 0, 8184, 8185, 7, 15, 0, 0, 8185, 8186, 7, 6, 0, 0, 8186, 8187, + 7, 11, 0, 0, 8187, 8188, 5, 95, 0, 0, 8188, 8189, 5, 49, 0, 0, 8189, 1028, + 1, 0, 0, 0, 8190, 8191, 7, 11, 0, 0, 8191, 8192, 7, 6, 0, 0, 8192, 8193, + 7, 15, 0, 0, 8193, 8194, 7, 6, 0, 0, 8194, 8195, 7, 11, 0, 0, 8195, 8196, + 5, 95, 0, 0, 8196, 8197, 5, 50, 0, 0, 8197, 1030, 1, 0, 0, 0, 8198, 8199, + 7, 11, 0, 0, 8199, 8200, 7, 6, 0, 0, 8200, 8201, 7, 15, 0, 0, 8201, 8202, + 7, 6, 0, 0, 8202, 8203, 7, 11, 0, 0, 8203, 8204, 5, 95, 0, 0, 8204, 8205, + 5, 51, 0, 0, 8205, 1032, 1, 0, 0, 0, 8206, 8207, 7, 11, 0, 0, 8207, 8208, + 7, 6, 0, 0, 8208, 8209, 7, 15, 0, 0, 8209, 8210, 7, 6, 0, 0, 8210, 8211, + 7, 11, 0, 0, 8211, 8212, 5, 95, 0, 0, 8212, 8213, 5, 52, 0, 0, 8213, 1034, + 1, 0, 0, 0, 8214, 8215, 7, 11, 0, 0, 8215, 8216, 7, 8, 0, 0, 8216, 8217, + 7, 1, 0, 0, 8217, 8218, 7, 3, 0, 0, 8218, 8219, 7, 0, 0, 0, 8219, 8220, + 7, 3, 0, 0, 8220, 8221, 7, 16, 0, 0, 8221, 1036, 1, 0, 0, 0, 8222, 8223, + 7, 11, 0, 0, 8223, 8224, 7, 8, 0, 0, 8224, 8225, 7, 5, 0, 0, 8225, 8226, + 7, 6, 0, 0, 8226, 8227, 7, 4, 0, 0, 8227, 8228, 7, 8, 0, 0, 8228, 8229, + 7, 17, 0, 0, 8229, 8230, 7, 6, 0, 0, 8230, 1038, 1, 0, 0, 0, 8231, 8232, + 7, 11, 0, 0, 8232, 8233, 7, 8, 0, 0, 8233, 8234, 7, 21, 0, 0, 8234, 8235, + 7, 6, 0, 0, 8235, 1040, 1, 0, 0, 0, 8236, 8237, 7, 11, 0, 0, 8237, 8238, + 7, 8, 0, 0, 8238, 8239, 7, 10, 0, 0, 8239, 8240, 7, 6, 0, 0, 8240, 8241, + 7, 10, 0, 0, 8241, 8242, 7, 2, 0, 0, 8242, 1042, 1, 0, 0, 0, 8243, 8244, + 7, 11, 0, 0, 8244, 8245, 7, 8, 0, 0, 8245, 8246, 7, 10, 0, 0, 8246, 8247, + 7, 21, 0, 0, 8247, 8248, 7, 6, 0, 0, 8248, 8249, 7, 14, 0, 0, 8249, 1044, + 1, 0, 0, 0, 8250, 8251, 7, 11, 0, 0, 8251, 8252, 7, 8, 0, 0, 8252, 8253, + 7, 10, 0, 0, 8253, 8254, 7, 12, 0, 0, 8254, 8255, 7, 22, 0, 0, 8255, 1046, + 1, 0, 0, 0, 8256, 8257, 7, 11, 0, 0, 8257, 8258, 7, 8, 0, 0, 8258, 8259, + 7, 9, 0, 0, 8259, 8260, 7, 4, 0, 0, 8260, 1048, 1, 0, 0, 0, 8261, 8262, + 7, 11, 0, 0, 8262, 8263, 7, 8, 0, 0, 8263, 8264, 7, 9, 0, 0, 8264, 8265, + 7, 4, 0, 0, 8265, 8266, 7, 6, 0, 0, 8266, 8267, 7, 10, 0, 0, 8267, 8268, + 7, 6, 0, 0, 8268, 8269, 7, 3, 0, 0, 8269, 1050, 1, 0, 0, 0, 8270, 8271, + 7, 11, 0, 0, 8271, 8272, 7, 8, 0, 0, 8272, 8273, 7, 9, 0, 0, 8273, 8274, + 7, 4, 0, 0, 8274, 8275, 7, 6, 0, 0, 8275, 8276, 7, 10, 0, 0, 8276, 8277, + 7, 6, 0, 0, 8277, 8278, 7, 3, 0, 0, 8278, 8279, 5, 95, 0, 0, 8279, 8280, + 7, 8, 0, 0, 8280, 8281, 7, 20, 0, 0, 8281, 1052, 1, 0, 0, 0, 8282, 8283, + 7, 11, 0, 0, 8283, 8284, 7, 8, 0, 0, 8284, 8285, 7, 9, 0, 0, 8285, 8286, + 7, 4, 0, 0, 8286, 8287, 7, 6, 0, 0, 8287, 8288, 7, 10, 0, 0, 8288, 8289, + 7, 6, 0, 0, 8289, 8290, 7, 3, 0, 0, 8290, 8291, 5, 95, 0, 0, 8291, 8292, + 7, 20, 0, 0, 8292, 8293, 7, 2, 0, 0, 8293, 8294, 7, 3, 0, 0, 8294, 8295, + 7, 4, 0, 0, 8295, 1054, 1, 0, 0, 0, 8296, 8297, 7, 11, 0, 0, 8297, 8298, + 7, 8, 0, 0, 8298, 8299, 7, 9, 0, 0, 8299, 8300, 7, 4, 0, 0, 8300, 8301, + 7, 6, 0, 0, 8301, 8302, 7, 10, 0, 0, 8302, 8303, 7, 6, 0, 0, 8303, 8304, + 7, 3, 0, 0, 8304, 8305, 5, 95, 0, 0, 8305, 8306, 7, 12, 0, 0, 8306, 8307, + 7, 3, 0, 0, 8307, 8308, 7, 11, 0, 0, 8308, 1056, 1, 0, 0, 0, 8309, 8310, + 7, 11, 0, 0, 8310, 8311, 7, 2, 0, 0, 8311, 8312, 7, 0, 0, 0, 8312, 8313, + 7, 14, 0, 0, 8313, 1058, 1, 0, 0, 0, 8314, 8315, 7, 11, 0, 0, 8315, 8316, + 7, 2, 0, 0, 8316, 8317, 7, 1, 0, 0, 8317, 8318, 5, 95, 0, 0, 8318, 8319, + 7, 13, 0, 0, 8319, 8320, 7, 2, 0, 0, 8320, 8321, 7, 17, 0, 0, 8321, 8322, + 7, 20, 0, 0, 8322, 8323, 7, 0, 0, 0, 8323, 8324, 7, 13, 0, 0, 8324, 8325, + 7, 4, 0, 0, 8325, 8326, 7, 8, 0, 0, 8326, 8327, 7, 2, 0, 0, 8327, 8328, + 7, 10, 0, 0, 8328, 1060, 1, 0, 0, 0, 8329, 8330, 7, 11, 0, 0, 8330, 8331, + 7, 2, 0, 0, 8331, 8332, 7, 13, 0, 0, 8332, 8333, 7, 0, 0, 0, 8333, 8334, + 7, 11, 0, 0, 8334, 1062, 1, 0, 0, 0, 8335, 8336, 7, 11, 0, 0, 8336, 8337, + 7, 2, 0, 0, 8337, 8338, 7, 13, 0, 0, 8338, 8339, 7, 0, 0, 0, 8339, 8340, + 7, 11, 0, 0, 8340, 8341, 5, 95, 0, 0, 8341, 8342, 7, 9, 0, 0, 8342, 8343, + 7, 6, 0, 0, 8343, 8344, 7, 3, 0, 0, 8344, 8345, 7, 15, 0, 0, 8345, 8346, + 7, 8, 0, 0, 8346, 8347, 7, 13, 0, 0, 8347, 8348, 7, 6, 0, 0, 8348, 8349, + 5, 95, 0, 0, 8349, 8350, 7, 10, 0, 0, 8350, 8351, 7, 0, 0, 0, 8351, 8352, + 7, 17, 0, 0, 8352, 8353, 7, 6, 0, 0, 8353, 1064, 1, 0, 0, 0, 8354, 8355, + 7, 11, 0, 0, 8355, 8356, 7, 2, 0, 0, 8356, 8357, 7, 13, 0, 0, 8357, 8358, + 7, 0, 0, 0, 8358, 8359, 7, 4, 0, 0, 8359, 8360, 7, 8, 0, 0, 8360, 8361, + 7, 2, 0, 0, 8361, 8362, 7, 10, 0, 0, 8362, 1066, 1, 0, 0, 0, 8363, 8364, + 7, 11, 0, 0, 8364, 8365, 7, 2, 0, 0, 8365, 8366, 7, 13, 0, 0, 8366, 8367, + 7, 21, 0, 0, 8367, 1068, 1, 0, 0, 0, 8368, 8369, 7, 11, 0, 0, 8369, 8370, + 7, 2, 0, 0, 8370, 8371, 7, 13, 0, 0, 8371, 8372, 7, 21, 0, 0, 8372, 8373, + 5, 95, 0, 0, 8373, 8374, 7, 6, 0, 0, 8374, 8375, 7, 9, 0, 0, 8375, 8376, + 7, 13, 0, 0, 8376, 8377, 7, 0, 0, 0, 8377, 8378, 7, 11, 0, 0, 8378, 8379, + 7, 0, 0, 0, 8379, 8380, 7, 4, 0, 0, 8380, 8381, 7, 8, 0, 0, 8381, 8382, + 7, 2, 0, 0, 8382, 8383, 7, 10, 0, 0, 8383, 1070, 1, 0, 0, 0, 8384, 8385, + 7, 11, 0, 0, 8385, 8386, 7, 2, 0, 0, 8386, 8387, 7, 18, 0, 0, 8387, 1072, + 1, 0, 0, 0, 8388, 8389, 7, 11, 0, 0, 8389, 8390, 7, 2, 0, 0, 8390, 8391, + 7, 18, 0, 0, 8391, 8392, 7, 8, 0, 0, 8392, 8393, 7, 10, 0, 0, 8393, 1074, + 1, 0, 0, 0, 8394, 8395, 7, 11, 0, 0, 8395, 8396, 7, 2, 0, 0, 8396, 8397, + 7, 18, 0, 0, 8397, 8398, 7, 8, 0, 0, 8398, 8399, 7, 10, 0, 0, 8399, 8400, + 7, 20, 0, 0, 8400, 8401, 7, 3, 0, 0, 8401, 8402, 7, 2, 0, 0, 8402, 8403, + 7, 20, 0, 0, 8403, 8404, 7, 6, 0, 0, 8404, 8405, 7, 3, 0, 0, 8405, 8406, + 7, 4, 0, 0, 8406, 8407, 7, 16, 0, 0, 8407, 1076, 1, 0, 0, 0, 8408, 8409, + 7, 11, 0, 0, 8409, 8410, 7, 2, 0, 0, 8410, 8411, 7, 2, 0, 0, 8411, 8412, + 7, 20, 0, 0, 8412, 1078, 1, 0, 0, 0, 8413, 8414, 7, 11, 0, 0, 8414, 8415, + 7, 2, 0, 0, 8415, 8416, 7, 7, 0, 0, 8416, 1080, 1, 0, 0, 0, 8417, 8418, + 7, 11, 0, 0, 8418, 8419, 7, 2, 0, 0, 8419, 8420, 7, 7, 0, 0, 8420, 8421, + 7, 6, 0, 0, 8421, 8422, 7, 3, 0, 0, 8422, 1082, 1, 0, 0, 0, 8423, 8424, + 7, 11, 0, 0, 8424, 8425, 7, 4, 0, 0, 8425, 8426, 7, 3, 0, 0, 8426, 8427, + 7, 8, 0, 0, 8427, 8428, 7, 17, 0, 0, 8428, 1084, 1, 0, 0, 0, 8429, 8430, + 7, 17, 0, 0, 8430, 8431, 7, 0, 0, 0, 8431, 8432, 7, 10, 0, 0, 8432, 8433, + 7, 12, 0, 0, 8433, 8434, 7, 0, 0, 0, 8434, 8435, 7, 11, 0, 0, 8435, 1086, + 1, 0, 0, 0, 8436, 8437, 7, 17, 0, 0, 8437, 8438, 7, 0, 0, 0, 8438, 8439, + 7, 3, 0, 0, 8439, 8440, 7, 21, 0, 0, 8440, 1088, 1, 0, 0, 0, 8441, 8442, + 7, 17, 0, 0, 8442, 8443, 7, 0, 0, 0, 8443, 8444, 7, 9, 0, 0, 8444, 8445, + 7, 21, 0, 0, 8445, 1090, 1, 0, 0, 0, 8446, 8447, 7, 17, 0, 0, 8447, 8448, + 7, 0, 0, 0, 8448, 8449, 7, 9, 0, 0, 8449, 8450, 7, 21, 0, 0, 8450, 8451, + 7, 6, 0, 0, 8451, 8452, 7, 14, 0, 0, 8452, 1092, 1, 0, 0, 0, 8453, 8454, + 7, 17, 0, 0, 8454, 8455, 7, 0, 0, 0, 8455, 8456, 7, 9, 0, 0, 8456, 8457, + 7, 4, 0, 0, 8457, 8458, 7, 6, 0, 0, 8458, 8459, 7, 3, 0, 0, 8459, 1094, + 1, 0, 0, 0, 8460, 8461, 7, 17, 0, 0, 8461, 8462, 7, 0, 0, 0, 8462, 8463, + 7, 4, 0, 0, 8463, 8464, 7, 13, 0, 0, 8464, 8465, 7, 19, 0, 0, 8465, 8466, + 7, 6, 0, 0, 8466, 8467, 7, 14, 0, 0, 8467, 1096, 1, 0, 0, 0, 8468, 8469, + 7, 17, 0, 0, 8469, 8470, 7, 0, 0, 0, 8470, 8471, 7, 4, 0, 0, 8471, 8472, + 7, 6, 0, 0, 8472, 8473, 7, 3, 0, 0, 8473, 8474, 7, 8, 0, 0, 8474, 8475, + 7, 0, 0, 0, 8475, 8476, 7, 11, 0, 0, 8476, 8477, 7, 8, 0, 0, 8477, 8478, + 7, 23, 0, 0, 8478, 8479, 7, 6, 0, 0, 8479, 8480, 7, 14, 0, 0, 8480, 1098, + 1, 0, 0, 0, 8481, 8482, 7, 17, 0, 0, 8482, 8483, 7, 0, 0, 0, 8483, 8484, + 7, 22, 0, 0, 8484, 1100, 1, 0, 0, 0, 8485, 8486, 7, 17, 0, 0, 8486, 8487, + 7, 0, 0, 0, 8487, 8488, 7, 22, 0, 0, 8488, 8489, 7, 14, 0, 0, 8489, 8490, + 7, 2, 0, 0, 8490, 8491, 7, 20, 0, 0, 8491, 1102, 1, 0, 0, 0, 8492, 8493, + 7, 17, 0, 0, 8493, 8494, 7, 0, 0, 0, 8494, 8495, 7, 22, 0, 0, 8495, 8496, + 7, 3, 0, 0, 8496, 8497, 7, 6, 0, 0, 8497, 8498, 7, 13, 0, 0, 8498, 8499, + 7, 12, 0, 0, 8499, 8500, 7, 3, 0, 0, 8500, 8501, 7, 9, 0, 0, 8501, 8502, + 7, 8, 0, 0, 8502, 8503, 7, 2, 0, 0, 8503, 8504, 7, 10, 0, 0, 8504, 1104, + 1, 0, 0, 0, 8505, 8506, 7, 17, 0, 0, 8506, 8507, 7, 0, 0, 0, 8507, 8508, + 7, 22, 0, 0, 8508, 8509, 7, 9, 0, 0, 8509, 8510, 7, 8, 0, 0, 8510, 8511, + 7, 23, 0, 0, 8511, 8512, 7, 6, 0, 0, 8512, 1106, 1, 0, 0, 0, 8513, 8514, + 7, 17, 0, 0, 8514, 8515, 7, 0, 0, 0, 8515, 8516, 7, 22, 0, 0, 8516, 8517, + 7, 4, 0, 0, 8517, 8518, 7, 3, 0, 0, 8518, 8519, 7, 0, 0, 0, 8519, 8520, + 7, 10, 0, 0, 8520, 8521, 7, 9, 0, 0, 8521, 8522, 7, 5, 0, 0, 8522, 8523, + 7, 6, 0, 0, 8523, 8524, 7, 3, 0, 0, 8524, 1108, 1, 0, 0, 0, 8525, 8526, + 7, 17, 0, 0, 8526, 8527, 7, 0, 0, 0, 8527, 8528, 7, 22, 0, 0, 8528, 8529, + 7, 15, 0, 0, 8529, 8530, 7, 0, 0, 0, 8530, 8531, 7, 11, 0, 0, 8531, 8532, + 7, 12, 0, 0, 8532, 8533, 7, 6, 0, 0, 8533, 1110, 1, 0, 0, 0, 8534, 8535, + 7, 17, 0, 0, 8535, 8536, 7, 0, 0, 0, 8536, 8537, 7, 22, 0, 0, 8537, 8538, + 5, 95, 0, 0, 8538, 8539, 7, 13, 0, 0, 8539, 8540, 7, 20, 0, 0, 8540, 8541, + 7, 12, 0, 0, 8541, 8542, 5, 95, 0, 0, 8542, 8543, 7, 20, 0, 0, 8543, 8544, + 7, 6, 0, 0, 8544, 8545, 7, 3, 0, 0, 8545, 8546, 7, 13, 0, 0, 8546, 8547, + 7, 6, 0, 0, 8547, 8548, 7, 10, 0, 0, 8548, 8549, 7, 4, 0, 0, 8549, 1112, + 1, 0, 0, 0, 8550, 8551, 7, 17, 0, 0, 8551, 8552, 7, 0, 0, 0, 8552, 8553, + 7, 22, 0, 0, 8553, 8554, 5, 95, 0, 0, 8554, 8555, 7, 14, 0, 0, 8555, 8556, + 7, 8, 0, 0, 8556, 8557, 7, 9, 0, 0, 8557, 8558, 7, 20, 0, 0, 8558, 8559, + 7, 0, 0, 0, 8559, 8560, 7, 4, 0, 0, 8560, 8561, 7, 13, 0, 0, 8561, 8562, + 7, 19, 0, 0, 8562, 8563, 5, 95, 0, 0, 8563, 8564, 7, 11, 0, 0, 8564, 8565, + 7, 0, 0, 0, 8565, 8566, 7, 4, 0, 0, 8566, 8567, 7, 6, 0, 0, 8567, 8568, + 7, 10, 0, 0, 8568, 8569, 7, 13, 0, 0, 8569, 8570, 7, 16, 0, 0, 8570, 1114, + 1, 0, 0, 0, 8571, 8572, 7, 17, 0, 0, 8572, 8573, 7, 0, 0, 0, 8573, 8574, + 7, 22, 0, 0, 8574, 8575, 5, 95, 0, 0, 8575, 8576, 7, 14, 0, 0, 8576, 8577, + 7, 2, 0, 0, 8577, 8578, 7, 20, 0, 0, 8578, 1116, 1, 0, 0, 0, 8579, 8580, + 7, 17, 0, 0, 8580, 8581, 7, 0, 0, 0, 8581, 8582, 7, 22, 0, 0, 8582, 8583, + 5, 95, 0, 0, 8583, 8584, 7, 14, 0, 0, 8584, 8585, 7, 12, 0, 0, 8585, 8586, + 7, 3, 0, 0, 8586, 8587, 7, 0, 0, 0, 8587, 8588, 7, 4, 0, 0, 8588, 8589, + 7, 8, 0, 0, 8589, 8590, 7, 2, 0, 0, 8590, 8591, 7, 10, 0, 0, 8591, 1118, + 1, 0, 0, 0, 8592, 8593, 7, 17, 0, 0, 8593, 8594, 7, 0, 0, 0, 8594, 8595, + 7, 22, 0, 0, 8595, 8596, 5, 95, 0, 0, 8596, 8597, 7, 6, 0, 0, 8597, 8598, + 7, 15, 0, 0, 8598, 8599, 7, 6, 0, 0, 8599, 8600, 7, 10, 0, 0, 8600, 8601, + 7, 4, 0, 0, 8601, 8602, 5, 95, 0, 0, 8602, 8603, 7, 9, 0, 0, 8603, 8604, + 7, 8, 0, 0, 8604, 8605, 7, 23, 0, 0, 8605, 8606, 7, 6, 0, 0, 8606, 1120, + 1, 0, 0, 0, 8607, 8608, 7, 17, 0, 0, 8608, 8609, 7, 0, 0, 0, 8609, 8610, + 7, 22, 0, 0, 8610, 8611, 5, 95, 0, 0, 8611, 8612, 7, 5, 0, 0, 8612, 8613, + 7, 8, 0, 0, 8613, 8614, 7, 11, 0, 0, 8614, 8615, 7, 6, 0, 0, 8615, 8616, + 7, 9, 0, 0, 8616, 1122, 1, 0, 0, 0, 8617, 8618, 7, 17, 0, 0, 8618, 8619, + 7, 0, 0, 0, 8619, 8620, 7, 22, 0, 0, 8620, 8621, 5, 95, 0, 0, 8621, 8622, + 7, 8, 0, 0, 8622, 8623, 7, 2, 0, 0, 8623, 8624, 7, 20, 0, 0, 8624, 8625, + 7, 9, 0, 0, 8625, 8626, 5, 95, 0, 0, 8626, 8627, 7, 20, 0, 0, 8627, 8628, + 7, 6, 0, 0, 8628, 8629, 7, 3, 0, 0, 8629, 8630, 5, 95, 0, 0, 8630, 8631, + 7, 15, 0, 0, 8631, 8632, 7, 2, 0, 0, 8632, 8633, 7, 11, 0, 0, 8633, 8634, + 7, 12, 0, 0, 8634, 8635, 7, 17, 0, 0, 8635, 8636, 7, 6, 0, 0, 8636, 1124, + 1, 0, 0, 0, 8637, 8638, 7, 17, 0, 0, 8638, 8639, 7, 0, 0, 0, 8639, 8640, + 7, 22, 0, 0, 8640, 8641, 5, 95, 0, 0, 8641, 8642, 7, 17, 0, 0, 8642, 8643, + 7, 6, 0, 0, 8643, 8644, 7, 17, 0, 0, 8644, 8645, 7, 2, 0, 0, 8645, 8646, + 7, 3, 0, 0, 8646, 8647, 7, 16, 0, 0, 8647, 1126, 1, 0, 0, 0, 8648, 8649, + 7, 17, 0, 0, 8649, 8650, 7, 0, 0, 0, 8650, 8651, 7, 22, 0, 0, 8651, 8652, + 5, 95, 0, 0, 8652, 8653, 7, 17, 0, 0, 8653, 8654, 7, 6, 0, 0, 8654, 8655, + 7, 17, 0, 0, 8655, 8656, 7, 2, 0, 0, 8656, 8657, 7, 3, 0, 0, 8657, 8658, + 7, 16, 0, 0, 8658, 8659, 5, 95, 0, 0, 8659, 8660, 7, 20, 0, 0, 8660, 8661, + 7, 6, 0, 0, 8661, 8662, 7, 3, 0, 0, 8662, 8663, 7, 13, 0, 0, 8663, 8664, + 7, 6, 0, 0, 8664, 8665, 7, 10, 0, 0, 8665, 8666, 7, 4, 0, 0, 8666, 1128, + 1, 0, 0, 0, 8667, 8668, 7, 17, 0, 0, 8668, 8669, 7, 0, 0, 0, 8669, 8670, + 7, 22, 0, 0, 8670, 8671, 5, 95, 0, 0, 8671, 8672, 7, 2, 0, 0, 8672, 8673, + 7, 12, 0, 0, 8673, 8674, 7, 4, 0, 0, 8674, 8675, 7, 9, 0, 0, 8675, 8676, + 7, 4, 0, 0, 8676, 8677, 7, 0, 0, 0, 8677, 8678, 7, 10, 0, 0, 8678, 8679, + 7, 14, 0, 0, 8679, 8680, 7, 8, 0, 0, 8680, 8681, 7, 10, 0, 0, 8681, 8682, + 7, 18, 0, 0, 8682, 8683, 5, 95, 0, 0, 8683, 8684, 7, 8, 0, 0, 8684, 8685, + 7, 2, 0, 0, 8685, 8686, 5, 95, 0, 0, 8686, 8687, 7, 20, 0, 0, 8687, 8688, + 7, 6, 0, 0, 8688, 8689, 7, 3, 0, 0, 8689, 8690, 5, 95, 0, 0, 8690, 8691, + 7, 15, 0, 0, 8691, 8692, 7, 2, 0, 0, 8692, 8693, 7, 11, 0, 0, 8693, 8694, + 7, 12, 0, 0, 8694, 8695, 7, 17, 0, 0, 8695, 8696, 7, 6, 0, 0, 8696, 1130, + 1, 0, 0, 0, 8697, 8698, 7, 17, 0, 0, 8698, 8699, 7, 0, 0, 0, 8699, 8700, + 7, 22, 0, 0, 8700, 8701, 5, 95, 0, 0, 8701, 8702, 7, 20, 0, 0, 8702, 8703, + 7, 3, 0, 0, 8703, 8704, 7, 2, 0, 0, 8704, 8705, 7, 13, 0, 0, 8705, 8706, + 7, 6, 0, 0, 8706, 8707, 7, 9, 0, 0, 8707, 8708, 7, 9, 0, 0, 8708, 8709, + 7, 6, 0, 0, 8709, 8710, 7, 9, 0, 0, 8710, 1132, 1, 0, 0, 0, 8711, 8712, + 7, 17, 0, 0, 8712, 8713, 7, 0, 0, 0, 8713, 8714, 7, 22, 0, 0, 8714, 8715, + 5, 95, 0, 0, 8715, 8716, 7, 25, 0, 0, 8716, 8717, 7, 12, 0, 0, 8717, 8718, + 7, 6, 0, 0, 8718, 8719, 7, 12, 0, 0, 8719, 8720, 7, 6, 0, 0, 8720, 8721, + 5, 95, 0, 0, 8721, 8722, 7, 3, 0, 0, 8722, 8723, 7, 6, 0, 0, 8723, 8724, + 7, 0, 0, 0, 8724, 8725, 7, 14, 0, 0, 8725, 8726, 7, 6, 0, 0, 8726, 8727, + 7, 3, 0, 0, 8727, 8728, 7, 9, 0, 0, 8728, 1134, 1, 0, 0, 0, 8729, 8730, + 7, 17, 0, 0, 8730, 8731, 7, 0, 0, 0, 8731, 8732, 7, 22, 0, 0, 8732, 8733, + 5, 95, 0, 0, 8733, 8734, 7, 3, 0, 0, 8734, 8735, 7, 2, 0, 0, 8735, 8736, + 7, 11, 0, 0, 8736, 8737, 7, 11, 0, 0, 8737, 8738, 7, 2, 0, 0, 8738, 8739, + 7, 15, 0, 0, 8739, 8740, 7, 6, 0, 0, 8740, 8741, 7, 3, 0, 0, 8741, 8742, + 5, 95, 0, 0, 8742, 8743, 7, 5, 0, 0, 8743, 8744, 7, 8, 0, 0, 8744, 8745, + 7, 11, 0, 0, 8745, 8746, 7, 6, 0, 0, 8746, 8747, 7, 9, 0, 0, 8747, 1136, + 1, 0, 0, 0, 8748, 8749, 7, 17, 0, 0, 8749, 8750, 7, 0, 0, 0, 8750, 8751, + 7, 22, 0, 0, 8751, 8752, 5, 95, 0, 0, 8752, 8753, 7, 9, 0, 0, 8753, 8754, + 7, 8, 0, 0, 8754, 8755, 7, 23, 0, 0, 8755, 8756, 7, 6, 0, 0, 8756, 1138, + 1, 0, 0, 0, 8757, 8758, 7, 17, 0, 0, 8758, 8759, 7, 1, 0, 0, 8759, 1140, + 1, 0, 0, 0, 8760, 8761, 7, 17, 0, 0, 8761, 8762, 7, 6, 0, 0, 8762, 8763, + 7, 14, 0, 0, 8763, 8764, 7, 8, 0, 0, 8764, 8765, 7, 0, 0, 0, 8765, 8766, + 7, 14, 0, 0, 8766, 8767, 7, 6, 0, 0, 8767, 8768, 7, 9, 0, 0, 8768, 8769, + 7, 13, 0, 0, 8769, 8770, 7, 3, 0, 0, 8770, 8771, 7, 8, 0, 0, 8771, 8772, + 7, 20, 0, 0, 8772, 8773, 7, 4, 0, 0, 8773, 8774, 7, 8, 0, 0, 8774, 8775, + 7, 2, 0, 0, 8775, 8776, 7, 10, 0, 0, 8776, 1142, 1, 0, 0, 0, 8777, 8778, + 7, 17, 0, 0, 8778, 8779, 7, 6, 0, 0, 8779, 8780, 7, 14, 0, 0, 8780, 8781, + 7, 8, 0, 0, 8781, 8782, 7, 0, 0, 0, 8782, 8783, 7, 10, 0, 0, 8783, 8784, + 7, 0, 0, 0, 8784, 8785, 7, 17, 0, 0, 8785, 8786, 7, 6, 0, 0, 8786, 1144, + 1, 0, 0, 0, 8787, 8788, 7, 17, 0, 0, 8788, 8789, 7, 6, 0, 0, 8789, 8790, + 7, 14, 0, 0, 8790, 8791, 7, 8, 0, 0, 8791, 8792, 7, 12, 0, 0, 8792, 8793, + 7, 17, 0, 0, 8793, 1146, 1, 0, 0, 0, 8794, 8795, 7, 17, 0, 0, 8795, 8796, + 7, 6, 0, 0, 8796, 8797, 7, 17, 0, 0, 8797, 8798, 7, 1, 0, 0, 8798, 8799, + 7, 6, 0, 0, 8799, 8800, 7, 3, 0, 0, 8800, 1148, 1, 0, 0, 0, 8801, 8802, + 7, 17, 0, 0, 8802, 8803, 7, 6, 0, 0, 8803, 8804, 7, 17, 0, 0, 8804, 8805, + 7, 2, 0, 0, 8805, 8806, 7, 3, 0, 0, 8806, 8807, 7, 16, 0, 0, 8807, 8808, + 5, 95, 0, 0, 8808, 8809, 7, 2, 0, 0, 8809, 8810, 7, 20, 0, 0, 8810, 8811, + 7, 4, 0, 0, 8811, 8812, 7, 8, 0, 0, 8812, 8813, 7, 17, 0, 0, 8813, 8814, + 7, 8, 0, 0, 8814, 8815, 7, 23, 0, 0, 8815, 8816, 7, 6, 0, 0, 8816, 8817, + 7, 14, 0, 0, 8817, 8818, 5, 95, 0, 0, 8818, 8819, 7, 14, 0, 0, 8819, 8820, + 7, 0, 0, 0, 8820, 8821, 7, 4, 0, 0, 8821, 8822, 7, 0, 0, 0, 8822, 1150, + 1, 0, 0, 0, 8823, 8824, 7, 17, 0, 0, 8824, 8825, 7, 6, 0, 0, 8825, 8826, + 7, 17, 0, 0, 8826, 8827, 7, 2, 0, 0, 8827, 8828, 7, 3, 0, 0, 8828, 8829, + 7, 16, 0, 0, 8829, 8830, 5, 95, 0, 0, 8830, 8831, 7, 20, 0, 0, 8831, 8832, + 7, 0, 0, 0, 8832, 8833, 7, 3, 0, 0, 8833, 8834, 7, 4, 0, 0, 8834, 8835, + 7, 8, 0, 0, 8835, 8836, 7, 4, 0, 0, 8836, 8837, 7, 8, 0, 0, 8837, 8838, + 7, 2, 0, 0, 8838, 8839, 7, 10, 0, 0, 8839, 8840, 5, 95, 0, 0, 8840, 8841, + 7, 17, 0, 0, 8841, 8842, 7, 2, 0, 0, 8842, 8843, 7, 14, 0, 0, 8843, 8844, + 7, 6, 0, 0, 8844, 1152, 1, 0, 0, 0, 8845, 8846, 7, 17, 0, 0, 8846, 8847, + 7, 6, 0, 0, 8847, 8848, 7, 3, 0, 0, 8848, 8849, 7, 18, 0, 0, 8849, 8850, + 7, 6, 0, 0, 8850, 1154, 1, 0, 0, 0, 8851, 8852, 7, 17, 0, 0, 8852, 8853, + 7, 6, 0, 0, 8853, 8854, 7, 9, 0, 0, 8854, 8855, 7, 9, 0, 0, 8855, 8856, + 7, 0, 0, 0, 8856, 8857, 7, 18, 0, 0, 8857, 8858, 7, 6, 0, 0, 8858, 1156, + 1, 0, 0, 0, 8859, 8860, 7, 17, 0, 0, 8860, 8861, 7, 6, 0, 0, 8861, 8862, + 7, 9, 0, 0, 8862, 8863, 7, 9, 0, 0, 8863, 8864, 7, 0, 0, 0, 8864, 8865, + 7, 18, 0, 0, 8865, 8866, 7, 6, 0, 0, 8866, 8867, 5, 95, 0, 0, 8867, 8868, + 7, 5, 0, 0, 8868, 8869, 7, 2, 0, 0, 8869, 8870, 7, 3, 0, 0, 8870, 8871, + 7, 7, 0, 0, 8871, 8872, 7, 0, 0, 0, 8872, 8873, 7, 3, 0, 0, 8873, 8874, + 7, 14, 0, 0, 8874, 8875, 7, 8, 0, 0, 8875, 8876, 7, 10, 0, 0, 8876, 8877, + 7, 18, 0, 0, 8877, 1158, 1, 0, 0, 0, 8878, 8879, 7, 17, 0, 0, 8879, 8880, + 7, 6, 0, 0, 8880, 8881, 7, 9, 0, 0, 8881, 8882, 7, 9, 0, 0, 8882, 8883, + 7, 0, 0, 0, 8883, 8884, 7, 18, 0, 0, 8884, 8885, 7, 6, 0, 0, 8885, 8886, + 5, 95, 0, 0, 8886, 8887, 7, 5, 0, 0, 8887, 8888, 7, 2, 0, 0, 8888, 8889, + 7, 3, 0, 0, 8889, 8890, 7, 7, 0, 0, 8890, 8891, 7, 0, 0, 0, 8891, 8892, + 7, 3, 0, 0, 8892, 8893, 7, 14, 0, 0, 8893, 8894, 5, 95, 0, 0, 8894, 8895, + 7, 9, 0, 0, 8895, 8896, 7, 8, 0, 0, 8896, 8897, 7, 23, 0, 0, 8897, 8898, + 7, 6, 0, 0, 8898, 1160, 1, 0, 0, 0, 8899, 8900, 7, 17, 0, 0, 8900, 8901, + 7, 8, 0, 0, 8901, 8902, 7, 10, 0, 0, 8902, 1162, 1, 0, 0, 0, 8903, 8904, + 7, 17, 0, 0, 8904, 8905, 7, 8, 0, 0, 8905, 8906, 7, 10, 0, 0, 8906, 8907, + 7, 12, 0, 0, 8907, 8908, 7, 4, 0, 0, 8908, 8909, 7, 6, 0, 0, 8909, 8910, + 7, 9, 0, 0, 8910, 1164, 1, 0, 0, 0, 8911, 8912, 7, 17, 0, 0, 8912, 8913, + 7, 8, 0, 0, 8913, 8914, 7, 10, 0, 0, 8914, 8915, 7, 15, 0, 0, 8915, 8916, + 7, 0, 0, 0, 8916, 8917, 7, 11, 0, 0, 8917, 8918, 7, 12, 0, 0, 8918, 8919, + 7, 6, 0, 0, 8919, 1166, 1, 0, 0, 0, 8920, 8921, 7, 17, 0, 0, 8921, 8922, + 7, 8, 0, 0, 8922, 8923, 7, 10, 0, 0, 8923, 8924, 5, 95, 0, 0, 8924, 8925, + 7, 0, 0, 0, 8925, 8926, 7, 13, 0, 0, 8926, 8927, 7, 4, 0, 0, 8927, 8928, + 7, 8, 0, 0, 8928, 8929, 7, 15, 0, 0, 8929, 8930, 7, 6, 0, 0, 8930, 8931, + 5, 95, 0, 0, 8931, 8932, 7, 3, 0, 0, 8932, 8933, 7, 2, 0, 0, 8933, 8934, + 7, 7, 0, 0, 8934, 8935, 7, 15, 0, 0, 8935, 8936, 7, 6, 0, 0, 8936, 8937, + 7, 3, 0, 0, 8937, 8938, 7, 9, 0, 0, 8938, 8939, 7, 8, 0, 0, 8939, 8940, + 7, 2, 0, 0, 8940, 8941, 7, 10, 0, 0, 8941, 1168, 1, 0, 0, 0, 8942, 8943, + 7, 17, 0, 0, 8943, 8944, 7, 8, 0, 0, 8944, 8945, 7, 10, 0, 0, 8945, 8946, + 5, 95, 0, 0, 8946, 8947, 7, 13, 0, 0, 8947, 8948, 7, 20, 0, 0, 8948, 8949, + 7, 12, 0, 0, 8949, 8950, 5, 95, 0, 0, 8950, 8951, 7, 20, 0, 0, 8951, 8952, + 7, 6, 0, 0, 8952, 8953, 7, 3, 0, 0, 8953, 8954, 7, 13, 0, 0, 8954, 8955, + 7, 6, 0, 0, 8955, 8956, 7, 10, 0, 0, 8956, 8957, 7, 4, 0, 0, 8957, 1170, + 1, 0, 0, 0, 8958, 8959, 7, 17, 0, 0, 8959, 8960, 7, 8, 0, 0, 8960, 8961, + 7, 10, 0, 0, 8961, 8962, 5, 95, 0, 0, 8962, 8963, 7, 8, 0, 0, 8963, 8964, + 7, 2, 0, 0, 8964, 8965, 7, 20, 0, 0, 8965, 8966, 7, 9, 0, 0, 8966, 8967, + 5, 95, 0, 0, 8967, 8968, 7, 20, 0, 0, 8968, 8969, 7, 6, 0, 0, 8969, 8970, + 7, 3, 0, 0, 8970, 8971, 5, 95, 0, 0, 8971, 8972, 7, 15, 0, 0, 8972, 8973, + 7, 2, 0, 0, 8973, 8974, 7, 11, 0, 0, 8974, 8975, 7, 12, 0, 0, 8975, 8976, + 7, 17, 0, 0, 8976, 8977, 7, 6, 0, 0, 8977, 1172, 1, 0, 0, 0, 8978, 8979, + 7, 17, 0, 0, 8979, 8980, 7, 8, 0, 0, 8980, 8981, 7, 10, 0, 0, 8981, 8982, + 5, 95, 0, 0, 8982, 8983, 7, 17, 0, 0, 8983, 8984, 7, 6, 0, 0, 8984, 8985, + 7, 17, 0, 0, 8985, 8986, 7, 2, 0, 0, 8986, 8987, 7, 3, 0, 0, 8987, 8988, + 7, 16, 0, 0, 8988, 8989, 5, 95, 0, 0, 8989, 8990, 7, 20, 0, 0, 8990, 8991, + 7, 6, 0, 0, 8991, 8992, 7, 3, 0, 0, 8992, 8993, 7, 13, 0, 0, 8993, 8994, + 7, 6, 0, 0, 8994, 8995, 7, 10, 0, 0, 8995, 8996, 7, 4, 0, 0, 8996, 1174, + 1, 0, 0, 0, 8997, 8998, 7, 17, 0, 0, 8998, 8999, 7, 8, 0, 0, 8999, 9000, + 7, 3, 0, 0, 9000, 9001, 7, 3, 0, 0, 9001, 9002, 7, 2, 0, 0, 9002, 9003, + 7, 3, 0, 0, 9003, 1176, 1, 0, 0, 0, 9004, 9005, 7, 17, 0, 0, 9005, 9006, + 7, 8, 0, 0, 9006, 9007, 7, 3, 0, 0, 9007, 9008, 7, 3, 0, 0, 9008, 9009, + 7, 2, 0, 0, 9009, 9010, 7, 3, 0, 0, 9010, 9011, 5, 95, 0, 0, 9011, 9012, + 7, 0, 0, 0, 9012, 9013, 7, 14, 0, 0, 9013, 9014, 7, 14, 0, 0, 9014, 9015, + 7, 3, 0, 0, 9015, 9016, 7, 6, 0, 0, 9016, 9017, 7, 9, 0, 0, 9017, 9018, + 7, 9, 0, 0, 9018, 1178, 1, 0, 0, 0, 9019, 9020, 7, 17, 0, 0, 9020, 9021, + 7, 8, 0, 0, 9021, 9022, 7, 22, 0, 0, 9022, 9023, 7, 6, 0, 0, 9023, 9024, + 7, 14, 0, 0, 9024, 9025, 5, 95, 0, 0, 9025, 9026, 7, 20, 0, 0, 9026, 9027, + 7, 0, 0, 0, 9027, 9028, 7, 18, 0, 0, 9028, 9029, 7, 6, 0, 0, 9029, 9030, + 5, 95, 0, 0, 9030, 9031, 7, 0, 0, 0, 9031, 9032, 7, 11, 0, 0, 9032, 9033, + 7, 11, 0, 0, 9033, 9034, 7, 2, 0, 0, 9034, 9035, 7, 13, 0, 0, 9035, 9036, + 7, 0, 0, 0, 9036, 9037, 7, 4, 0, 0, 9037, 9038, 7, 8, 0, 0, 9038, 9039, + 7, 2, 0, 0, 9039, 9040, 7, 10, 0, 0, 9040, 1180, 1, 0, 0, 0, 9041, 9042, + 7, 17, 0, 0, 9042, 9043, 7, 2, 0, 0, 9043, 9044, 7, 14, 0, 0, 9044, 9045, + 7, 6, 0, 0, 9045, 1182, 1, 0, 0, 0, 9046, 9047, 7, 17, 0, 0, 9047, 9048, + 7, 2, 0, 0, 9048, 9049, 7, 14, 0, 0, 9049, 9050, 7, 8, 0, 0, 9050, 9051, + 7, 5, 0, 0, 9051, 9052, 7, 16, 0, 0, 9052, 1184, 1, 0, 0, 0, 9053, 9054, + 5, 91, 0, 0, 9054, 9055, 7, 17, 0, 0, 9055, 9056, 7, 2, 0, 0, 9056, 9057, + 7, 14, 0, 0, 9057, 9058, 7, 8, 0, 0, 9058, 9059, 7, 5, 0, 0, 9059, 9060, + 7, 16, 0, 0, 9060, 9061, 5, 93, 0, 0, 9061, 1186, 1, 0, 0, 0, 9062, 9063, + 7, 17, 0, 0, 9063, 9064, 7, 2, 0, 0, 9064, 9065, 7, 15, 0, 0, 9065, 9066, + 7, 6, 0, 0, 9066, 1188, 1, 0, 0, 0, 9067, 9068, 7, 17, 0, 0, 9068, 9069, + 7, 12, 0, 0, 9069, 9070, 7, 11, 0, 0, 9070, 9071, 7, 4, 0, 0, 9071, 9072, + 7, 8, 0, 0, 9072, 9073, 5, 95, 0, 0, 9073, 9074, 7, 12, 0, 0, 9074, 9075, + 7, 9, 0, 0, 9075, 9076, 7, 6, 0, 0, 9076, 9077, 7, 3, 0, 0, 9077, 1190, + 1, 0, 0, 0, 9078, 9079, 7, 17, 0, 0, 9079, 9080, 7, 12, 0, 0, 9080, 9081, + 7, 9, 0, 0, 9081, 9082, 7, 4, 0, 0, 9082, 9083, 5, 95, 0, 0, 9083, 9084, + 7, 13, 0, 0, 9084, 9085, 7, 19, 0, 0, 9085, 9086, 7, 0, 0, 0, 9086, 9087, + 7, 10, 0, 0, 9087, 9088, 7, 18, 0, 0, 9088, 9089, 7, 6, 0, 0, 9089, 1192, + 1, 0, 0, 0, 9090, 9091, 7, 10, 0, 0, 9091, 9092, 7, 0, 0, 0, 9092, 9093, + 7, 17, 0, 0, 9093, 9094, 7, 6, 0, 0, 9094, 1194, 1, 0, 0, 0, 9095, 9096, + 7, 10, 0, 0, 9096, 9097, 7, 0, 0, 0, 9097, 9098, 7, 4, 0, 0, 9098, 9099, + 7, 8, 0, 0, 9099, 9100, 7, 2, 0, 0, 9100, 9101, 7, 10, 0, 0, 9101, 9102, + 7, 0, 0, 0, 9102, 9103, 7, 11, 0, 0, 9103, 1196, 1, 0, 0, 0, 9104, 9105, + 7, 10, 0, 0, 9105, 9106, 7, 13, 0, 0, 9106, 9107, 7, 19, 0, 0, 9107, 9108, + 7, 0, 0, 0, 9108, 9109, 7, 3, 0, 0, 9109, 1198, 1, 0, 0, 0, 9110, 9111, + 7, 10, 0, 0, 9111, 9112, 7, 6, 0, 0, 9112, 9113, 7, 18, 0, 0, 9113, 9114, + 7, 2, 0, 0, 9114, 9115, 7, 4, 0, 0, 9115, 9116, 7, 8, 0, 0, 9116, 9117, + 7, 0, 0, 0, 9117, 9118, 7, 4, 0, 0, 9118, 9119, 7, 6, 0, 0, 9119, 1200, + 1, 0, 0, 0, 9120, 9121, 7, 10, 0, 0, 9121, 9122, 7, 6, 0, 0, 9122, 9123, + 7, 9, 0, 0, 9123, 9124, 7, 4, 0, 0, 9124, 9125, 7, 6, 0, 0, 9125, 9126, + 7, 14, 0, 0, 9126, 9127, 5, 95, 0, 0, 9127, 9128, 7, 4, 0, 0, 9128, 9129, + 7, 3, 0, 0, 9129, 9130, 7, 8, 0, 0, 9130, 9131, 7, 18, 0, 0, 9131, 9132, + 7, 18, 0, 0, 9132, 9133, 7, 6, 0, 0, 9133, 9134, 7, 3, 0, 0, 9134, 9135, + 7, 9, 0, 0, 9135, 1202, 1, 0, 0, 0, 9136, 9137, 7, 10, 0, 0, 9137, 9138, + 7, 6, 0, 0, 9138, 9139, 7, 7, 0, 0, 9139, 9140, 7, 8, 0, 0, 9140, 9141, + 7, 14, 0, 0, 9141, 1204, 1, 0, 0, 0, 9142, 9143, 7, 10, 0, 0, 9143, 9144, + 7, 6, 0, 0, 9144, 9145, 7, 7, 0, 0, 9145, 9146, 7, 10, 0, 0, 9146, 9147, + 7, 0, 0, 0, 9147, 9148, 7, 17, 0, 0, 9148, 9149, 7, 6, 0, 0, 9149, 1206, + 1, 0, 0, 0, 9150, 9151, 7, 10, 0, 0, 9151, 9152, 7, 6, 0, 0, 9152, 9153, + 7, 7, 0, 0, 9153, 9154, 7, 9, 0, 0, 9154, 9155, 7, 6, 0, 0, 9155, 9156, + 7, 25, 0, 0, 9156, 9157, 7, 12, 0, 0, 9157, 9158, 7, 6, 0, 0, 9158, 9159, + 7, 10, 0, 0, 9159, 9160, 7, 4, 0, 0, 9160, 9161, 7, 8, 0, 0, 9161, 9162, + 7, 0, 0, 0, 9162, 9163, 7, 11, 0, 0, 9163, 9164, 7, 8, 0, 0, 9164, 9165, + 7, 14, 0, 0, 9165, 1208, 1, 0, 0, 0, 9166, 9167, 7, 10, 0, 0, 9167, 9168, + 7, 6, 0, 0, 9168, 9169, 7, 7, 0, 0, 9169, 9170, 5, 95, 0, 0, 9170, 9171, + 7, 0, 0, 0, 9171, 9172, 7, 13, 0, 0, 9172, 9173, 7, 13, 0, 0, 9173, 9174, + 7, 2, 0, 0, 9174, 9175, 7, 12, 0, 0, 9175, 9176, 7, 10, 0, 0, 9176, 9177, + 7, 4, 0, 0, 9177, 1210, 1, 0, 0, 0, 9178, 9179, 7, 10, 0, 0, 9179, 9180, + 7, 6, 0, 0, 9180, 9181, 7, 7, 0, 0, 9181, 9182, 5, 95, 0, 0, 9182, 9183, + 7, 1, 0, 0, 9183, 9184, 7, 3, 0, 0, 9184, 9185, 7, 2, 0, 0, 9185, 9186, + 7, 21, 0, 0, 9186, 9187, 7, 6, 0, 0, 9187, 9188, 7, 3, 0, 0, 9188, 1212, + 1, 0, 0, 0, 9189, 9190, 7, 10, 0, 0, 9190, 9191, 7, 6, 0, 0, 9191, 9192, + 7, 7, 0, 0, 9192, 9193, 5, 95, 0, 0, 9193, 9194, 7, 20, 0, 0, 9194, 9195, + 7, 0, 0, 0, 9195, 9196, 7, 9, 0, 0, 9196, 9197, 7, 9, 0, 0, 9197, 9198, + 7, 7, 0, 0, 9198, 9199, 7, 2, 0, 0, 9199, 9200, 7, 3, 0, 0, 9200, 9201, + 7, 14, 0, 0, 9201, 1214, 1, 0, 0, 0, 9202, 9203, 7, 10, 0, 0, 9203, 9204, + 7, 6, 0, 0, 9204, 9205, 7, 22, 0, 0, 9205, 9206, 7, 4, 0, 0, 9206, 1216, + 1, 0, 0, 0, 9207, 9208, 7, 10, 0, 0, 9208, 9209, 7, 2, 0, 0, 9209, 1218, + 1, 0, 0, 0, 9210, 9211, 7, 10, 0, 0, 9211, 9212, 7, 2, 0, 0, 9212, 9213, + 7, 13, 0, 0, 9213, 9214, 7, 19, 0, 0, 9214, 9215, 7, 6, 0, 0, 9215, 9216, + 7, 13, 0, 0, 9216, 9217, 7, 21, 0, 0, 9217, 1220, 1, 0, 0, 0, 9218, 9219, + 7, 10, 0, 0, 9219, 9220, 7, 2, 0, 0, 9220, 9221, 7, 13, 0, 0, 9221, 9222, + 7, 2, 0, 0, 9222, 9223, 7, 12, 0, 0, 9223, 9224, 7, 10, 0, 0, 9224, 9225, + 7, 4, 0, 0, 9225, 1222, 1, 0, 0, 0, 9226, 9227, 7, 10, 0, 0, 9227, 9228, + 7, 2, 0, 0, 9228, 9229, 7, 14, 0, 0, 9229, 9230, 7, 6, 0, 0, 9230, 9231, + 7, 9, 0, 0, 9231, 1224, 1, 0, 0, 0, 9232, 9233, 7, 10, 0, 0, 9233, 9234, + 7, 2, 0, 0, 9234, 9235, 7, 6, 0, 0, 9235, 9236, 7, 22, 0, 0, 9236, 9237, + 7, 6, 0, 0, 9237, 9238, 7, 13, 0, 0, 9238, 1226, 1, 0, 0, 0, 9239, 9240, + 7, 10, 0, 0, 9240, 9241, 7, 2, 0, 0, 9241, 9242, 7, 6, 0, 0, 9242, 9243, + 7, 22, 0, 0, 9243, 9244, 7, 20, 0, 0, 9244, 9245, 7, 0, 0, 0, 9245, 9246, + 7, 10, 0, 0, 9246, 9247, 7, 14, 0, 0, 9247, 1228, 1, 0, 0, 0, 9248, 9249, + 7, 10, 0, 0, 9249, 9250, 7, 2, 0, 0, 9250, 9251, 7, 5, 0, 0, 9251, 9252, + 7, 2, 0, 0, 9252, 9253, 7, 3, 0, 0, 9253, 9254, 7, 17, 0, 0, 9254, 9255, + 7, 0, 0, 0, 9255, 9256, 7, 4, 0, 0, 9256, 1230, 1, 0, 0, 0, 9257, 9258, + 7, 10, 0, 0, 9258, 9259, 7, 2, 0, 0, 9259, 9260, 7, 19, 0, 0, 9260, 9261, + 7, 2, 0, 0, 9261, 9262, 7, 11, 0, 0, 9262, 9263, 7, 14, 0, 0, 9263, 9264, + 7, 11, 0, 0, 9264, 9265, 7, 2, 0, 0, 9265, 9266, 7, 13, 0, 0, 9266, 9267, + 7, 21, 0, 0, 9267, 1232, 1, 0, 0, 0, 9268, 9269, 7, 10, 0, 0, 9269, 9270, + 7, 2, 0, 0, 9270, 9271, 7, 8, 0, 0, 9271, 9272, 7, 10, 0, 0, 9272, 9273, + 7, 14, 0, 0, 9273, 9274, 7, 6, 0, 0, 9274, 9275, 7, 22, 0, 0, 9275, 1234, + 1, 0, 0, 0, 9276, 9277, 7, 10, 0, 0, 9277, 9278, 7, 2, 0, 0, 9278, 9279, + 7, 8, 0, 0, 9279, 9280, 7, 10, 0, 0, 9280, 9281, 7, 8, 0, 0, 9281, 9282, + 7, 4, 0, 0, 9282, 1236, 1, 0, 0, 0, 9283, 9284, 7, 10, 0, 0, 9284, 9285, + 7, 2, 0, 0, 9285, 9286, 7, 11, 0, 0, 9286, 9287, 7, 2, 0, 0, 9287, 9288, + 7, 13, 0, 0, 9288, 9289, 7, 21, 0, 0, 9289, 1238, 1, 0, 0, 0, 9290, 9291, + 7, 10, 0, 0, 9291, 9292, 7, 2, 0, 0, 9292, 9293, 7, 10, 0, 0, 9293, 9294, + 7, 13, 0, 0, 9294, 9295, 7, 11, 0, 0, 9295, 9296, 7, 12, 0, 0, 9296, 9297, + 7, 9, 0, 0, 9297, 9298, 7, 4, 0, 0, 9298, 9299, 7, 6, 0, 0, 9299, 9300, + 7, 3, 0, 0, 9300, 9301, 7, 6, 0, 0, 9301, 9302, 7, 14, 0, 0, 9302, 1240, + 1, 0, 0, 0, 9303, 9304, 7, 10, 0, 0, 9304, 9305, 7, 2, 0, 0, 9305, 9306, + 7, 10, 0, 0, 9306, 9307, 7, 6, 0, 0, 9307, 1242, 1, 0, 0, 0, 9308, 9309, + 7, 10, 0, 0, 9309, 9310, 7, 2, 0, 0, 9310, 9311, 7, 10, 0, 0, 9311, 9312, + 5, 95, 0, 0, 9312, 9313, 7, 4, 0, 0, 9313, 9314, 7, 3, 0, 0, 9314, 9315, + 7, 0, 0, 0, 9315, 9316, 7, 10, 0, 0, 9316, 9317, 7, 9, 0, 0, 9317, 9318, + 7, 0, 0, 0, 9318, 9319, 7, 13, 0, 0, 9319, 9320, 7, 4, 0, 0, 9320, 9321, + 7, 6, 0, 0, 9321, 9322, 7, 14, 0, 0, 9322, 9323, 5, 95, 0, 0, 9323, 9324, + 7, 0, 0, 0, 9324, 9325, 7, 13, 0, 0, 9325, 9326, 7, 13, 0, 0, 9326, 9327, + 7, 6, 0, 0, 9327, 9328, 7, 9, 0, 0, 9328, 9329, 7, 9, 0, 0, 9329, 1244, + 1, 0, 0, 0, 9330, 9331, 7, 10, 0, 0, 9331, 9332, 7, 2, 0, 0, 9332, 9333, + 7, 3, 0, 0, 9333, 9334, 7, 6, 0, 0, 9334, 9335, 7, 13, 0, 0, 9335, 9336, + 7, 2, 0, 0, 9336, 9337, 7, 17, 0, 0, 9337, 9338, 7, 20, 0, 0, 9338, 9339, + 7, 12, 0, 0, 9339, 9340, 7, 4, 0, 0, 9340, 9341, 7, 6, 0, 0, 9341, 1246, + 1, 0, 0, 0, 9342, 9343, 7, 10, 0, 0, 9343, 9344, 7, 2, 0, 0, 9344, 9345, + 7, 3, 0, 0, 9345, 9346, 7, 6, 0, 0, 9346, 9347, 7, 13, 0, 0, 9347, 9348, + 7, 2, 0, 0, 9348, 9349, 7, 15, 0, 0, 9349, 9350, 7, 6, 0, 0, 9350, 9351, + 7, 3, 0, 0, 9351, 9352, 7, 16, 0, 0, 9352, 1248, 1, 0, 0, 0, 9353, 9354, + 7, 10, 0, 0, 9354, 9355, 7, 2, 0, 0, 9355, 9356, 7, 3, 0, 0, 9356, 9357, + 7, 6, 0, 0, 9357, 9358, 7, 7, 0, 0, 9358, 9359, 7, 8, 0, 0, 9359, 9360, + 7, 10, 0, 0, 9360, 9361, 7, 14, 0, 0, 9361, 1250, 1, 0, 0, 0, 9362, 9363, + 7, 10, 0, 0, 9363, 9364, 7, 2, 0, 0, 9364, 9365, 7, 9, 0, 0, 9365, 9366, + 7, 21, 0, 0, 9366, 9367, 7, 8, 0, 0, 9367, 9368, 7, 20, 0, 0, 9368, 1252, + 1, 0, 0, 0, 9369, 9370, 7, 10, 0, 0, 9370, 9371, 7, 2, 0, 0, 9371, 9372, + 7, 4, 0, 0, 9372, 1254, 1, 0, 0, 0, 9373, 9374, 7, 10, 0, 0, 9374, 9375, + 7, 2, 0, 0, 9375, 9376, 7, 4, 0, 0, 9376, 9377, 7, 8, 0, 0, 9377, 9378, + 7, 5, 0, 0, 9378, 9379, 7, 8, 0, 0, 9379, 9380, 7, 13, 0, 0, 9380, 9381, + 7, 0, 0, 0, 9381, 9382, 7, 4, 0, 0, 9382, 9383, 7, 8, 0, 0, 9383, 9384, + 7, 2, 0, 0, 9384, 9385, 7, 10, 0, 0, 9385, 1256, 1, 0, 0, 0, 9386, 9387, + 7, 10, 0, 0, 9387, 9388, 7, 2, 0, 0, 9388, 9389, 7, 4, 0, 0, 9389, 9390, + 7, 8, 0, 0, 9390, 9391, 7, 5, 0, 0, 9391, 9392, 7, 8, 0, 0, 9392, 9393, + 7, 13, 0, 0, 9393, 9394, 7, 0, 0, 0, 9394, 9395, 7, 4, 0, 0, 9395, 9396, + 7, 8, 0, 0, 9396, 9397, 7, 2, 0, 0, 9397, 9398, 7, 10, 0, 0, 9398, 9399, + 7, 9, 0, 0, 9399, 1258, 1, 0, 0, 0, 9400, 9401, 7, 10, 0, 0, 9401, 9402, + 7, 2, 0, 0, 9402, 9403, 7, 12, 0, 0, 9403, 9404, 7, 10, 0, 0, 9404, 9405, + 7, 11, 0, 0, 9405, 9406, 7, 2, 0, 0, 9406, 9407, 7, 0, 0, 0, 9407, 9408, + 7, 14, 0, 0, 9408, 1260, 1, 0, 0, 0, 9409, 9410, 7, 10, 0, 0, 9410, 9411, + 7, 2, 0, 0, 9411, 9412, 7, 7, 0, 0, 9412, 9413, 7, 0, 0, 0, 9413, 9414, + 7, 8, 0, 0, 9414, 9415, 7, 4, 0, 0, 9415, 1262, 1, 0, 0, 0, 9416, 9417, + 7, 10, 0, 0, 9417, 9418, 7, 2, 0, 0, 9418, 9419, 5, 95, 0, 0, 9419, 9420, + 7, 13, 0, 0, 9420, 9421, 7, 19, 0, 0, 9421, 9422, 7, 6, 0, 0, 9422, 9423, + 7, 13, 0, 0, 9423, 9424, 7, 21, 0, 0, 9424, 9425, 7, 9, 0, 0, 9425, 9426, + 7, 12, 0, 0, 9426, 9427, 7, 17, 0, 0, 9427, 1264, 1, 0, 0, 0, 9428, 9429, + 7, 10, 0, 0, 9429, 9430, 7, 2, 0, 0, 9430, 9431, 5, 95, 0, 0, 9431, 9432, + 7, 13, 0, 0, 9432, 9433, 7, 2, 0, 0, 9433, 9434, 7, 17, 0, 0, 9434, 9435, + 7, 20, 0, 0, 9435, 9436, 7, 3, 0, 0, 9436, 9437, 7, 6, 0, 0, 9437, 9438, + 7, 9, 0, 0, 9438, 9439, 7, 9, 0, 0, 9439, 9440, 7, 8, 0, 0, 9440, 9441, + 7, 2, 0, 0, 9441, 9442, 7, 10, 0, 0, 9442, 1266, 1, 0, 0, 0, 9443, 9444, + 7, 10, 0, 0, 9444, 9445, 7, 2, 0, 0, 9445, 9446, 5, 95, 0, 0, 9446, 9447, + 7, 6, 0, 0, 9447, 9448, 7, 15, 0, 0, 9448, 9449, 7, 6, 0, 0, 9449, 9450, + 7, 10, 0, 0, 9450, 9451, 7, 4, 0, 0, 9451, 9452, 5, 95, 0, 0, 9452, 9453, + 7, 11, 0, 0, 9453, 9454, 7, 2, 0, 0, 9454, 9455, 7, 9, 0, 0, 9455, 9456, + 7, 9, 0, 0, 9456, 1268, 1, 0, 0, 0, 9457, 9458, 7, 10, 0, 0, 9458, 9459, + 7, 2, 0, 0, 9459, 9460, 5, 95, 0, 0, 9460, 9461, 7, 8, 0, 0, 9461, 9462, + 7, 10, 0, 0, 9462, 9463, 7, 5, 0, 0, 9463, 9464, 7, 2, 0, 0, 9464, 9465, + 7, 17, 0, 0, 9465, 9466, 7, 9, 0, 0, 9466, 9467, 7, 18, 0, 0, 9467, 9468, + 7, 9, 0, 0, 9468, 1270, 1, 0, 0, 0, 9469, 9470, 7, 10, 0, 0, 9470, 9471, + 7, 2, 0, 0, 9471, 9472, 5, 95, 0, 0, 9472, 9473, 7, 25, 0, 0, 9473, 9474, + 7, 12, 0, 0, 9474, 9475, 7, 6, 0, 0, 9475, 9476, 7, 3, 0, 0, 9476, 9477, + 7, 16, 0, 0, 9477, 9478, 7, 9, 0, 0, 9478, 9479, 7, 4, 0, 0, 9479, 9480, + 7, 2, 0, 0, 9480, 9481, 7, 3, 0, 0, 9481, 9482, 7, 6, 0, 0, 9482, 1272, + 1, 0, 0, 0, 9483, 9484, 7, 10, 0, 0, 9484, 9485, 7, 2, 0, 0, 9485, 9486, + 5, 95, 0, 0, 9486, 9487, 7, 9, 0, 0, 9487, 9488, 7, 4, 0, 0, 9488, 9489, + 7, 0, 0, 0, 9489, 9490, 7, 4, 0, 0, 9490, 9491, 7, 8, 0, 0, 9491, 9492, + 7, 9, 0, 0, 9492, 9493, 7, 4, 0, 0, 9493, 9494, 7, 8, 0, 0, 9494, 9495, + 7, 13, 0, 0, 9495, 9496, 7, 9, 0, 0, 9496, 1274, 1, 0, 0, 0, 9497, 9498, + 7, 10, 0, 0, 9498, 9499, 7, 2, 0, 0, 9499, 9500, 5, 95, 0, 0, 9500, 9501, + 7, 4, 0, 0, 9501, 9502, 7, 3, 0, 0, 9502, 9503, 7, 12, 0, 0, 9503, 9504, + 7, 10, 0, 0, 9504, 9505, 7, 13, 0, 0, 9505, 9506, 7, 0, 0, 0, 9506, 9507, + 7, 4, 0, 0, 9507, 9508, 7, 6, 0, 0, 9508, 1276, 1, 0, 0, 0, 9509, 9510, + 7, 10, 0, 0, 9510, 9511, 7, 2, 0, 0, 9511, 9512, 5, 95, 0, 0, 9512, 9513, + 7, 7, 0, 0, 9513, 9514, 7, 0, 0, 0, 9514, 9515, 7, 8, 0, 0, 9515, 9516, + 7, 4, 0, 0, 9516, 1278, 1, 0, 0, 0, 9517, 9518, 7, 10, 0, 0, 9518, 9519, + 7, 4, 0, 0, 9519, 9520, 7, 8, 0, 0, 9520, 9521, 7, 11, 0, 0, 9521, 9522, + 7, 6, 0, 0, 9522, 1280, 1, 0, 0, 0, 9523, 9524, 7, 10, 0, 0, 9524, 9525, + 7, 4, 0, 0, 9525, 9526, 7, 11, 0, 0, 9526, 9527, 7, 17, 0, 0, 9527, 1282, + 1, 0, 0, 0, 9528, 9529, 7, 10, 0, 0, 9529, 9530, 7, 12, 0, 0, 9530, 9531, + 7, 11, 0, 0, 9531, 9532, 7, 11, 0, 0, 9532, 9533, 7, 8, 0, 0, 9533, 9534, + 7, 5, 0, 0, 9534, 1284, 1, 0, 0, 0, 9535, 9536, 7, 10, 0, 0, 9536, 9537, + 7, 12, 0, 0, 9537, 9538, 7, 11, 0, 0, 9538, 9539, 7, 11, 0, 0, 9539, 1286, + 1, 0, 0, 0, 9540, 9541, 7, 26, 0, 0, 9541, 9542, 7, 10, 0, 0, 9542, 9543, + 7, 12, 0, 0, 9543, 9544, 7, 11, 0, 0, 9544, 9545, 7, 11, 0, 0, 9545, 9546, + 1, 0, 0, 0, 9546, 9547, 7, 26, 0, 0, 9547, 1288, 1, 0, 0, 0, 9548, 9549, + 7, 10, 0, 0, 9549, 9550, 7, 12, 0, 0, 9550, 9551, 7, 17, 0, 0, 9551, 9552, + 7, 0, 0, 0, 9552, 9553, 7, 10, 0, 0, 9553, 9554, 7, 2, 0, 0, 9554, 9555, + 7, 14, 0, 0, 9555, 9556, 7, 6, 0, 0, 9556, 1290, 1, 0, 0, 0, 9557, 9558, + 7, 10, 0, 0, 9558, 9559, 7, 12, 0, 0, 9559, 9560, 7, 17, 0, 0, 9560, 9561, + 7, 1, 0, 0, 9561, 9562, 7, 6, 0, 0, 9562, 9563, 7, 3, 0, 0, 9563, 1292, + 1, 0, 0, 0, 9564, 9565, 7, 10, 0, 0, 9565, 9566, 7, 12, 0, 0, 9566, 9567, + 7, 17, 0, 0, 9567, 9568, 7, 6, 0, 0, 9568, 9569, 7, 3, 0, 0, 9569, 9570, + 7, 8, 0, 0, 9570, 9571, 7, 13, 0, 0, 9571, 9572, 5, 95, 0, 0, 9572, 9573, + 7, 3, 0, 0, 9573, 9574, 7, 2, 0, 0, 9574, 9575, 7, 12, 0, 0, 9575, 9576, + 7, 10, 0, 0, 9576, 9577, 7, 14, 0, 0, 9577, 9578, 7, 0, 0, 0, 9578, 9579, + 7, 1, 0, 0, 9579, 9580, 7, 2, 0, 0, 9580, 9581, 7, 3, 0, 0, 9581, 9582, + 7, 4, 0, 0, 9582, 1294, 1, 0, 0, 0, 9583, 9584, 7, 2, 0, 0, 9584, 9585, + 7, 1, 0, 0, 9585, 9586, 7, 24, 0, 0, 9586, 9587, 7, 6, 0, 0, 9587, 9588, + 7, 13, 0, 0, 9588, 9589, 7, 4, 0, 0, 9589, 1296, 1, 0, 0, 0, 9590, 9591, + 7, 2, 0, 0, 9591, 9592, 7, 1, 0, 0, 9592, 9593, 7, 24, 0, 0, 9593, 9594, + 7, 6, 0, 0, 9594, 9595, 7, 13, 0, 0, 9595, 9596, 7, 4, 0, 0, 9596, 9597, + 7, 20, 0, 0, 9597, 9598, 7, 3, 0, 0, 9598, 9599, 7, 2, 0, 0, 9599, 9600, + 7, 20, 0, 0, 9600, 9601, 7, 6, 0, 0, 9601, 9602, 7, 3, 0, 0, 9602, 9603, + 7, 4, 0, 0, 9603, 9604, 7, 16, 0, 0, 9604, 1298, 1, 0, 0, 0, 9605, 9606, + 7, 2, 0, 0, 9606, 9607, 7, 1, 0, 0, 9607, 9608, 7, 24, 0, 0, 9608, 9609, + 7, 6, 0, 0, 9609, 9610, 7, 13, 0, 0, 9610, 9611, 7, 4, 0, 0, 9611, 9612, + 7, 20, 0, 0, 9612, 9613, 7, 3, 0, 0, 9613, 9614, 7, 2, 0, 0, 9614, 9615, + 7, 20, 0, 0, 9615, 9616, 7, 6, 0, 0, 9616, 9617, 7, 3, 0, 0, 9617, 9618, + 7, 4, 0, 0, 9618, 9619, 7, 16, 0, 0, 9619, 9620, 7, 6, 0, 0, 9620, 9621, + 7, 22, 0, 0, 9621, 1300, 1, 0, 0, 0, 9622, 9623, 7, 2, 0, 0, 9623, 9624, + 7, 1, 0, 0, 9624, 9625, 7, 24, 0, 0, 9625, 9626, 7, 6, 0, 0, 9626, 9627, + 7, 13, 0, 0, 9627, 9628, 7, 4, 0, 0, 9628, 9629, 5, 95, 0, 0, 9629, 9630, + 7, 14, 0, 0, 9630, 9631, 7, 6, 0, 0, 9631, 9632, 7, 5, 0, 0, 9632, 9633, + 7, 8, 0, 0, 9633, 9634, 7, 10, 0, 0, 9634, 9635, 7, 8, 0, 0, 9635, 9636, + 7, 4, 0, 0, 9636, 9637, 7, 8, 0, 0, 9637, 9638, 7, 2, 0, 0, 9638, 9639, + 7, 10, 0, 0, 9639, 1302, 1, 0, 0, 0, 9640, 9641, 7, 2, 0, 0, 9641, 9642, + 7, 1, 0, 0, 9642, 9643, 7, 24, 0, 0, 9643, 9644, 7, 6, 0, 0, 9644, 9645, + 7, 13, 0, 0, 9645, 9646, 7, 4, 0, 0, 9646, 9647, 5, 95, 0, 0, 9647, 9648, + 7, 8, 0, 0, 9648, 9649, 7, 14, 0, 0, 9649, 1304, 1, 0, 0, 0, 9650, 9651, + 7, 2, 0, 0, 9651, 9652, 7, 1, 0, 0, 9652, 9653, 7, 24, 0, 0, 9653, 9654, + 7, 6, 0, 0, 9654, 9655, 7, 13, 0, 0, 9655, 9656, 7, 4, 0, 0, 9656, 9657, + 5, 95, 0, 0, 9657, 9658, 7, 10, 0, 0, 9658, 9659, 7, 0, 0, 0, 9659, 9660, + 7, 17, 0, 0, 9660, 9661, 7, 6, 0, 0, 9661, 1306, 1, 0, 0, 0, 9662, 9663, + 7, 2, 0, 0, 9663, 9664, 7, 1, 0, 0, 9664, 9665, 7, 24, 0, 0, 9665, 9666, + 7, 6, 0, 0, 9666, 9667, 7, 13, 0, 0, 9667, 9668, 7, 4, 0, 0, 9668, 9669, + 5, 95, 0, 0, 9669, 9670, 7, 9, 0, 0, 9670, 9671, 7, 13, 0, 0, 9671, 9672, + 7, 19, 0, 0, 9672, 9673, 7, 6, 0, 0, 9673, 9674, 7, 17, 0, 0, 9674, 9675, + 7, 0, 0, 0, 9675, 9676, 5, 95, 0, 0, 9676, 9677, 7, 10, 0, 0, 9677, 9678, + 7, 0, 0, 0, 9678, 9679, 7, 17, 0, 0, 9679, 9680, 7, 6, 0, 0, 9680, 1308, + 1, 0, 0, 0, 9681, 9682, 7, 2, 0, 0, 9682, 9683, 7, 5, 0, 0, 9683, 1310, + 1, 0, 0, 0, 9684, 9685, 7, 2, 0, 0, 9685, 9686, 7, 5, 0, 0, 9686, 9687, + 7, 5, 0, 0, 9687, 1312, 1, 0, 0, 0, 9688, 9689, 7, 2, 0, 0, 9689, 9690, + 7, 5, 0, 0, 9690, 9691, 7, 5, 0, 0, 9691, 9692, 7, 11, 0, 0, 9692, 9693, + 7, 8, 0, 0, 9693, 9694, 7, 10, 0, 0, 9694, 9695, 7, 6, 0, 0, 9695, 1314, + 1, 0, 0, 0, 9696, 9697, 7, 2, 0, 0, 9697, 9698, 7, 5, 0, 0, 9698, 9699, + 7, 5, 0, 0, 9699, 9700, 7, 9, 0, 0, 9700, 9701, 7, 6, 0, 0, 9701, 9702, + 7, 4, 0, 0, 9702, 1316, 1, 0, 0, 0, 9703, 9704, 7, 2, 0, 0, 9704, 9705, + 7, 5, 0, 0, 9705, 9706, 7, 5, 0, 0, 9706, 9707, 7, 9, 0, 0, 9707, 9708, + 7, 6, 0, 0, 9708, 9709, 7, 4, 0, 0, 9709, 9710, 7, 9, 0, 0, 9710, 1318, + 1, 0, 0, 0, 9711, 9712, 7, 2, 0, 0, 9712, 9713, 7, 11, 0, 0, 9713, 9714, + 7, 14, 0, 0, 9714, 9715, 5, 95, 0, 0, 9715, 9716, 7, 0, 0, 0, 9716, 9717, + 7, 13, 0, 0, 9717, 9718, 7, 13, 0, 0, 9718, 9719, 7, 2, 0, 0, 9719, 9720, + 7, 12, 0, 0, 9720, 9721, 7, 10, 0, 0, 9721, 9722, 7, 4, 0, 0, 9722, 1320, + 1, 0, 0, 0, 9723, 9724, 7, 2, 0, 0, 9724, 9725, 7, 11, 0, 0, 9725, 9726, + 7, 14, 0, 0, 9726, 9727, 5, 95, 0, 0, 9727, 9728, 7, 20, 0, 0, 9728, 9729, + 7, 0, 0, 0, 9729, 9730, 7, 9, 0, 0, 9730, 9731, 7, 9, 0, 0, 9731, 9732, + 7, 7, 0, 0, 9732, 9733, 7, 2, 0, 0, 9733, 9734, 7, 3, 0, 0, 9734, 9735, + 7, 14, 0, 0, 9735, 1322, 1, 0, 0, 0, 9736, 9737, 7, 2, 0, 0, 9737, 9738, + 7, 10, 0, 0, 9738, 1324, 1, 0, 0, 0, 9739, 9740, 7, 2, 0, 0, 9740, 9741, + 7, 10, 0, 0, 9741, 9742, 7, 11, 0, 0, 9742, 9743, 7, 8, 0, 0, 9743, 9744, + 7, 10, 0, 0, 9744, 9745, 7, 6, 0, 0, 9745, 1326, 1, 0, 0, 0, 9746, 9747, + 7, 2, 0, 0, 9747, 9748, 7, 10, 0, 0, 9748, 9749, 7, 11, 0, 0, 9749, 9750, + 7, 16, 0, 0, 9750, 1328, 1, 0, 0, 0, 9751, 9752, 7, 2, 0, 0, 9752, 9753, + 7, 10, 0, 0, 9753, 9754, 5, 95, 0, 0, 9754, 9755, 7, 5, 0, 0, 9755, 9756, + 7, 0, 0, 0, 9756, 9757, 7, 8, 0, 0, 9757, 9758, 7, 11, 0, 0, 9758, 9759, + 7, 12, 0, 0, 9759, 9760, 7, 3, 0, 0, 9760, 9761, 7, 6, 0, 0, 9761, 1330, + 1, 0, 0, 0, 9762, 9763, 7, 2, 0, 0, 9763, 9764, 7, 20, 0, 0, 9764, 9765, + 7, 6, 0, 0, 9765, 9766, 7, 10, 0, 0, 9766, 1332, 1, 0, 0, 0, 9767, 9768, + 7, 2, 0, 0, 9768, 9769, 7, 20, 0, 0, 9769, 9770, 7, 6, 0, 0, 9770, 9771, + 7, 10, 0, 0, 9771, 9772, 7, 14, 0, 0, 9772, 9773, 7, 0, 0, 0, 9773, 9774, + 7, 4, 0, 0, 9774, 9775, 7, 0, 0, 0, 9775, 9776, 7, 9, 0, 0, 9776, 9777, + 7, 2, 0, 0, 9777, 9778, 7, 12, 0, 0, 9778, 9779, 7, 3, 0, 0, 9779, 9780, + 7, 13, 0, 0, 9780, 9781, 7, 6, 0, 0, 9781, 1334, 1, 0, 0, 0, 9782, 9783, + 7, 2, 0, 0, 9783, 9784, 7, 20, 0, 0, 9784, 9785, 7, 6, 0, 0, 9785, 9786, + 7, 10, 0, 0, 9786, 9787, 7, 24, 0, 0, 9787, 9788, 7, 9, 0, 0, 9788, 9789, + 7, 2, 0, 0, 9789, 9790, 7, 10, 0, 0, 9790, 1336, 1, 0, 0, 0, 9791, 9792, + 7, 2, 0, 0, 9792, 9793, 7, 20, 0, 0, 9793, 9794, 7, 6, 0, 0, 9794, 9795, + 7, 10, 0, 0, 9795, 9796, 7, 25, 0, 0, 9796, 9797, 7, 12, 0, 0, 9797, 9798, + 7, 6, 0, 0, 9798, 9799, 7, 3, 0, 0, 9799, 9800, 7, 16, 0, 0, 9800, 1338, + 1, 0, 0, 0, 9801, 9802, 7, 2, 0, 0, 9802, 9803, 7, 20, 0, 0, 9803, 9804, + 7, 6, 0, 0, 9804, 9805, 7, 10, 0, 0, 9805, 9806, 7, 3, 0, 0, 9806, 9807, + 7, 2, 0, 0, 9807, 9808, 7, 7, 0, 0, 9808, 9809, 7, 9, 0, 0, 9809, 9810, + 7, 6, 0, 0, 9810, 9811, 7, 4, 0, 0, 9811, 1340, 1, 0, 0, 0, 9812, 9813, + 7, 2, 0, 0, 9813, 9814, 7, 20, 0, 0, 9814, 9815, 7, 6, 0, 0, 9815, 9816, + 7, 10, 0, 0, 9816, 9817, 7, 22, 0, 0, 9817, 9818, 7, 17, 0, 0, 9818, 9819, + 7, 11, 0, 0, 9819, 1342, 1, 0, 0, 0, 9820, 9821, 7, 2, 0, 0, 9821, 9822, + 7, 20, 0, 0, 9822, 9823, 7, 6, 0, 0, 9823, 9824, 7, 10, 0, 0, 9824, 9825, + 5, 95, 0, 0, 9825, 9826, 7, 6, 0, 0, 9826, 9827, 7, 22, 0, 0, 9827, 9828, + 7, 8, 0, 0, 9828, 9829, 7, 9, 0, 0, 9829, 9830, 7, 4, 0, 0, 9830, 9831, + 7, 8, 0, 0, 9831, 9832, 7, 10, 0, 0, 9832, 9833, 7, 18, 0, 0, 9833, 1344, + 1, 0, 0, 0, 9834, 9835, 7, 2, 0, 0, 9835, 9836, 7, 20, 0, 0, 9836, 9837, + 7, 6, 0, 0, 9837, 9838, 7, 3, 0, 0, 9838, 9839, 7, 0, 0, 0, 9839, 9840, + 7, 4, 0, 0, 9840, 9841, 7, 8, 0, 0, 9841, 9842, 7, 2, 0, 0, 9842, 9843, + 7, 10, 0, 0, 9843, 9844, 7, 9, 0, 0, 9844, 1346, 1, 0, 0, 0, 9845, 9846, + 7, 2, 0, 0, 9846, 9847, 7, 20, 0, 0, 9847, 9848, 7, 4, 0, 0, 9848, 9849, + 7, 8, 0, 0, 9849, 9850, 7, 17, 0, 0, 9850, 9851, 7, 8, 0, 0, 9851, 9852, + 7, 9, 0, 0, 9852, 9853, 7, 4, 0, 0, 9853, 9854, 7, 8, 0, 0, 9854, 9855, + 7, 13, 0, 0, 9855, 1348, 1, 0, 0, 0, 9856, 9857, 7, 2, 0, 0, 9857, 9858, + 7, 20, 0, 0, 9858, 9859, 7, 4, 0, 0, 9859, 9860, 7, 8, 0, 0, 9860, 9861, + 7, 17, 0, 0, 9861, 9862, 7, 8, 0, 0, 9862, 9863, 7, 23, 0, 0, 9863, 9864, + 7, 6, 0, 0, 9864, 1350, 1, 0, 0, 0, 9865, 9866, 7, 2, 0, 0, 9866, 9867, + 7, 20, 0, 0, 9867, 9868, 7, 4, 0, 0, 9868, 9869, 7, 8, 0, 0, 9869, 9870, + 7, 17, 0, 0, 9870, 9871, 7, 8, 0, 0, 9871, 9872, 7, 23, 0, 0, 9872, 9873, + 7, 6, 0, 0, 9873, 9874, 5, 95, 0, 0, 9874, 9875, 7, 5, 0, 0, 9875, 9876, + 7, 2, 0, 0, 9876, 9877, 7, 3, 0, 0, 9877, 9878, 5, 95, 0, 0, 9878, 9879, + 7, 9, 0, 0, 9879, 9880, 7, 6, 0, 0, 9880, 9881, 7, 25, 0, 0, 9881, 9882, + 7, 12, 0, 0, 9882, 9883, 7, 6, 0, 0, 9883, 9884, 7, 10, 0, 0, 9884, 9885, + 7, 4, 0, 0, 9885, 9886, 7, 8, 0, 0, 9886, 9887, 7, 0, 0, 0, 9887, 9888, + 7, 11, 0, 0, 9888, 9889, 5, 95, 0, 0, 9889, 9890, 7, 21, 0, 0, 9890, 9891, + 7, 6, 0, 0, 9891, 9892, 7, 16, 0, 0, 9892, 1352, 1, 0, 0, 0, 9893, 9894, + 7, 2, 0, 0, 9894, 9895, 7, 20, 0, 0, 9895, 9896, 7, 4, 0, 0, 9896, 9897, + 7, 8, 0, 0, 9897, 9898, 7, 2, 0, 0, 9898, 9899, 7, 10, 0, 0, 9899, 1354, + 1, 0, 0, 0, 9900, 9901, 7, 2, 0, 0, 9901, 9902, 7, 3, 0, 0, 9902, 1356, + 1, 0, 0, 0, 9903, 9904, 7, 2, 0, 0, 9904, 9905, 7, 3, 0, 0, 9905, 9906, + 7, 14, 0, 0, 9906, 9907, 7, 6, 0, 0, 9907, 9908, 7, 3, 0, 0, 9908, 1358, + 1, 0, 0, 0, 9909, 9910, 7, 2, 0, 0, 9910, 9911, 7, 3, 0, 0, 9911, 9912, + 7, 8, 0, 0, 9912, 9913, 7, 18, 0, 0, 9913, 9914, 7, 8, 0, 0, 9914, 9915, + 7, 10, 0, 0, 9915, 9916, 7, 0, 0, 0, 9916, 9917, 7, 11, 0, 0, 9917, 9918, + 5, 95, 0, 0, 9918, 9919, 7, 14, 0, 0, 9919, 9920, 7, 1, 0, 0, 9920, 9921, + 5, 95, 0, 0, 9921, 9922, 7, 10, 0, 0, 9922, 9923, 7, 0, 0, 0, 9923, 9924, + 7, 17, 0, 0, 9924, 9925, 7, 6, 0, 0, 9925, 1360, 1, 0, 0, 0, 9926, 9927, + 7, 2, 0, 0, 9927, 9928, 7, 3, 0, 0, 9928, 9929, 7, 8, 0, 0, 9929, 9930, + 7, 18, 0, 0, 9930, 9931, 7, 8, 0, 0, 9931, 9932, 7, 10, 0, 0, 9932, 9933, + 7, 0, 0, 0, 9933, 9934, 7, 11, 0, 0, 9934, 9935, 5, 95, 0, 0, 9935, 9936, + 7, 11, 0, 0, 9936, 9937, 7, 2, 0, 0, 9937, 9938, 7, 18, 0, 0, 9938, 9939, + 7, 8, 0, 0, 9939, 9940, 7, 10, 0, 0, 9940, 1362, 1, 0, 0, 0, 9941, 9942, + 7, 2, 0, 0, 9942, 9943, 7, 12, 0, 0, 9943, 9944, 7, 4, 0, 0, 9944, 1364, + 1, 0, 0, 0, 9945, 9946, 7, 2, 0, 0, 9946, 9947, 7, 12, 0, 0, 9947, 9948, + 7, 4, 0, 0, 9948, 9949, 7, 6, 0, 0, 9949, 9950, 7, 3, 0, 0, 9950, 1366, + 1, 0, 0, 0, 9951, 9952, 7, 2, 0, 0, 9952, 9953, 7, 12, 0, 0, 9953, 9954, + 7, 4, 0, 0, 9954, 9955, 7, 20, 0, 0, 9955, 9956, 7, 12, 0, 0, 9956, 9957, + 7, 4, 0, 0, 9957, 1368, 1, 0, 0, 0, 9958, 9959, 7, 2, 0, 0, 9959, 9960, + 7, 15, 0, 0, 9960, 9961, 7, 6, 0, 0, 9961, 9962, 7, 3, 0, 0, 9962, 1370, + 1, 0, 0, 0, 9963, 9964, 7, 2, 0, 0, 9964, 9965, 7, 15, 0, 0, 9965, 9966, + 7, 6, 0, 0, 9966, 9967, 7, 3, 0, 0, 9967, 9968, 7, 3, 0, 0, 9968, 9969, + 7, 8, 0, 0, 9969, 9970, 7, 14, 0, 0, 9970, 9971, 7, 6, 0, 0, 9971, 1372, + 1, 0, 0, 0, 9972, 9973, 7, 2, 0, 0, 9973, 9974, 7, 7, 0, 0, 9974, 9975, + 7, 10, 0, 0, 9975, 9976, 7, 6, 0, 0, 9976, 9977, 7, 3, 0, 0, 9977, 1374, + 1, 0, 0, 0, 9978, 9979, 7, 2, 0, 0, 9979, 9980, 7, 7, 0, 0, 9980, 9981, + 7, 10, 0, 0, 9981, 9982, 7, 6, 0, 0, 9982, 9983, 7, 3, 0, 0, 9983, 9984, + 7, 9, 0, 0, 9984, 9985, 7, 19, 0, 0, 9985, 9986, 7, 8, 0, 0, 9986, 9987, + 7, 20, 0, 0, 9987, 1376, 1, 0, 0, 0, 9988, 9989, 7, 20, 0, 0, 9989, 9990, + 7, 0, 0, 0, 9990, 9991, 7, 14, 0, 0, 9991, 9992, 5, 95, 0, 0, 9992, 9993, + 7, 8, 0, 0, 9993, 9994, 7, 10, 0, 0, 9994, 9995, 7, 14, 0, 0, 9995, 9996, + 7, 6, 0, 0, 9996, 9997, 7, 22, 0, 0, 9997, 1378, 1, 0, 0, 0, 9998, 9999, + 7, 20, 0, 0, 9999, 10000, 7, 0, 0, 0, 10000, 10001, 7, 18, 0, 0, 10001, + 10002, 7, 6, 0, 0, 10002, 1380, 1, 0, 0, 0, 10003, 10004, 7, 20, 0, 0, + 10004, 10005, 7, 0, 0, 0, 10005, 10006, 7, 18, 0, 0, 10006, 10007, 7, 6, + 0, 0, 10007, 10008, 7, 13, 0, 0, 10008, 10009, 7, 2, 0, 0, 10009, 10010, + 7, 12, 0, 0, 10010, 10011, 7, 10, 0, 0, 10011, 10012, 7, 4, 0, 0, 10012, + 1382, 1, 0, 0, 0, 10013, 10014, 7, 20, 0, 0, 10014, 10015, 7, 0, 0, 0, + 10015, 10016, 7, 18, 0, 0, 10016, 10017, 7, 6, 0, 0, 10017, 10018, 5, 95, + 0, 0, 10018, 10019, 7, 15, 0, 0, 10019, 10020, 7, 6, 0, 0, 10020, 10021, + 7, 3, 0, 0, 10021, 10022, 7, 8, 0, 0, 10022, 10023, 7, 5, 0, 0, 10023, + 10024, 7, 16, 0, 0, 10024, 1384, 1, 0, 0, 0, 10025, 10026, 7, 20, 0, 0, + 10026, 10027, 7, 0, 0, 0, 10027, 10028, 7, 18, 0, 0, 10028, 10029, 7, 11, + 0, 0, 10029, 10030, 7, 2, 0, 0, 10030, 10031, 7, 13, 0, 0, 10031, 10032, + 7, 21, 0, 0, 10032, 1386, 1, 0, 0, 0, 10033, 10034, 7, 20, 0, 0, 10034, + 10035, 7, 0, 0, 0, 10035, 10036, 7, 3, 0, 0, 10036, 10037, 7, 0, 0, 0, + 10037, 10038, 7, 17, 0, 0, 10038, 10039, 7, 6, 0, 0, 10039, 10040, 7, 4, + 0, 0, 10040, 10041, 7, 6, 0, 0, 10041, 10042, 7, 3, 0, 0, 10042, 10043, + 7, 8, 0, 0, 10043, 10044, 7, 23, 0, 0, 10044, 10045, 7, 0, 0, 0, 10045, + 10046, 7, 4, 0, 0, 10046, 10047, 7, 8, 0, 0, 10047, 10048, 7, 2, 0, 0, + 10048, 10049, 7, 10, 0, 0, 10049, 1388, 1, 0, 0, 0, 10050, 10051, 7, 20, + 0, 0, 10051, 10052, 7, 0, 0, 0, 10052, 10053, 7, 3, 0, 0, 10053, 10054, + 7, 0, 0, 0, 10054, 10055, 7, 17, 0, 0, 10055, 10056, 5, 95, 0, 0, 10056, + 10057, 7, 10, 0, 0, 10057, 10058, 7, 2, 0, 0, 10058, 10059, 7, 14, 0, 0, + 10059, 10060, 7, 6, 0, 0, 10060, 1390, 1, 0, 0, 0, 10061, 10062, 7, 4, + 0, 0, 10062, 10063, 7, 3, 0, 0, 10063, 10064, 7, 16, 0, 0, 10064, 10066, + 5, 95, 0, 0, 10065, 10061, 1, 0, 0, 0, 10065, 10066, 1, 0, 0, 0, 10066, + 10067, 1, 0, 0, 0, 10067, 10068, 7, 20, 0, 0, 10068, 10069, 7, 0, 0, 0, + 10069, 10070, 7, 3, 0, 0, 10070, 10071, 7, 9, 0, 0, 10071, 10072, 7, 6, + 0, 0, 10072, 1392, 1, 0, 0, 0, 10073, 10074, 7, 20, 0, 0, 10074, 10075, + 7, 0, 0, 0, 10075, 10076, 7, 3, 0, 0, 10076, 10077, 7, 9, 0, 0, 10077, + 10078, 7, 6, 0, 0, 10078, 10079, 7, 10, 0, 0, 10079, 10080, 7, 0, 0, 0, + 10080, 10081, 7, 17, 0, 0, 10081, 10082, 7, 6, 0, 0, 10082, 1394, 1, 0, + 0, 0, 10083, 10084, 7, 20, 0, 0, 10084, 10085, 7, 0, 0, 0, 10085, 10086, + 7, 3, 0, 0, 10086, 10087, 7, 9, 0, 0, 10087, 10088, 7, 6, 0, 0, 10088, + 10089, 7, 2, 0, 0, 10089, 10090, 7, 10, 0, 0, 10090, 10091, 7, 11, 0, 0, + 10091, 10092, 7, 16, 0, 0, 10092, 1396, 1, 0, 0, 0, 10093, 10094, 7, 20, + 0, 0, 10094, 10095, 7, 0, 0, 0, 10095, 10096, 7, 3, 0, 0, 10096, 10097, + 7, 4, 0, 0, 10097, 10098, 7, 8, 0, 0, 10098, 10099, 7, 0, 0, 0, 10099, + 10100, 7, 11, 0, 0, 10100, 1398, 1, 0, 0, 0, 10101, 10102, 7, 20, 0, 0, + 10102, 10103, 7, 0, 0, 0, 10103, 10104, 7, 3, 0, 0, 10104, 10105, 7, 4, + 0, 0, 10105, 10106, 7, 8, 0, 0, 10106, 10107, 7, 4, 0, 0, 10107, 10108, + 7, 8, 0, 0, 10108, 10109, 7, 2, 0, 0, 10109, 10110, 7, 10, 0, 0, 10110, + 1400, 1, 0, 0, 0, 10111, 10112, 7, 20, 0, 0, 10112, 10113, 7, 0, 0, 0, + 10113, 10114, 7, 3, 0, 0, 10114, 10115, 7, 4, 0, 0, 10115, 10116, 7, 8, + 0, 0, 10116, 10117, 7, 4, 0, 0, 10117, 10118, 7, 8, 0, 0, 10118, 10119, + 7, 2, 0, 0, 10119, 10120, 7, 10, 0, 0, 10120, 10121, 7, 9, 0, 0, 10121, + 1402, 1, 0, 0, 0, 10122, 10123, 7, 20, 0, 0, 10123, 10124, 7, 0, 0, 0, + 10124, 10125, 7, 3, 0, 0, 10125, 10126, 7, 4, 0, 0, 10126, 10127, 7, 10, + 0, 0, 10127, 10128, 7, 6, 0, 0, 10128, 10129, 7, 3, 0, 0, 10129, 1404, + 1, 0, 0, 0, 10130, 10131, 7, 20, 0, 0, 10131, 10132, 7, 0, 0, 0, 10132, + 10133, 7, 9, 0, 0, 10133, 10134, 7, 9, 0, 0, 10134, 10135, 7, 7, 0, 0, + 10135, 10136, 7, 2, 0, 0, 10136, 10137, 7, 3, 0, 0, 10137, 10138, 7, 14, + 0, 0, 10138, 1406, 1, 0, 0, 0, 10139, 10140, 7, 20, 0, 0, 10140, 10141, + 7, 0, 0, 0, 10141, 10142, 7, 4, 0, 0, 10142, 10143, 7, 19, 0, 0, 10143, + 1408, 1, 0, 0, 0, 10144, 10145, 7, 20, 0, 0, 10145, 10146, 7, 0, 0, 0, + 10146, 10147, 7, 4, 0, 0, 10147, 10148, 7, 8, 0, 0, 10148, 10149, 7, 10, + 0, 0, 10149, 10150, 7, 14, 0, 0, 10150, 10151, 7, 6, 0, 0, 10151, 10152, + 7, 22, 0, 0, 10152, 1410, 1, 0, 0, 0, 10153, 10154, 7, 20, 0, 0, 10154, + 10155, 7, 0, 0, 0, 10155, 10156, 7, 12, 0, 0, 10156, 10157, 7, 9, 0, 0, + 10157, 10158, 7, 6, 0, 0, 10158, 1412, 1, 0, 0, 0, 10159, 10160, 7, 20, + 0, 0, 10160, 10161, 7, 14, 0, 0, 10161, 10162, 7, 7, 0, 0, 10162, 10163, + 5, 95, 0, 0, 10163, 10164, 7, 9, 0, 0, 10164, 10165, 7, 19, 0, 0, 10165, + 10166, 7, 2, 0, 0, 10166, 10167, 7, 7, 0, 0, 10167, 10168, 7, 9, 0, 0, + 10168, 10169, 7, 20, 0, 0, 10169, 10170, 7, 0, 0, 0, 10170, 10171, 7, 13, + 0, 0, 10171, 10172, 7, 6, 0, 0, 10172, 10173, 7, 12, 0, 0, 10173, 10174, + 7, 9, 0, 0, 10174, 10175, 7, 6, 0, 0, 10175, 10176, 7, 14, 0, 0, 10176, + 1414, 1, 0, 0, 0, 10177, 10178, 7, 20, 0, 0, 10178, 10179, 7, 6, 0, 0, + 10179, 10180, 7, 3, 0, 0, 10180, 10181, 7, 13, 0, 0, 10181, 10182, 7, 6, + 0, 0, 10182, 10183, 7, 10, 0, 0, 10183, 10184, 7, 4, 0, 0, 10184, 1416, + 1, 0, 0, 0, 10185, 10186, 7, 20, 0, 0, 10186, 10187, 7, 6, 0, 0, 10187, + 10188, 7, 3, 0, 0, 10188, 10189, 7, 13, 0, 0, 10189, 10190, 7, 6, 0, 0, + 10190, 10191, 7, 10, 0, 0, 10191, 10192, 7, 4, 0, 0, 10192, 10193, 7, 8, + 0, 0, 10193, 10194, 7, 11, 0, 0, 10194, 10195, 7, 6, 0, 0, 10195, 10196, + 5, 95, 0, 0, 10196, 10197, 7, 13, 0, 0, 10197, 10198, 7, 2, 0, 0, 10198, + 10199, 7, 10, 0, 0, 10199, 10200, 7, 4, 0, 0, 10200, 1418, 1, 0, 0, 0, + 10201, 10202, 7, 20, 0, 0, 10202, 10203, 7, 6, 0, 0, 10203, 10204, 7, 3, + 0, 0, 10204, 10205, 7, 13, 0, 0, 10205, 10206, 7, 6, 0, 0, 10206, 10207, + 7, 10, 0, 0, 10207, 10208, 7, 4, 0, 0, 10208, 10209, 7, 8, 0, 0, 10209, + 10210, 7, 11, 0, 0, 10210, 10211, 7, 6, 0, 0, 10211, 10212, 5, 95, 0, 0, + 10212, 10213, 7, 14, 0, 0, 10213, 10214, 7, 8, 0, 0, 10214, 10215, 7, 9, + 0, 0, 10215, 10216, 7, 13, 0, 0, 10216, 1420, 1, 0, 0, 0, 10217, 10218, + 7, 20, 0, 0, 10218, 10219, 7, 6, 0, 0, 10219, 10220, 7, 3, 0, 0, 10220, + 10221, 7, 13, 0, 0, 10221, 10222, 7, 6, 0, 0, 10222, 10223, 7, 10, 0, 0, + 10223, 10224, 7, 4, 0, 0, 10224, 10225, 5, 95, 0, 0, 10225, 10226, 7, 3, + 0, 0, 10226, 10227, 7, 0, 0, 0, 10227, 10228, 7, 10, 0, 0, 10228, 10229, + 7, 21, 0, 0, 10229, 1422, 1, 0, 0, 0, 10230, 10231, 7, 20, 0, 0, 10231, + 10232, 7, 6, 0, 0, 10232, 10233, 7, 3, 0, 0, 10233, 10234, 7, 17, 0, 0, + 10234, 10235, 7, 8, 0, 0, 10235, 10236, 7, 9, 0, 0, 10236, 10237, 7, 9, + 0, 0, 10237, 10238, 7, 8, 0, 0, 10238, 10239, 7, 2, 0, 0, 10239, 10240, + 7, 10, 0, 0, 10240, 10241, 7, 9, 0, 0, 10241, 1424, 1, 0, 0, 0, 10242, + 10243, 7, 20, 0, 0, 10243, 10244, 7, 6, 0, 0, 10244, 10245, 7, 3, 0, 0, + 10245, 10246, 7, 17, 0, 0, 10246, 10247, 7, 8, 0, 0, 10247, 10248, 7, 9, + 0, 0, 10248, 10249, 7, 9, 0, 0, 10249, 10250, 7, 8, 0, 0, 10250, 10251, + 7, 2, 0, 0, 10251, 10252, 7, 10, 0, 0, 10252, 10253, 5, 95, 0, 0, 10253, + 10254, 7, 9, 0, 0, 10254, 10255, 7, 6, 0, 0, 10255, 10256, 7, 4, 0, 0, + 10256, 1426, 1, 0, 0, 0, 10257, 10258, 7, 20, 0, 0, 10258, 10259, 7, 6, + 0, 0, 10259, 10260, 7, 3, 0, 0, 10260, 10261, 7, 9, 0, 0, 10261, 10262, + 7, 8, 0, 0, 10262, 10263, 7, 9, 0, 0, 10263, 10264, 7, 4, 0, 0, 10264, + 10265, 7, 6, 0, 0, 10265, 10266, 7, 14, 0, 0, 10266, 1428, 1, 0, 0, 0, + 10267, 10268, 7, 20, 0, 0, 10268, 10269, 7, 6, 0, 0, 10269, 10270, 7, 3, + 0, 0, 10270, 10271, 7, 9, 0, 0, 10271, 10272, 7, 8, 0, 0, 10272, 10273, + 7, 9, 0, 0, 10273, 10274, 7, 4, 0, 0, 10274, 10275, 5, 95, 0, 0, 10275, + 10276, 7, 9, 0, 0, 10276, 10277, 7, 0, 0, 0, 10277, 10278, 7, 17, 0, 0, + 10278, 10279, 7, 20, 0, 0, 10279, 10280, 7, 11, 0, 0, 10280, 10281, 7, + 6, 0, 0, 10281, 10282, 5, 95, 0, 0, 10282, 10283, 7, 20, 0, 0, 10283, 10284, + 7, 6, 0, 0, 10284, 10285, 7, 3, 0, 0, 10285, 10286, 7, 13, 0, 0, 10286, + 10287, 7, 6, 0, 0, 10287, 10288, 7, 10, 0, 0, 10288, 10289, 7, 4, 0, 0, + 10289, 1430, 1, 0, 0, 0, 10290, 10291, 7, 20, 0, 0, 10291, 10292, 7, 6, + 0, 0, 10292, 10293, 7, 3, 0, 0, 10293, 10294, 5, 95, 0, 0, 10294, 10295, + 7, 13, 0, 0, 10295, 10296, 7, 20, 0, 0, 10296, 10297, 7, 12, 0, 0, 10297, + 1432, 1, 0, 0, 0, 10298, 10299, 7, 20, 0, 0, 10299, 10300, 7, 6, 0, 0, + 10300, 10301, 7, 3, 0, 0, 10301, 10302, 5, 95, 0, 0, 10302, 10303, 7, 14, + 0, 0, 10303, 10304, 7, 1, 0, 0, 10304, 1434, 1, 0, 0, 0, 10305, 10306, + 7, 20, 0, 0, 10306, 10307, 7, 6, 0, 0, 10307, 10308, 7, 3, 0, 0, 10308, + 10309, 5, 95, 0, 0, 10309, 10310, 7, 10, 0, 0, 10310, 10311, 7, 2, 0, 0, + 10311, 10312, 7, 14, 0, 0, 10312, 10313, 7, 6, 0, 0, 10313, 1436, 1, 0, + 0, 0, 10314, 10315, 7, 20, 0, 0, 10315, 10316, 7, 19, 0, 0, 10316, 10317, + 7, 16, 0, 0, 10317, 10318, 7, 9, 0, 0, 10318, 10319, 7, 8, 0, 0, 10319, + 10320, 7, 13, 0, 0, 10320, 10321, 7, 0, 0, 0, 10321, 10322, 7, 11, 0, 0, + 10322, 10323, 5, 95, 0, 0, 10323, 10324, 7, 2, 0, 0, 10324, 10325, 7, 10, + 0, 0, 10325, 10326, 7, 11, 0, 0, 10326, 10327, 7, 16, 0, 0, 10327, 1438, + 1, 0, 0, 0, 10328, 10329, 7, 20, 0, 0, 10329, 10330, 7, 8, 0, 0, 10330, + 10331, 7, 15, 0, 0, 10331, 10332, 7, 2, 0, 0, 10332, 10333, 7, 4, 0, 0, + 10333, 1440, 1, 0, 0, 0, 10334, 10335, 7, 20, 0, 0, 10335, 10336, 7, 11, + 0, 0, 10336, 10337, 7, 0, 0, 0, 10337, 10338, 7, 10, 0, 0, 10338, 1442, + 1, 0, 0, 0, 10339, 10340, 7, 20, 0, 0, 10340, 10341, 7, 11, 0, 0, 10341, + 10342, 7, 0, 0, 0, 10342, 10343, 7, 4, 0, 0, 10343, 10344, 7, 5, 0, 0, + 10344, 10345, 7, 2, 0, 0, 10345, 10346, 7, 3, 0, 0, 10346, 10347, 7, 17, + 0, 0, 10347, 1444, 1, 0, 0, 0, 10348, 10349, 7, 20, 0, 0, 10349, 10350, + 7, 2, 0, 0, 10350, 10351, 7, 8, 0, 0, 10351, 10352, 7, 9, 0, 0, 10352, + 10353, 7, 2, 0, 0, 10353, 10354, 7, 10, 0, 0, 10354, 10355, 5, 95, 0, 0, + 10355, 10356, 7, 17, 0, 0, 10356, 10357, 7, 6, 0, 0, 10357, 10358, 7, 9, + 0, 0, 10358, 10359, 7, 9, 0, 0, 10359, 10360, 7, 0, 0, 0, 10360, 10361, + 7, 18, 0, 0, 10361, 10362, 7, 6, 0, 0, 10362, 10363, 5, 95, 0, 0, 10363, + 10364, 7, 19, 0, 0, 10364, 10365, 7, 0, 0, 0, 10365, 10366, 7, 10, 0, 0, + 10366, 10367, 7, 14, 0, 0, 10367, 10368, 7, 11, 0, 0, 10368, 10369, 7, + 8, 0, 0, 10369, 10370, 7, 10, 0, 0, 10370, 10371, 7, 18, 0, 0, 10371, 1446, + 1, 0, 0, 0, 10372, 10373, 7, 20, 0, 0, 10373, 10374, 7, 2, 0, 0, 10374, + 10375, 7, 11, 0, 0, 10375, 10376, 7, 8, 0, 0, 10376, 10377, 7, 13, 0, 0, + 10377, 10378, 7, 16, 0, 0, 10378, 1448, 1, 0, 0, 0, 10379, 10380, 7, 20, + 0, 0, 10380, 10381, 7, 2, 0, 0, 10381, 10382, 7, 2, 0, 0, 10382, 10383, + 7, 11, 0, 0, 10383, 1450, 1, 0, 0, 0, 10384, 10385, 7, 20, 0, 0, 10385, + 10386, 7, 2, 0, 0, 10386, 10387, 7, 3, 0, 0, 10387, 10388, 7, 4, 0, 0, + 10388, 1452, 1, 0, 0, 0, 10389, 10390, 7, 20, 0, 0, 10390, 10391, 7, 3, + 0, 0, 10391, 10392, 7, 6, 0, 0, 10392, 10393, 7, 13, 0, 0, 10393, 10394, + 7, 6, 0, 0, 10394, 10395, 7, 14, 0, 0, 10395, 10396, 7, 8, 0, 0, 10396, + 10397, 7, 10, 0, 0, 10397, 10398, 7, 18, 0, 0, 10398, 1454, 1, 0, 0, 0, + 10399, 10400, 7, 20, 0, 0, 10400, 10401, 7, 3, 0, 0, 10401, 10402, 7, 6, + 0, 0, 10402, 10403, 7, 13, 0, 0, 10403, 10404, 7, 8, 0, 0, 10404, 10405, + 7, 9, 0, 0, 10405, 10406, 7, 8, 0, 0, 10406, 10407, 7, 2, 0, 0, 10407, + 10408, 7, 10, 0, 0, 10408, 1456, 1, 0, 0, 0, 10409, 10410, 7, 20, 0, 0, + 10410, 10411, 7, 3, 0, 0, 10411, 10412, 7, 6, 0, 0, 10412, 10413, 7, 14, + 0, 0, 10413, 10414, 7, 8, 0, 0, 10414, 10415, 7, 13, 0, 0, 10415, 10416, + 7, 0, 0, 0, 10416, 10417, 7, 4, 0, 0, 10417, 10418, 7, 6, 0, 0, 10418, + 1458, 1, 0, 0, 0, 10419, 10420, 7, 20, 0, 0, 10420, 10421, 7, 3, 0, 0, + 10421, 10422, 7, 8, 0, 0, 10422, 10423, 7, 17, 0, 0, 10423, 10424, 7, 0, + 0, 0, 10424, 10425, 7, 3, 0, 0, 10425, 10426, 7, 16, 0, 0, 10426, 1460, + 1, 0, 0, 0, 10427, 10428, 7, 20, 0, 0, 10428, 10429, 7, 3, 0, 0, 10429, + 10430, 7, 8, 0, 0, 10430, 10431, 7, 17, 0, 0, 10431, 10432, 7, 0, 0, 0, + 10432, 10433, 7, 3, 0, 0, 10433, 10434, 7, 16, 0, 0, 10434, 10435, 5, 95, + 0, 0, 10435, 10436, 7, 3, 0, 0, 10436, 10437, 7, 2, 0, 0, 10437, 10438, + 7, 11, 0, 0, 10438, 10439, 7, 6, 0, 0, 10439, 1462, 1, 0, 0, 0, 10440, + 10441, 7, 20, 0, 0, 10441, 10442, 7, 3, 0, 0, 10442, 10443, 7, 8, 0, 0, + 10443, 10444, 7, 10, 0, 0, 10444, 10445, 7, 4, 0, 0, 10445, 1464, 1, 0, + 0, 0, 10446, 10447, 7, 20, 0, 0, 10447, 10448, 7, 3, 0, 0, 10448, 10449, + 7, 8, 0, 0, 10449, 10450, 7, 2, 0, 0, 10450, 10451, 7, 3, 0, 0, 10451, + 1466, 1, 0, 0, 0, 10452, 10453, 7, 20, 0, 0, 10453, 10454, 7, 3, 0, 0, + 10454, 10455, 7, 8, 0, 0, 10455, 10456, 7, 2, 0, 0, 10456, 10457, 7, 3, + 0, 0, 10457, 10458, 7, 8, 0, 0, 10458, 10459, 7, 4, 0, 0, 10459, 10460, + 7, 16, 0, 0, 10460, 1468, 1, 0, 0, 0, 10461, 10462, 7, 20, 0, 0, 10462, + 10463, 7, 3, 0, 0, 10463, 10464, 7, 8, 0, 0, 10464, 10465, 7, 2, 0, 0, + 10465, 10466, 7, 3, 0, 0, 10466, 10467, 7, 8, 0, 0, 10467, 10468, 7, 4, + 0, 0, 10468, 10469, 7, 16, 0, 0, 10469, 10470, 5, 95, 0, 0, 10470, 10471, + 7, 11, 0, 0, 10471, 10472, 7, 6, 0, 0, 10472, 10473, 7, 15, 0, 0, 10473, + 10474, 7, 6, 0, 0, 10474, 10475, 7, 11, 0, 0, 10475, 1470, 1, 0, 0, 0, + 10476, 10477, 7, 20, 0, 0, 10477, 10478, 7, 3, 0, 0, 10478, 10479, 7, 8, + 0, 0, 10479, 10480, 7, 15, 0, 0, 10480, 10481, 7, 0, 0, 0, 10481, 10482, + 7, 4, 0, 0, 10482, 10483, 7, 6, 0, 0, 10483, 1472, 1, 0, 0, 0, 10484, 10485, + 7, 20, 0, 0, 10485, 10486, 7, 3, 0, 0, 10486, 10487, 7, 8, 0, 0, 10487, + 10488, 7, 15, 0, 0, 10488, 10489, 7, 0, 0, 0, 10489, 10490, 7, 4, 0, 0, + 10490, 10491, 7, 6, 0, 0, 10491, 10492, 5, 95, 0, 0, 10492, 10493, 7, 21, + 0, 0, 10493, 10494, 7, 6, 0, 0, 10494, 10495, 7, 16, 0, 0, 10495, 1474, + 1, 0, 0, 0, 10496, 10497, 7, 20, 0, 0, 10497, 10498, 7, 3, 0, 0, 10498, + 10499, 7, 8, 0, 0, 10499, 10500, 7, 15, 0, 0, 10500, 10501, 7, 8, 0, 0, + 10501, 10502, 7, 11, 0, 0, 10502, 10503, 7, 6, 0, 0, 10503, 10504, 7, 18, + 0, 0, 10504, 10505, 7, 6, 0, 0, 10505, 10506, 7, 9, 0, 0, 10506, 1476, + 1, 0, 0, 0, 10507, 10508, 7, 20, 0, 0, 10508, 10509, 7, 3, 0, 0, 10509, + 10510, 7, 2, 0, 0, 10510, 10511, 7, 13, 0, 0, 10511, 1478, 1, 0, 0, 0, + 10512, 10513, 7, 20, 0, 0, 10513, 10514, 7, 3, 0, 0, 10514, 10515, 7, 2, + 0, 0, 10515, 10516, 7, 13, 0, 0, 10516, 10517, 7, 13, 0, 0, 10517, 10518, + 7, 0, 0, 0, 10518, 10519, 7, 13, 0, 0, 10519, 10520, 7, 19, 0, 0, 10520, + 10521, 7, 6, 0, 0, 10521, 1480, 1, 0, 0, 0, 10522, 10523, 7, 20, 0, 0, + 10523, 10524, 7, 3, 0, 0, 10524, 10525, 7, 2, 0, 0, 10525, 10526, 7, 13, + 0, 0, 10526, 10527, 7, 6, 0, 0, 10527, 10528, 7, 14, 0, 0, 10528, 10529, + 7, 12, 0, 0, 10529, 10530, 7, 3, 0, 0, 10530, 10531, 7, 6, 0, 0, 10531, + 1482, 1, 0, 0, 0, 10532, 10533, 7, 20, 0, 0, 10533, 10534, 7, 3, 0, 0, + 10534, 10535, 7, 2, 0, 0, 10535, 10536, 7, 13, 0, 0, 10536, 10537, 7, 6, + 0, 0, 10537, 10538, 7, 14, 0, 0, 10538, 10539, 7, 12, 0, 0, 10539, 10540, + 7, 3, 0, 0, 10540, 10541, 7, 6, 0, 0, 10541, 10542, 5, 95, 0, 0, 10542, + 10543, 7, 10, 0, 0, 10543, 10544, 7, 0, 0, 0, 10544, 10545, 7, 17, 0, 0, + 10545, 10546, 7, 6, 0, 0, 10546, 1484, 1, 0, 0, 0, 10547, 10548, 7, 20, + 0, 0, 10548, 10549, 7, 3, 0, 0, 10549, 10550, 7, 2, 0, 0, 10550, 10551, + 7, 13, 0, 0, 10551, 10552, 7, 6, 0, 0, 10552, 10553, 7, 9, 0, 0, 10553, + 10554, 7, 9, 0, 0, 10554, 1486, 1, 0, 0, 0, 10555, 10556, 7, 20, 0, 0, + 10556, 10557, 7, 3, 0, 0, 10557, 10558, 7, 2, 0, 0, 10558, 10559, 7, 5, + 0, 0, 10559, 10560, 7, 8, 0, 0, 10560, 10561, 7, 11, 0, 0, 10561, 10562, + 7, 6, 0, 0, 10562, 1488, 1, 0, 0, 0, 10563, 10564, 7, 20, 0, 0, 10564, + 10565, 7, 3, 0, 0, 10565, 10566, 7, 2, 0, 0, 10566, 10567, 7, 20, 0, 0, + 10567, 10568, 7, 6, 0, 0, 10568, 10569, 7, 3, 0, 0, 10569, 10570, 7, 4, + 0, 0, 10570, 10571, 7, 16, 0, 0, 10571, 1490, 1, 0, 0, 0, 10572, 10573, + 7, 20, 0, 0, 10573, 10574, 7, 3, 0, 0, 10574, 10575, 7, 2, 0, 0, 10575, + 10576, 7, 15, 0, 0, 10576, 10577, 7, 8, 0, 0, 10577, 10578, 7, 14, 0, 0, + 10578, 10579, 7, 6, 0, 0, 10579, 10580, 7, 3, 0, 0, 10580, 1492, 1, 0, + 0, 0, 10581, 10582, 7, 20, 0, 0, 10582, 10583, 7, 3, 0, 0, 10583, 10584, + 7, 2, 0, 0, 10584, 10585, 7, 15, 0, 0, 10585, 10586, 7, 8, 0, 0, 10586, + 10587, 7, 14, 0, 0, 10587, 10588, 7, 6, 0, 0, 10588, 10589, 7, 3, 0, 0, + 10589, 10590, 5, 95, 0, 0, 10590, 10591, 7, 21, 0, 0, 10591, 10592, 7, + 6, 0, 0, 10592, 10593, 7, 16, 0, 0, 10593, 10594, 5, 95, 0, 0, 10594, 10595, + 7, 10, 0, 0, 10595, 10596, 7, 0, 0, 0, 10596, 10597, 7, 17, 0, 0, 10597, + 10598, 7, 6, 0, 0, 10598, 1494, 1, 0, 0, 0, 10599, 10600, 7, 20, 0, 0, + 10600, 10601, 7, 12, 0, 0, 10601, 10602, 7, 1, 0, 0, 10602, 10603, 7, 11, + 0, 0, 10603, 10604, 7, 8, 0, 0, 10604, 10605, 7, 13, 0, 0, 10605, 1496, + 1, 0, 0, 0, 10606, 10607, 7, 20, 0, 0, 10607, 10608, 7, 7, 0, 0, 10608, + 10609, 7, 14, 0, 0, 10609, 10610, 7, 13, 0, 0, 10610, 10611, 7, 2, 0, 0, + 10611, 10612, 7, 17, 0, 0, 10612, 10613, 7, 20, 0, 0, 10613, 10614, 7, + 0, 0, 0, 10614, 10615, 7, 3, 0, 0, 10615, 10616, 7, 6, 0, 0, 10616, 1498, + 1, 0, 0, 0, 10617, 10618, 7, 20, 0, 0, 10618, 10619, 7, 7, 0, 0, 10619, + 10620, 7, 14, 0, 0, 10620, 10621, 7, 6, 0, 0, 10621, 10622, 7, 10, 0, 0, + 10622, 10623, 7, 13, 0, 0, 10623, 10624, 7, 3, 0, 0, 10624, 10625, 7, 16, + 0, 0, 10625, 10626, 7, 20, 0, 0, 10626, 10627, 7, 4, 0, 0, 10627, 1500, + 1, 0, 0, 0, 10628, 10629, 7, 20, 0, 0, 10629, 10630, 7, 16, 0, 0, 10630, + 10631, 7, 4, 0, 0, 10631, 10632, 7, 19, 0, 0, 10632, 10633, 7, 2, 0, 0, + 10633, 10634, 7, 10, 0, 0, 10634, 1502, 1, 0, 0, 0, 10635, 10636, 7, 25, + 0, 0, 10636, 10637, 7, 12, 0, 0, 10637, 10638, 7, 6, 0, 0, 10638, 10639, + 7, 3, 0, 0, 10639, 10640, 7, 16, 0, 0, 10640, 1504, 1, 0, 0, 0, 10641, + 10642, 5, 91, 0, 0, 10642, 10643, 7, 25, 0, 0, 10643, 10644, 7, 12, 0, + 0, 10644, 10645, 7, 6, 0, 0, 10645, 10646, 7, 3, 0, 0, 10646, 10647, 7, + 16, 0, 0, 10647, 10648, 5, 93, 0, 0, 10648, 1506, 1, 0, 0, 0, 10649, 10650, + 7, 25, 0, 0, 10650, 10651, 7, 12, 0, 0, 10651, 10652, 7, 6, 0, 0, 10652, + 10653, 7, 12, 0, 0, 10653, 10654, 7, 6, 0, 0, 10654, 1508, 1, 0, 0, 0, + 10655, 10656, 7, 25, 0, 0, 10656, 10657, 7, 12, 0, 0, 10657, 10658, 7, + 6, 0, 0, 10658, 10659, 7, 12, 0, 0, 10659, 10660, 7, 6, 0, 0, 10660, 10661, + 5, 95, 0, 0, 10661, 10662, 7, 14, 0, 0, 10662, 10663, 7, 6, 0, 0, 10663, + 10664, 7, 11, 0, 0, 10664, 10665, 7, 0, 0, 0, 10665, 10666, 7, 16, 0, 0, + 10666, 1510, 1, 0, 0, 0, 10667, 10668, 7, 25, 0, 0, 10668, 10669, 7, 12, + 0, 0, 10669, 10670, 7, 2, 0, 0, 10670, 10671, 7, 4, 0, 0, 10671, 10672, + 7, 6, 0, 0, 10672, 10673, 7, 14, 0, 0, 10673, 10674, 5, 95, 0, 0, 10674, + 10675, 7, 8, 0, 0, 10675, 10676, 7, 14, 0, 0, 10676, 10677, 7, 6, 0, 0, + 10677, 10678, 7, 10, 0, 0, 10678, 10679, 7, 4, 0, 0, 10679, 10680, 7, 8, + 0, 0, 10680, 10681, 7, 5, 0, 0, 10681, 10682, 7, 8, 0, 0, 10682, 10683, + 7, 6, 0, 0, 10683, 10684, 7, 3, 0, 0, 10684, 1512, 1, 0, 0, 0, 10685, 10686, + 7, 25, 0, 0, 10686, 10687, 7, 12, 0, 0, 10687, 10688, 7, 2, 0, 0, 10688, + 10689, 7, 4, 0, 0, 10689, 10690, 7, 6, 0, 0, 10690, 10691, 7, 10, 0, 0, + 10691, 10692, 7, 0, 0, 0, 10692, 10693, 7, 17, 0, 0, 10693, 10694, 7, 6, + 0, 0, 10694, 1514, 1, 0, 0, 0, 10695, 10696, 7, 3, 0, 0, 10696, 1516, 1, + 0, 0, 0, 10697, 10698, 7, 3, 0, 0, 10698, 10699, 7, 0, 0, 0, 10699, 10700, + 7, 8, 0, 0, 10700, 10701, 7, 9, 0, 0, 10701, 10702, 7, 6, 0, 0, 10702, + 10703, 7, 3, 0, 0, 10703, 10704, 7, 3, 0, 0, 10704, 10705, 7, 2, 0, 0, + 10705, 10706, 7, 3, 0, 0, 10706, 1518, 1, 0, 0, 0, 10707, 10708, 7, 3, + 0, 0, 10708, 10709, 7, 0, 0, 0, 10709, 10710, 7, 10, 0, 0, 10710, 10711, + 7, 14, 0, 0, 10711, 10712, 7, 2, 0, 0, 10712, 10713, 7, 17, 0, 0, 10713, + 10714, 7, 8, 0, 0, 10714, 10715, 7, 23, 0, 0, 10715, 10716, 7, 6, 0, 0, + 10716, 10717, 7, 14, 0, 0, 10717, 1520, 1, 0, 0, 0, 10718, 10719, 7, 3, + 0, 0, 10719, 10720, 7, 0, 0, 0, 10720, 10721, 7, 10, 0, 0, 10721, 10722, + 7, 18, 0, 0, 10722, 10723, 7, 6, 0, 0, 10723, 1522, 1, 0, 0, 0, 10724, + 10725, 7, 3, 0, 0, 10725, 10726, 7, 0, 0, 0, 10726, 10727, 7, 10, 0, 0, + 10727, 10728, 7, 21, 0, 0, 10728, 1524, 1, 0, 0, 0, 10729, 10730, 7, 3, + 0, 0, 10730, 10731, 7, 0, 0, 0, 10731, 10732, 7, 7, 0, 0, 10732, 1526, + 1, 0, 0, 0, 10733, 10734, 7, 3, 0, 0, 10734, 10735, 7, 13, 0, 0, 10735, + 10736, 5, 50, 0, 0, 10736, 1528, 1, 0, 0, 0, 10737, 10738, 7, 3, 0, 0, + 10738, 10739, 7, 13, 0, 0, 10739, 10740, 5, 52, 0, 0, 10740, 1530, 1, 0, + 0, 0, 10741, 10742, 7, 3, 0, 0, 10742, 10743, 7, 13, 0, 0, 10743, 10744, + 5, 52, 0, 0, 10744, 10745, 5, 95, 0, 0, 10745, 10746, 5, 49, 0, 0, 10746, + 10747, 5, 50, 0, 0, 10747, 10748, 5, 56, 0, 0, 10748, 1532, 1, 0, 0, 0, + 10749, 10750, 7, 3, 0, 0, 10750, 10751, 7, 6, 0, 0, 10751, 10752, 7, 0, + 0, 0, 10752, 10753, 7, 14, 0, 0, 10753, 1534, 1, 0, 0, 0, 10754, 10755, + 7, 3, 0, 0, 10755, 10756, 7, 6, 0, 0, 10756, 10757, 7, 0, 0, 0, 10757, + 10758, 7, 14, 0, 0, 10758, 10759, 7, 13, 0, 0, 10759, 10760, 7, 2, 0, 0, + 10760, 10761, 7, 17, 0, 0, 10761, 10762, 7, 17, 0, 0, 10762, 10763, 7, + 8, 0, 0, 10763, 10764, 7, 4, 0, 0, 10764, 10765, 7, 4, 0, 0, 10765, 10766, + 7, 6, 0, 0, 10766, 10767, 7, 14, 0, 0, 10767, 1536, 1, 0, 0, 0, 10768, + 10769, 7, 3, 0, 0, 10769, 10770, 7, 6, 0, 0, 10770, 10771, 7, 0, 0, 0, + 10771, 10772, 7, 14, 0, 0, 10772, 10773, 7, 13, 0, 0, 10773, 10774, 7, + 2, 0, 0, 10774, 10775, 7, 17, 0, 0, 10775, 10776, 7, 17, 0, 0, 10776, 10777, + 7, 8, 0, 0, 10777, 10778, 7, 4, 0, 0, 10778, 10779, 7, 4, 0, 0, 10779, + 10780, 7, 6, 0, 0, 10780, 10781, 7, 14, 0, 0, 10781, 10782, 7, 11, 0, 0, + 10782, 10783, 7, 2, 0, 0, 10783, 10784, 7, 13, 0, 0, 10784, 10785, 7, 21, + 0, 0, 10785, 1538, 1, 0, 0, 0, 10786, 10787, 7, 3, 0, 0, 10787, 10788, + 7, 6, 0, 0, 10788, 10789, 7, 0, 0, 0, 10789, 10790, 7, 14, 0, 0, 10790, + 10791, 7, 2, 0, 0, 10791, 10792, 7, 10, 0, 0, 10792, 10793, 7, 11, 0, 0, + 10793, 10794, 7, 16, 0, 0, 10794, 1540, 1, 0, 0, 0, 10795, 10796, 7, 3, + 0, 0, 10796, 10797, 7, 6, 0, 0, 10797, 10798, 7, 0, 0, 0, 10798, 10799, + 7, 14, 0, 0, 10799, 10800, 7, 20, 0, 0, 10800, 10801, 7, 0, 0, 0, 10801, + 10802, 7, 9, 0, 0, 10802, 10803, 7, 4, 0, 0, 10803, 1542, 1, 0, 0, 0, 10804, + 10805, 7, 3, 0, 0, 10805, 10806, 7, 6, 0, 0, 10806, 10807, 7, 0, 0, 0, + 10807, 10808, 7, 14, 0, 0, 10808, 10809, 7, 4, 0, 0, 10809, 10810, 7, 6, + 0, 0, 10810, 10811, 7, 22, 0, 0, 10811, 10812, 7, 4, 0, 0, 10812, 1544, + 1, 0, 0, 0, 10813, 10814, 7, 3, 0, 0, 10814, 10815, 7, 6, 0, 0, 10815, + 10816, 7, 0, 0, 0, 10816, 10817, 7, 14, 0, 0, 10817, 10818, 7, 12, 0, 0, + 10818, 10819, 7, 10, 0, 0, 10819, 10820, 7, 13, 0, 0, 10820, 10821, 7, + 2, 0, 0, 10821, 10822, 7, 17, 0, 0, 10822, 10823, 7, 17, 0, 0, 10823, 10824, + 7, 8, 0, 0, 10824, 10825, 7, 4, 0, 0, 10825, 10826, 7, 4, 0, 0, 10826, + 10827, 7, 6, 0, 0, 10827, 10828, 7, 14, 0, 0, 10828, 1546, 1, 0, 0, 0, + 10829, 10830, 7, 3, 0, 0, 10830, 10831, 7, 6, 0, 0, 10831, 10832, 7, 0, + 0, 0, 10832, 10833, 7, 14, 0, 0, 10833, 10834, 7, 7, 0, 0, 10834, 10835, + 7, 3, 0, 0, 10835, 10836, 7, 8, 0, 0, 10836, 10837, 7, 4, 0, 0, 10837, + 10838, 7, 6, 0, 0, 10838, 1548, 1, 0, 0, 0, 10839, 10840, 7, 3, 0, 0, 10840, + 10841, 7, 6, 0, 0, 10841, 10842, 7, 0, 0, 0, 10842, 10843, 7, 14, 0, 0, + 10843, 10844, 5, 95, 0, 0, 10844, 10845, 7, 13, 0, 0, 10845, 10846, 7, + 2, 0, 0, 10846, 10847, 7, 17, 0, 0, 10847, 10848, 7, 17, 0, 0, 10848, 10849, + 7, 8, 0, 0, 10849, 10850, 7, 4, 0, 0, 10850, 10851, 7, 4, 0, 0, 10851, + 10852, 7, 6, 0, 0, 10852, 10853, 7, 14, 0, 0, 10853, 10854, 5, 95, 0, 0, + 10854, 10855, 7, 9, 0, 0, 10855, 10856, 7, 10, 0, 0, 10856, 10857, 7, 0, + 0, 0, 10857, 10858, 7, 20, 0, 0, 10858, 10859, 7, 9, 0, 0, 10859, 10860, + 7, 19, 0, 0, 10860, 10861, 7, 2, 0, 0, 10861, 10862, 7, 4, 0, 0, 10862, + 1550, 1, 0, 0, 0, 10863, 10864, 7, 3, 0, 0, 10864, 10865, 7, 6, 0, 0, 10865, + 10866, 7, 0, 0, 0, 10866, 10867, 7, 14, 0, 0, 10867, 10868, 5, 95, 0, 0, + 10868, 10869, 7, 2, 0, 0, 10869, 10870, 7, 10, 0, 0, 10870, 10871, 7, 11, + 0, 0, 10871, 10872, 7, 16, 0, 0, 10872, 1552, 1, 0, 0, 0, 10873, 10874, + 7, 3, 0, 0, 10874, 10875, 7, 6, 0, 0, 10875, 10876, 7, 0, 0, 0, 10876, + 10877, 7, 14, 0, 0, 10877, 10878, 5, 95, 0, 0, 10878, 10879, 7, 2, 0, 0, + 10879, 10880, 7, 10, 0, 0, 10880, 10881, 7, 11, 0, 0, 10881, 10882, 7, + 16, 0, 0, 10882, 10883, 5, 95, 0, 0, 10883, 10884, 7, 3, 0, 0, 10884, 10885, + 7, 2, 0, 0, 10885, 10886, 7, 12, 0, 0, 10886, 10887, 7, 4, 0, 0, 10887, + 10888, 7, 8, 0, 0, 10888, 10889, 7, 10, 0, 0, 10889, 10890, 7, 18, 0, 0, + 10890, 10891, 5, 95, 0, 0, 10891, 10892, 7, 11, 0, 0, 10892, 10893, 7, + 8, 0, 0, 10893, 10894, 7, 9, 0, 0, 10894, 10895, 7, 4, 0, 0, 10895, 1554, + 1, 0, 0, 0, 10896, 10897, 7, 3, 0, 0, 10897, 10898, 7, 6, 0, 0, 10898, + 10899, 7, 0, 0, 0, 10899, 10900, 7, 14, 0, 0, 10900, 10901, 5, 95, 0, 0, + 10901, 10902, 7, 7, 0, 0, 10902, 10903, 7, 3, 0, 0, 10903, 10904, 7, 8, + 0, 0, 10904, 10905, 7, 4, 0, 0, 10905, 10906, 7, 6, 0, 0, 10906, 1556, + 1, 0, 0, 0, 10907, 10908, 7, 3, 0, 0, 10908, 10909, 7, 6, 0, 0, 10909, + 10910, 7, 0, 0, 0, 10910, 10911, 7, 14, 0, 0, 10911, 10912, 5, 95, 0, 0, + 10912, 10913, 7, 7, 0, 0, 10913, 10914, 7, 3, 0, 0, 10914, 10915, 7, 8, + 0, 0, 10915, 10916, 7, 4, 0, 0, 10916, 10917, 7, 6, 0, 0, 10917, 10918, + 5, 95, 0, 0, 10918, 10919, 7, 5, 0, 0, 10919, 10920, 7, 8, 0, 0, 10920, + 10921, 7, 11, 0, 0, 10921, 10922, 7, 6, 0, 0, 10922, 10923, 7, 18, 0, 0, + 10923, 10924, 7, 3, 0, 0, 10924, 10925, 7, 2, 0, 0, 10925, 10926, 7, 12, + 0, 0, 10926, 10927, 7, 20, 0, 0, 10927, 10928, 7, 9, 0, 0, 10928, 1558, + 1, 0, 0, 0, 10929, 10930, 7, 3, 0, 0, 10930, 10931, 7, 6, 0, 0, 10931, + 10932, 7, 1, 0, 0, 10932, 10933, 7, 12, 0, 0, 10933, 10934, 7, 8, 0, 0, + 10934, 10935, 7, 11, 0, 0, 10935, 10936, 7, 14, 0, 0, 10936, 1560, 1, 0, + 0, 0, 10937, 10938, 7, 3, 0, 0, 10938, 10939, 7, 6, 0, 0, 10939, 10940, + 7, 13, 0, 0, 10940, 10941, 7, 6, 0, 0, 10941, 10942, 7, 8, 0, 0, 10942, + 10943, 7, 15, 0, 0, 10943, 10944, 7, 6, 0, 0, 10944, 1562, 1, 0, 0, 0, + 10945, 10946, 7, 3, 0, 0, 10946, 10947, 7, 6, 0, 0, 10947, 10948, 7, 13, + 0, 0, 10948, 10949, 7, 2, 0, 0, 10949, 10950, 7, 17, 0, 0, 10950, 10951, + 7, 20, 0, 0, 10951, 10952, 7, 8, 0, 0, 10952, 10953, 7, 11, 0, 0, 10953, + 10954, 7, 6, 0, 0, 10954, 1564, 1, 0, 0, 0, 10955, 10956, 7, 3, 0, 0, 10956, + 10957, 7, 6, 0, 0, 10957, 10958, 7, 13, 0, 0, 10958, 10959, 7, 2, 0, 0, + 10959, 10960, 7, 10, 0, 0, 10960, 10961, 7, 5, 0, 0, 10961, 10962, 7, 8, + 0, 0, 10962, 10963, 7, 18, 0, 0, 10963, 10964, 7, 12, 0, 0, 10964, 10965, + 7, 3, 0, 0, 10965, 10966, 7, 6, 0, 0, 10966, 1566, 1, 0, 0, 0, 10967, 10968, + 7, 3, 0, 0, 10968, 10969, 7, 6, 0, 0, 10969, 10970, 7, 13, 0, 0, 10970, + 10971, 7, 2, 0, 0, 10971, 10972, 7, 15, 0, 0, 10972, 10973, 7, 6, 0, 0, + 10973, 10974, 7, 3, 0, 0, 10974, 10975, 7, 16, 0, 0, 10975, 1568, 1, 0, + 0, 0, 10976, 10977, 7, 3, 0, 0, 10977, 10978, 7, 6, 0, 0, 10978, 10979, + 7, 13, 0, 0, 10979, 10980, 7, 12, 0, 0, 10980, 10981, 7, 3, 0, 0, 10981, + 10982, 7, 9, 0, 0, 10982, 10983, 7, 8, 0, 0, 10983, 10984, 7, 15, 0, 0, + 10984, 10985, 7, 6, 0, 0, 10985, 10986, 5, 95, 0, 0, 10986, 10987, 7, 4, + 0, 0, 10987, 10988, 7, 3, 0, 0, 10988, 10989, 7, 8, 0, 0, 10989, 10990, + 7, 18, 0, 0, 10990, 10991, 7, 18, 0, 0, 10991, 10992, 7, 6, 0, 0, 10992, + 10993, 7, 3, 0, 0, 10993, 10994, 7, 9, 0, 0, 10994, 1570, 1, 0, 0, 0, 10995, + 10996, 7, 3, 0, 0, 10996, 10997, 7, 6, 0, 0, 10997, 10998, 7, 5, 0, 0, + 10998, 10999, 7, 6, 0, 0, 10999, 11000, 7, 3, 0, 0, 11000, 11001, 7, 6, + 0, 0, 11001, 11002, 7, 10, 0, 0, 11002, 11003, 7, 13, 0, 0, 11003, 11004, + 7, 6, 0, 0, 11004, 11005, 7, 9, 0, 0, 11005, 1572, 1, 0, 0, 0, 11006, 11007, + 7, 3, 0, 0, 11007, 11008, 7, 6, 0, 0, 11008, 11009, 7, 18, 0, 0, 11009, + 11010, 7, 6, 0, 0, 11010, 11011, 7, 10, 0, 0, 11011, 11012, 7, 6, 0, 0, + 11012, 11013, 7, 3, 0, 0, 11013, 11014, 7, 0, 0, 0, 11014, 11015, 7, 4, + 0, 0, 11015, 11016, 7, 6, 0, 0, 11016, 1574, 1, 0, 0, 0, 11017, 11018, + 7, 3, 0, 0, 11018, 11019, 7, 6, 0, 0, 11019, 11020, 7, 11, 0, 0, 11020, + 11021, 7, 0, 0, 0, 11021, 11022, 7, 4, 0, 0, 11022, 11023, 7, 6, 0, 0, + 11023, 11024, 7, 14, 0, 0, 11024, 11025, 5, 95, 0, 0, 11025, 11026, 7, + 13, 0, 0, 11026, 11027, 7, 2, 0, 0, 11027, 11028, 7, 10, 0, 0, 11028, 11029, + 7, 15, 0, 0, 11029, 11030, 7, 6, 0, 0, 11030, 11031, 7, 3, 0, 0, 11031, + 11032, 7, 9, 0, 0, 11032, 11033, 7, 0, 0, 0, 11033, 11034, 7, 4, 0, 0, + 11034, 11035, 7, 8, 0, 0, 11035, 11036, 7, 2, 0, 0, 11036, 11037, 7, 10, + 0, 0, 11037, 1576, 1, 0, 0, 0, 11038, 11039, 7, 3, 0, 0, 11039, 11040, + 7, 6, 0, 0, 11040, 11041, 7, 11, 0, 0, 11041, 11042, 7, 0, 0, 0, 11042, + 11043, 7, 4, 0, 0, 11043, 11044, 7, 6, 0, 0, 11044, 11045, 7, 14, 0, 0, + 11045, 11046, 5, 95, 0, 0, 11046, 11047, 7, 13, 0, 0, 11047, 11048, 7, + 2, 0, 0, 11048, 11049, 7, 10, 0, 0, 11049, 11050, 7, 15, 0, 0, 11050, 11051, + 7, 6, 0, 0, 11051, 11052, 7, 3, 0, 0, 11052, 11053, 7, 9, 0, 0, 11053, + 11054, 7, 0, 0, 0, 11054, 11055, 7, 4, 0, 0, 11055, 11056, 7, 8, 0, 0, + 11056, 11057, 7, 2, 0, 0, 11057, 11058, 7, 10, 0, 0, 11058, 11059, 5, 95, + 0, 0, 11059, 11060, 7, 18, 0, 0, 11060, 11061, 7, 3, 0, 0, 11061, 11062, + 7, 2, 0, 0, 11062, 11063, 7, 12, 0, 0, 11063, 11064, 7, 20, 0, 0, 11064, + 1578, 1, 0, 0, 0, 11065, 11066, 7, 3, 0, 0, 11066, 11067, 7, 6, 0, 0, 11067, + 11068, 7, 11, 0, 0, 11068, 11069, 7, 0, 0, 0, 11069, 11070, 7, 4, 0, 0, + 11070, 11071, 7, 8, 0, 0, 11071, 11072, 7, 15, 0, 0, 11072, 11073, 7, 6, + 0, 0, 11073, 1580, 1, 0, 0, 0, 11074, 11075, 7, 3, 0, 0, 11075, 11076, + 7, 6, 0, 0, 11076, 11077, 7, 17, 0, 0, 11077, 11078, 7, 2, 0, 0, 11078, + 11079, 7, 4, 0, 0, 11079, 11080, 7, 6, 0, 0, 11080, 1582, 1, 0, 0, 0, 11081, + 11082, 7, 3, 0, 0, 11082, 11083, 7, 6, 0, 0, 11083, 11084, 7, 17, 0, 0, + 11084, 11085, 7, 2, 0, 0, 11085, 11086, 7, 4, 0, 0, 11086, 11087, 7, 6, + 0, 0, 11087, 11088, 5, 95, 0, 0, 11088, 11089, 7, 20, 0, 0, 11089, 11090, + 7, 3, 0, 0, 11090, 11091, 7, 2, 0, 0, 11091, 11092, 7, 13, 0, 0, 11092, + 11093, 5, 95, 0, 0, 11093, 11094, 7, 4, 0, 0, 11094, 11095, 7, 3, 0, 0, + 11095, 11096, 7, 0, 0, 0, 11096, 11097, 7, 10, 0, 0, 11097, 11098, 7, 9, + 0, 0, 11098, 11099, 7, 0, 0, 0, 11099, 11100, 7, 13, 0, 0, 11100, 11101, + 7, 4, 0, 0, 11101, 11102, 7, 8, 0, 0, 11102, 11103, 7, 2, 0, 0, 11103, + 11104, 7, 10, 0, 0, 11104, 11105, 7, 9, 0, 0, 11105, 1584, 1, 0, 0, 0, + 11106, 11107, 7, 3, 0, 0, 11107, 11108, 7, 6, 0, 0, 11108, 11109, 7, 17, + 0, 0, 11109, 11110, 7, 2, 0, 0, 11110, 11111, 7, 4, 0, 0, 11111, 11112, + 7, 6, 0, 0, 11112, 11113, 5, 95, 0, 0, 11113, 11114, 7, 9, 0, 0, 11114, + 11115, 7, 6, 0, 0, 11115, 11116, 7, 3, 0, 0, 11116, 11117, 7, 15, 0, 0, + 11117, 11118, 7, 8, 0, 0, 11118, 11119, 7, 13, 0, 0, 11119, 11120, 7, 6, + 0, 0, 11120, 11121, 5, 95, 0, 0, 11121, 11122, 7, 10, 0, 0, 11122, 11123, + 7, 0, 0, 0, 11123, 11124, 7, 17, 0, 0, 11124, 11125, 7, 6, 0, 0, 11125, + 1586, 1, 0, 0, 0, 11126, 11127, 7, 3, 0, 0, 11127, 11128, 7, 6, 0, 0, 11128, + 11129, 7, 17, 0, 0, 11129, 11130, 7, 2, 0, 0, 11130, 11131, 7, 15, 0, 0, + 11131, 11132, 7, 6, 0, 0, 11132, 1588, 1, 0, 0, 0, 11133, 11134, 7, 3, + 0, 0, 11134, 11135, 7, 6, 0, 0, 11135, 11136, 7, 2, 0, 0, 11136, 11137, + 7, 3, 0, 0, 11137, 11138, 7, 18, 0, 0, 11138, 11139, 7, 0, 0, 0, 11139, + 11140, 7, 10, 0, 0, 11140, 11141, 7, 8, 0, 0, 11141, 11142, 7, 23, 0, 0, + 11142, 11143, 7, 6, 0, 0, 11143, 1590, 1, 0, 0, 0, 11144, 11145, 7, 3, + 0, 0, 11145, 11146, 7, 6, 0, 0, 11146, 11147, 7, 20, 0, 0, 11147, 11148, + 7, 0, 0, 0, 11148, 11149, 7, 8, 0, 0, 11149, 11150, 7, 3, 0, 0, 11150, + 11151, 5, 95, 0, 0, 11151, 11152, 7, 0, 0, 0, 11152, 11153, 7, 11, 0, 0, + 11153, 11154, 7, 11, 0, 0, 11154, 11155, 7, 2, 0, 0, 11155, 11156, 7, 7, + 0, 0, 11156, 11157, 5, 95, 0, 0, 11157, 11158, 7, 14, 0, 0, 11158, 11159, + 7, 0, 0, 0, 11159, 11160, 7, 4, 0, 0, 11160, 11161, 7, 0, 0, 0, 11161, + 11162, 5, 95, 0, 0, 11162, 11163, 7, 11, 0, 0, 11163, 11164, 7, 2, 0, 0, + 11164, 11165, 7, 9, 0, 0, 11165, 11166, 7, 9, 0, 0, 11166, 1592, 1, 0, + 0, 0, 11167, 11168, 7, 3, 0, 0, 11168, 11169, 7, 6, 0, 0, 11169, 11170, + 7, 20, 0, 0, 11170, 11171, 7, 0, 0, 0, 11171, 11172, 7, 8, 0, 0, 11172, + 11173, 7, 3, 0, 0, 11173, 11174, 5, 95, 0, 0, 11174, 11175, 7, 5, 0, 0, + 11175, 11176, 7, 0, 0, 0, 11176, 11177, 7, 9, 0, 0, 11177, 11178, 7, 4, + 0, 0, 11178, 1594, 1, 0, 0, 0, 11179, 11180, 7, 3, 0, 0, 11180, 11181, + 7, 6, 0, 0, 11181, 11182, 7, 20, 0, 0, 11182, 11183, 7, 0, 0, 0, 11183, + 11184, 7, 8, 0, 0, 11184, 11185, 7, 3, 0, 0, 11185, 11186, 5, 95, 0, 0, + 11186, 11187, 7, 3, 0, 0, 11187, 11188, 7, 6, 0, 0, 11188, 11189, 7, 1, + 0, 0, 11189, 11190, 7, 12, 0, 0, 11190, 11191, 7, 8, 0, 0, 11191, 11192, + 7, 11, 0, 0, 11192, 11193, 7, 14, 0, 0, 11193, 1596, 1, 0, 0, 0, 11194, + 11195, 7, 3, 0, 0, 11195, 11196, 7, 6, 0, 0, 11196, 11197, 7, 20, 0, 0, + 11197, 11198, 7, 6, 0, 0, 11198, 11199, 7, 0, 0, 0, 11199, 11200, 7, 4, + 0, 0, 11200, 11201, 7, 0, 0, 0, 11201, 11202, 7, 1, 0, 0, 11202, 11203, + 7, 11, 0, 0, 11203, 11204, 7, 6, 0, 0, 11204, 1598, 1, 0, 0, 0, 11205, + 11206, 7, 3, 0, 0, 11206, 11207, 7, 6, 0, 0, 11207, 11208, 7, 20, 0, 0, + 11208, 11209, 7, 6, 0, 0, 11209, 11210, 7, 0, 0, 0, 11210, 11211, 7, 4, + 0, 0, 11211, 11212, 7, 0, 0, 0, 11212, 11213, 7, 1, 0, 0, 11213, 11214, + 7, 11, 0, 0, 11214, 11215, 7, 6, 0, 0, 11215, 11216, 7, 3, 0, 0, 11216, + 11217, 7, 6, 0, 0, 11217, 11218, 7, 0, 0, 0, 11218, 11219, 7, 14, 0, 0, + 11219, 1600, 1, 0, 0, 0, 11220, 11221, 7, 3, 0, 0, 11221, 11222, 7, 6, + 0, 0, 11222, 11223, 7, 20, 0, 0, 11223, 11224, 7, 11, 0, 0, 11224, 11225, + 7, 0, 0, 0, 11225, 11226, 7, 13, 0, 0, 11226, 11227, 7, 6, 0, 0, 11227, + 1602, 1, 0, 0, 0, 11228, 11229, 7, 3, 0, 0, 11229, 11230, 7, 6, 0, 0, 11230, + 11231, 7, 20, 0, 0, 11231, 11232, 7, 11, 0, 0, 11232, 11233, 7, 8, 0, 0, + 11233, 11234, 7, 13, 0, 0, 11234, 11235, 7, 0, 0, 0, 11235, 1604, 1, 0, + 0, 0, 11236, 11237, 7, 3, 0, 0, 11237, 11238, 7, 6, 0, 0, 11238, 11239, + 7, 20, 0, 0, 11239, 11240, 7, 11, 0, 0, 11240, 11241, 7, 8, 0, 0, 11241, + 11242, 7, 13, 0, 0, 11242, 11243, 7, 0, 0, 0, 11243, 11244, 7, 4, 0, 0, + 11244, 11245, 7, 6, 0, 0, 11245, 1606, 1, 0, 0, 0, 11246, 11247, 7, 3, + 0, 0, 11247, 11248, 7, 6, 0, 0, 11248, 11249, 7, 20, 0, 0, 11249, 11250, + 7, 11, 0, 0, 11250, 11251, 7, 8, 0, 0, 11251, 11252, 7, 13, 0, 0, 11252, + 11253, 7, 0, 0, 0, 11253, 11254, 7, 4, 0, 0, 11254, 11255, 7, 8, 0, 0, + 11255, 11256, 7, 2, 0, 0, 11256, 11257, 7, 10, 0, 0, 11257, 1608, 1, 0, + 0, 0, 11258, 11259, 7, 3, 0, 0, 11259, 11260, 7, 6, 0, 0, 11260, 11261, + 7, 25, 0, 0, 11261, 11262, 7, 12, 0, 0, 11262, 11263, 7, 6, 0, 0, 11263, + 11264, 7, 9, 0, 0, 11264, 11265, 7, 4, 0, 0, 11265, 11266, 5, 95, 0, 0, + 11266, 11267, 7, 17, 0, 0, 11267, 11268, 7, 0, 0, 0, 11268, 11269, 7, 22, + 0, 0, 11269, 11270, 5, 95, 0, 0, 11270, 11271, 7, 13, 0, 0, 11271, 11272, + 7, 20, 0, 0, 11272, 11273, 7, 12, 0, 0, 11273, 11274, 5, 95, 0, 0, 11274, + 11275, 7, 4, 0, 0, 11275, 11276, 7, 8, 0, 0, 11276, 11277, 7, 17, 0, 0, + 11277, 11278, 7, 6, 0, 0, 11278, 11279, 5, 95, 0, 0, 11279, 11280, 7, 9, + 0, 0, 11280, 11281, 7, 6, 0, 0, 11281, 11282, 7, 13, 0, 0, 11282, 1610, + 1, 0, 0, 0, 11283, 11284, 7, 3, 0, 0, 11284, 11285, 7, 6, 0, 0, 11285, + 11286, 7, 25, 0, 0, 11286, 11287, 7, 12, 0, 0, 11287, 11288, 7, 6, 0, 0, + 11288, 11289, 7, 9, 0, 0, 11289, 11290, 7, 4, 0, 0, 11290, 11291, 5, 95, + 0, 0, 11291, 11292, 7, 17, 0, 0, 11292, 11293, 7, 0, 0, 0, 11293, 11294, + 7, 22, 0, 0, 11294, 11295, 5, 95, 0, 0, 11295, 11296, 7, 17, 0, 0, 11296, + 11297, 7, 6, 0, 0, 11297, 11298, 7, 17, 0, 0, 11298, 11299, 7, 2, 0, 0, + 11299, 11300, 7, 3, 0, 0, 11300, 11301, 7, 16, 0, 0, 11301, 11302, 5, 95, + 0, 0, 11302, 11303, 7, 18, 0, 0, 11303, 11304, 7, 3, 0, 0, 11304, 11305, + 7, 0, 0, 0, 11305, 11306, 7, 10, 0, 0, 11306, 11307, 7, 4, 0, 0, 11307, + 11308, 5, 95, 0, 0, 11308, 11309, 7, 20, 0, 0, 11309, 11310, 7, 6, 0, 0, + 11310, 11311, 7, 3, 0, 0, 11311, 11312, 7, 13, 0, 0, 11312, 11313, 7, 6, + 0, 0, 11313, 11314, 7, 10, 0, 0, 11314, 11315, 7, 4, 0, 0, 11315, 1612, + 1, 0, 0, 0, 11316, 11317, 7, 3, 0, 0, 11317, 11318, 7, 6, 0, 0, 11318, + 11319, 7, 25, 0, 0, 11319, 11320, 7, 12, 0, 0, 11320, 11321, 7, 6, 0, 0, + 11321, 11322, 7, 9, 0, 0, 11322, 11323, 7, 4, 0, 0, 11323, 11324, 5, 95, + 0, 0, 11324, 11325, 7, 17, 0, 0, 11325, 11326, 7, 6, 0, 0, 11326, 11327, + 7, 17, 0, 0, 11327, 11328, 7, 2, 0, 0, 11328, 11329, 7, 3, 0, 0, 11329, + 11330, 7, 16, 0, 0, 11330, 11331, 5, 95, 0, 0, 11331, 11332, 7, 18, 0, + 0, 11332, 11333, 7, 3, 0, 0, 11333, 11334, 7, 0, 0, 0, 11334, 11335, 7, + 10, 0, 0, 11335, 11336, 7, 4, 0, 0, 11336, 11337, 5, 95, 0, 0, 11337, 11338, + 7, 4, 0, 0, 11338, 11339, 7, 8, 0, 0, 11339, 11340, 7, 17, 0, 0, 11340, + 11341, 7, 6, 0, 0, 11341, 11342, 7, 2, 0, 0, 11342, 11343, 7, 12, 0, 0, + 11343, 11344, 7, 4, 0, 0, 11344, 11345, 5, 95, 0, 0, 11345, 11346, 7, 9, + 0, 0, 11346, 11347, 7, 6, 0, 0, 11347, 11348, 7, 13, 0, 0, 11348, 1614, + 1, 0, 0, 0, 11349, 11350, 7, 3, 0, 0, 11350, 11351, 7, 6, 0, 0, 11351, + 11352, 7, 25, 0, 0, 11352, 11353, 7, 12, 0, 0, 11353, 11354, 7, 8, 0, 0, + 11354, 11355, 7, 3, 0, 0, 11355, 11356, 7, 6, 0, 0, 11356, 11357, 7, 14, + 0, 0, 11357, 1616, 1, 0, 0, 0, 11358, 11359, 7, 3, 0, 0, 11359, 11360, + 7, 6, 0, 0, 11360, 11361, 7, 25, 0, 0, 11361, 11362, 7, 12, 0, 0, 11362, + 11363, 7, 8, 0, 0, 11363, 11364, 7, 3, 0, 0, 11364, 11365, 7, 6, 0, 0, + 11365, 11366, 7, 14, 0, 0, 11366, 11367, 5, 95, 0, 0, 11367, 11368, 7, + 9, 0, 0, 11368, 11369, 7, 16, 0, 0, 11369, 11370, 7, 10, 0, 0, 11370, 11371, + 7, 13, 0, 0, 11371, 11372, 7, 19, 0, 0, 11372, 11373, 7, 3, 0, 0, 11373, + 11374, 7, 2, 0, 0, 11374, 11375, 7, 10, 0, 0, 11375, 11376, 7, 8, 0, 0, + 11376, 11377, 7, 23, 0, 0, 11377, 11378, 7, 6, 0, 0, 11378, 11379, 7, 14, + 0, 0, 11379, 11380, 5, 95, 0, 0, 11380, 11381, 7, 9, 0, 0, 11381, 11382, + 7, 6, 0, 0, 11382, 11383, 7, 13, 0, 0, 11383, 11384, 7, 2, 0, 0, 11384, + 11385, 7, 10, 0, 0, 11385, 11386, 7, 14, 0, 0, 11386, 11387, 7, 0, 0, 0, + 11387, 11388, 7, 3, 0, 0, 11388, 11389, 7, 8, 0, 0, 11389, 11390, 7, 6, + 0, 0, 11390, 11391, 7, 9, 0, 0, 11391, 11392, 5, 95, 0, 0, 11392, 11393, + 7, 4, 0, 0, 11393, 11394, 7, 2, 0, 0, 11394, 11395, 5, 95, 0, 0, 11395, + 11396, 7, 13, 0, 0, 11396, 11397, 7, 2, 0, 0, 11397, 11398, 7, 17, 0, 0, + 11398, 11399, 7, 17, 0, 0, 11399, 11400, 7, 8, 0, 0, 11400, 11401, 7, 4, + 0, 0, 11401, 1618, 1, 0, 0, 0, 11402, 11403, 7, 3, 0, 0, 11403, 11404, + 7, 6, 0, 0, 11404, 11405, 7, 9, 0, 0, 11405, 11406, 7, 0, 0, 0, 11406, + 11407, 7, 17, 0, 0, 11407, 11408, 7, 20, 0, 0, 11408, 11409, 7, 11, 0, + 0, 11409, 11410, 7, 6, 0, 0, 11410, 1620, 1, 0, 0, 0, 11411, 11412, 7, + 3, 0, 0, 11412, 11413, 7, 6, 0, 0, 11413, 11414, 7, 9, 0, 0, 11414, 11415, + 7, 6, 0, 0, 11415, 11416, 7, 3, 0, 0, 11416, 11417, 7, 15, 0, 0, 11417, + 11418, 7, 6, 0, 0, 11418, 11419, 5, 95, 0, 0, 11419, 11420, 7, 14, 0, 0, + 11420, 11421, 7, 8, 0, 0, 11421, 11422, 7, 9, 0, 0, 11422, 11423, 7, 21, + 0, 0, 11423, 11424, 5, 95, 0, 0, 11424, 11425, 7, 9, 0, 0, 11425, 11426, + 7, 20, 0, 0, 11426, 11427, 7, 0, 0, 0, 11427, 11428, 7, 13, 0, 0, 11428, + 11429, 7, 6, 0, 0, 11429, 1622, 1, 0, 0, 0, 11430, 11431, 7, 3, 0, 0, 11431, + 11432, 7, 6, 0, 0, 11432, 11433, 7, 9, 0, 0, 11433, 11434, 7, 6, 0, 0, + 11434, 11435, 7, 4, 0, 0, 11435, 1624, 1, 0, 0, 0, 11436, 11437, 7, 3, + 0, 0, 11437, 11438, 7, 6, 0, 0, 11438, 11439, 7, 9, 0, 0, 11439, 11440, + 7, 2, 0, 0, 11440, 11441, 7, 12, 0, 0, 11441, 11442, 7, 3, 0, 0, 11442, + 11443, 7, 13, 0, 0, 11443, 11444, 7, 6, 0, 0, 11444, 1626, 1, 0, 0, 0, + 11445, 11446, 7, 3, 0, 0, 11446, 11447, 7, 6, 0, 0, 11447, 11448, 7, 9, + 0, 0, 11448, 11449, 7, 2, 0, 0, 11449, 11450, 7, 12, 0, 0, 11450, 11451, + 7, 3, 0, 0, 11451, 11452, 7, 13, 0, 0, 11452, 11453, 7, 6, 0, 0, 11453, + 11454, 7, 9, 0, 0, 11454, 1628, 1, 0, 0, 0, 11455, 11456, 7, 3, 0, 0, 11456, + 11457, 7, 6, 0, 0, 11457, 11458, 7, 9, 0, 0, 11458, 11459, 7, 2, 0, 0, + 11459, 11460, 7, 12, 0, 0, 11460, 11461, 7, 3, 0, 0, 11461, 11462, 7, 13, + 0, 0, 11462, 11463, 7, 6, 0, 0, 11463, 11464, 5, 95, 0, 0, 11464, 11465, + 7, 17, 0, 0, 11465, 11466, 7, 0, 0, 0, 11466, 11467, 7, 10, 0, 0, 11467, + 11468, 7, 0, 0, 0, 11468, 11469, 7, 18, 0, 0, 11469, 11470, 7, 6, 0, 0, + 11470, 11471, 7, 3, 0, 0, 11471, 11472, 5, 95, 0, 0, 11472, 11473, 7, 11, + 0, 0, 11473, 11474, 7, 2, 0, 0, 11474, 11475, 7, 13, 0, 0, 11475, 11476, + 7, 0, 0, 0, 11476, 11477, 7, 4, 0, 0, 11477, 11478, 7, 8, 0, 0, 11478, + 11479, 7, 2, 0, 0, 11479, 11480, 7, 10, 0, 0, 11480, 1630, 1, 0, 0, 0, + 11481, 11482, 7, 3, 0, 0, 11482, 11483, 7, 6, 0, 0, 11483, 11484, 7, 9, + 0, 0, 11484, 11485, 7, 4, 0, 0, 11485, 11486, 7, 0, 0, 0, 11486, 11487, + 7, 3, 0, 0, 11487, 11488, 7, 4, 0, 0, 11488, 1632, 1, 0, 0, 0, 11489, 11490, + 7, 3, 0, 0, 11490, 11491, 7, 6, 0, 0, 11491, 11492, 7, 9, 0, 0, 11492, + 11493, 7, 4, 0, 0, 11493, 11494, 7, 2, 0, 0, 11494, 11495, 7, 3, 0, 0, + 11495, 11496, 7, 6, 0, 0, 11496, 1634, 1, 0, 0, 0, 11497, 11498, 7, 3, + 0, 0, 11498, 11499, 7, 6, 0, 0, 11499, 11500, 7, 9, 0, 0, 11500, 11501, + 7, 4, 0, 0, 11501, 11502, 7, 3, 0, 0, 11502, 11503, 7, 8, 0, 0, 11503, + 11504, 7, 13, 0, 0, 11504, 11505, 7, 4, 0, 0, 11505, 1636, 1, 0, 0, 0, + 11506, 11507, 7, 3, 0, 0, 11507, 11508, 7, 6, 0, 0, 11508, 11509, 7, 9, + 0, 0, 11509, 11510, 7, 4, 0, 0, 11510, 11511, 7, 3, 0, 0, 11511, 11512, + 7, 8, 0, 0, 11512, 11513, 7, 13, 0, 0, 11513, 11514, 7, 4, 0, 0, 11514, + 11515, 7, 6, 0, 0, 11515, 11516, 7, 14, 0, 0, 11516, 11517, 5, 95, 0, 0, + 11517, 11518, 7, 12, 0, 0, 11518, 11519, 7, 9, 0, 0, 11519, 11520, 7, 6, + 0, 0, 11520, 11521, 7, 3, 0, 0, 11521, 1638, 1, 0, 0, 0, 11522, 11523, + 7, 3, 0, 0, 11523, 11524, 7, 6, 0, 0, 11524, 11525, 7, 9, 0, 0, 11525, + 11526, 7, 12, 0, 0, 11526, 11527, 7, 17, 0, 0, 11527, 11528, 7, 0, 0, 0, + 11528, 11529, 7, 1, 0, 0, 11529, 11530, 7, 11, 0, 0, 11530, 11531, 7, 6, + 0, 0, 11531, 1640, 1, 0, 0, 0, 11532, 11533, 7, 3, 0, 0, 11533, 11534, + 7, 6, 0, 0, 11534, 11535, 7, 9, 0, 0, 11535, 11536, 7, 12, 0, 0, 11536, + 11537, 7, 17, 0, 0, 11537, 11538, 7, 6, 0, 0, 11538, 1642, 1, 0, 0, 0, + 11539, 11540, 7, 3, 0, 0, 11540, 11541, 7, 6, 0, 0, 11541, 11542, 7, 4, + 0, 0, 11542, 11543, 7, 0, 0, 0, 11543, 11544, 7, 8, 0, 0, 11544, 11545, + 7, 10, 0, 0, 11545, 11546, 7, 14, 0, 0, 11546, 11547, 7, 0, 0, 0, 11547, + 11548, 7, 16, 0, 0, 11548, 11549, 7, 9, 0, 0, 11549, 1644, 1, 0, 0, 0, + 11550, 11551, 7, 3, 0, 0, 11551, 11552, 7, 6, 0, 0, 11552, 11553, 7, 4, + 0, 0, 11553, 11554, 7, 6, 0, 0, 11554, 11555, 7, 10, 0, 0, 11555, 11556, + 7, 4, 0, 0, 11556, 11557, 7, 8, 0, 0, 11557, 11558, 7, 2, 0, 0, 11558, + 11559, 7, 10, 0, 0, 11559, 1646, 1, 0, 0, 0, 11560, 11561, 7, 3, 0, 0, + 11561, 11562, 7, 6, 0, 0, 11562, 11563, 7, 4, 0, 0, 11563, 11564, 7, 12, + 0, 0, 11564, 11565, 7, 3, 0, 0, 11565, 11566, 7, 10, 0, 0, 11566, 1648, + 1, 0, 0, 0, 11567, 11568, 7, 3, 0, 0, 11568, 11569, 7, 6, 0, 0, 11569, + 11570, 7, 4, 0, 0, 11570, 11571, 7, 12, 0, 0, 11571, 11572, 7, 3, 0, 0, + 11572, 11573, 7, 10, 0, 0, 11573, 11574, 7, 9, 0, 0, 11574, 1650, 1, 0, + 0, 0, 11575, 11576, 7, 3, 0, 0, 11576, 11577, 7, 6, 0, 0, 11577, 11578, + 7, 15, 0, 0, 11578, 11579, 7, 6, 0, 0, 11579, 11580, 7, 3, 0, 0, 11580, + 11581, 7, 9, 0, 0, 11581, 11582, 7, 6, 0, 0, 11582, 1652, 1, 0, 0, 0, 11583, + 11584, 7, 3, 0, 0, 11584, 11585, 7, 6, 0, 0, 11585, 11586, 7, 15, 0, 0, + 11586, 11587, 7, 6, 0, 0, 11587, 11588, 7, 3, 0, 0, 11588, 11589, 7, 4, + 0, 0, 11589, 1654, 1, 0, 0, 0, 11590, 11591, 7, 3, 0, 0, 11591, 11592, + 7, 6, 0, 0, 11592, 11593, 7, 15, 0, 0, 11593, 11594, 7, 2, 0, 0, 11594, + 11595, 7, 21, 0, 0, 11595, 11596, 7, 6, 0, 0, 11596, 1656, 1, 0, 0, 0, + 11597, 11598, 7, 3, 0, 0, 11598, 11599, 7, 6, 0, 0, 11599, 11600, 7, 7, + 0, 0, 11600, 11601, 7, 8, 0, 0, 11601, 11602, 7, 10, 0, 0, 11602, 11603, + 7, 14, 0, 0, 11603, 1658, 1, 0, 0, 0, 11604, 11605, 7, 3, 0, 0, 11605, + 11606, 7, 8, 0, 0, 11606, 11607, 7, 18, 0, 0, 11607, 11608, 7, 19, 0, 0, + 11608, 11609, 7, 4, 0, 0, 11609, 1660, 1, 0, 0, 0, 11610, 11611, 7, 3, + 0, 0, 11611, 11612, 7, 2, 0, 0, 11612, 11613, 7, 1, 0, 0, 11613, 11614, + 7, 12, 0, 0, 11614, 11615, 7, 9, 0, 0, 11615, 11616, 7, 4, 0, 0, 11616, + 1662, 1, 0, 0, 0, 11617, 11618, 7, 3, 0, 0, 11618, 11619, 7, 2, 0, 0, 11619, + 11620, 7, 11, 0, 0, 11620, 11621, 7, 6, 0, 0, 11621, 1664, 1, 0, 0, 0, + 11622, 11623, 7, 3, 0, 0, 11623, 11624, 7, 2, 0, 0, 11624, 11625, 7, 11, + 0, 0, 11625, 11626, 7, 11, 0, 0, 11626, 11627, 7, 1, 0, 0, 11627, 11628, + 7, 0, 0, 0, 11628, 11629, 7, 13, 0, 0, 11629, 11630, 7, 21, 0, 0, 11630, + 1666, 1, 0, 0, 0, 11631, 11632, 7, 3, 0, 0, 11632, 11633, 7, 2, 0, 0, 11633, + 11634, 7, 2, 0, 0, 11634, 11635, 7, 4, 0, 0, 11635, 1668, 1, 0, 0, 0, 11636, + 11637, 7, 3, 0, 0, 11637, 11638, 7, 2, 0, 0, 11638, 11639, 7, 12, 0, 0, + 11639, 11640, 7, 10, 0, 0, 11640, 11641, 7, 14, 0, 0, 11641, 11642, 5, + 95, 0, 0, 11642, 11643, 7, 3, 0, 0, 11643, 11644, 7, 2, 0, 0, 11644, 11645, + 7, 1, 0, 0, 11645, 11646, 7, 8, 0, 0, 11646, 11647, 7, 10, 0, 0, 11647, + 1670, 1, 0, 0, 0, 11648, 11649, 7, 3, 0, 0, 11649, 11650, 7, 2, 0, 0, 11650, + 11651, 7, 12, 0, 0, 11651, 11652, 7, 4, 0, 0, 11652, 11653, 7, 6, 0, 0, + 11653, 1672, 1, 0, 0, 0, 11654, 11655, 7, 3, 0, 0, 11655, 11656, 7, 2, + 0, 0, 11656, 11657, 7, 7, 0, 0, 11657, 1674, 1, 0, 0, 0, 11658, 11659, + 7, 3, 0, 0, 11659, 11660, 7, 2, 0, 0, 11660, 11661, 7, 7, 0, 0, 11661, + 11662, 7, 13, 0, 0, 11662, 11663, 7, 2, 0, 0, 11663, 11664, 7, 12, 0, 0, + 11664, 11665, 7, 10, 0, 0, 11665, 11666, 7, 4, 0, 0, 11666, 1676, 1, 0, + 0, 0, 11667, 11668, 7, 3, 0, 0, 11668, 11669, 7, 2, 0, 0, 11669, 11670, + 7, 7, 0, 0, 11670, 11671, 7, 13, 0, 0, 11671, 11672, 7, 2, 0, 0, 11672, + 11673, 7, 12, 0, 0, 11673, 11674, 7, 10, 0, 0, 11674, 11675, 7, 4, 0, 0, + 11675, 11676, 5, 95, 0, 0, 11676, 11677, 7, 1, 0, 0, 11677, 11678, 7, 8, + 0, 0, 11678, 11679, 7, 18, 0, 0, 11679, 1678, 1, 0, 0, 0, 11680, 11681, + 7, 3, 0, 0, 11681, 11682, 7, 2, 0, 0, 11682, 11683, 7, 7, 0, 0, 11683, + 11684, 7, 18, 0, 0, 11684, 11685, 7, 12, 0, 0, 11685, 11686, 7, 8, 0, 0, + 11686, 11687, 7, 14, 0, 0, 11687, 1680, 1, 0, 0, 0, 11688, 11689, 7, 3, + 0, 0, 11689, 11690, 7, 2, 0, 0, 11690, 11691, 7, 7, 0, 0, 11691, 11692, + 7, 18, 0, 0, 11692, 11693, 7, 12, 0, 0, 11693, 11694, 7, 8, 0, 0, 11694, + 11695, 7, 14, 0, 0, 11695, 11696, 7, 13, 0, 0, 11696, 11697, 7, 2, 0, 0, + 11697, 11698, 7, 11, 0, 0, 11698, 1682, 1, 0, 0, 0, 11699, 11700, 7, 3, + 0, 0, 11700, 11701, 7, 2, 0, 0, 11701, 11702, 7, 7, 0, 0, 11702, 11703, + 7, 11, 0, 0, 11703, 11704, 7, 2, 0, 0, 11704, 11705, 7, 13, 0, 0, 11705, + 11706, 7, 21, 0, 0, 11706, 1684, 1, 0, 0, 0, 11707, 11708, 7, 3, 0, 0, + 11708, 11709, 7, 2, 0, 0, 11709, 11710, 7, 7, 0, 0, 11710, 11711, 7, 9, + 0, 0, 11711, 1686, 1, 0, 0, 0, 11712, 11713, 7, 3, 0, 0, 11713, 11714, + 7, 2, 0, 0, 11714, 11715, 7, 7, 0, 0, 11715, 11716, 5, 95, 0, 0, 11716, + 11717, 7, 10, 0, 0, 11717, 11718, 7, 12, 0, 0, 11718, 11719, 7, 17, 0, + 0, 11719, 11720, 7, 1, 0, 0, 11720, 11721, 7, 6, 0, 0, 11721, 11722, 7, + 3, 0, 0, 11722, 1688, 1, 0, 0, 0, 11723, 11724, 7, 3, 0, 0, 11724, 11725, + 7, 9, 0, 0, 11725, 11726, 7, 0, 0, 0, 11726, 11727, 5, 95, 0, 0, 11727, + 11728, 5, 49, 0, 0, 11728, 11729, 5, 48, 0, 0, 11729, 11730, 5, 50, 0, + 0, 11730, 11731, 5, 52, 0, 0, 11731, 1690, 1, 0, 0, 0, 11732, 11733, 7, + 3, 0, 0, 11733, 11734, 7, 9, 0, 0, 11734, 11735, 7, 0, 0, 0, 11735, 11736, + 5, 95, 0, 0, 11736, 11737, 5, 50, 0, 0, 11737, 11738, 5, 48, 0, 0, 11738, + 11739, 5, 52, 0, 0, 11739, 11740, 5, 56, 0, 0, 11740, 1692, 1, 0, 0, 0, + 11741, 11742, 7, 3, 0, 0, 11742, 11743, 7, 9, 0, 0, 11743, 11744, 7, 0, + 0, 0, 11744, 11745, 5, 95, 0, 0, 11745, 11746, 5, 51, 0, 0, 11746, 11747, + 5, 48, 0, 0, 11747, 11748, 5, 55, 0, 0, 11748, 11749, 5, 50, 0, 0, 11749, + 1694, 1, 0, 0, 0, 11750, 11751, 7, 3, 0, 0, 11751, 11752, 7, 9, 0, 0, 11752, + 11753, 7, 0, 0, 0, 11753, 11754, 5, 95, 0, 0, 11754, 11755, 5, 52, 0, 0, + 11755, 11756, 5, 48, 0, 0, 11756, 11757, 5, 57, 0, 0, 11757, 11758, 5, + 54, 0, 0, 11758, 1696, 1, 0, 0, 0, 11759, 11760, 7, 3, 0, 0, 11760, 11761, + 7, 9, 0, 0, 11761, 11762, 7, 0, 0, 0, 11762, 11763, 5, 95, 0, 0, 11763, + 11764, 5, 53, 0, 0, 11764, 11765, 5, 49, 0, 0, 11765, 11766, 5, 50, 0, + 0, 11766, 1698, 1, 0, 0, 0, 11767, 11768, 7, 3, 0, 0, 11768, 11769, 7, + 4, 0, 0, 11769, 11770, 7, 3, 0, 0, 11770, 11771, 7, 8, 0, 0, 11771, 11772, + 7, 17, 0, 0, 11772, 1700, 1, 0, 0, 0, 11773, 11774, 7, 3, 0, 0, 11774, + 11775, 7, 12, 0, 0, 11775, 11776, 7, 11, 0, 0, 11776, 11777, 7, 6, 0, 0, + 11777, 1702, 1, 0, 0, 0, 11778, 11779, 7, 9, 0, 0, 11779, 11780, 7, 0, + 0, 0, 11780, 11781, 7, 5, 0, 0, 11781, 11782, 7, 6, 0, 0, 11782, 1704, + 1, 0, 0, 0, 11783, 11784, 7, 9, 0, 0, 11784, 11785, 7, 0, 0, 0, 11785, + 11786, 7, 5, 0, 0, 11786, 11787, 7, 6, 0, 0, 11787, 11788, 7, 4, 0, 0, + 11788, 11789, 7, 16, 0, 0, 11789, 1706, 1, 0, 0, 0, 11790, 11791, 7, 9, + 0, 0, 11791, 11792, 7, 0, 0, 0, 11792, 11793, 7, 17, 0, 0, 11793, 11794, + 7, 20, 0, 0, 11794, 11795, 7, 11, 0, 0, 11795, 11796, 7, 6, 0, 0, 11796, + 1708, 1, 0, 0, 0, 11797, 11798, 7, 9, 0, 0, 11798, 11799, 7, 0, 0, 0, 11799, + 11800, 7, 15, 0, 0, 11800, 11801, 7, 6, 0, 0, 11801, 1710, 1, 0, 0, 0, + 11802, 11803, 7, 9, 0, 0, 11803, 11804, 7, 13, 0, 0, 11804, 11805, 7, 19, + 0, 0, 11805, 11806, 7, 6, 0, 0, 11806, 11807, 7, 14, 0, 0, 11807, 11808, + 7, 12, 0, 0, 11808, 11809, 7, 11, 0, 0, 11809, 11810, 7, 6, 0, 0, 11810, + 11811, 7, 3, 0, 0, 11811, 1712, 1, 0, 0, 0, 11812, 11813, 7, 9, 0, 0, 11813, + 11814, 7, 13, 0, 0, 11814, 11815, 7, 19, 0, 0, 11815, 11816, 7, 6, 0, 0, + 11816, 11817, 7, 17, 0, 0, 11817, 11818, 7, 0, 0, 0, 11818, 1714, 1, 0, + 0, 0, 11819, 11820, 7, 9, 0, 0, 11820, 11821, 7, 13, 0, 0, 11821, 11822, + 7, 19, 0, 0, 11822, 11823, 7, 6, 0, 0, 11823, 11824, 7, 17, 0, 0, 11824, + 11825, 7, 0, 0, 0, 11825, 11826, 7, 1, 0, 0, 11826, 11827, 7, 8, 0, 0, + 11827, 11828, 7, 10, 0, 0, 11828, 11829, 7, 14, 0, 0, 11829, 11830, 7, + 8, 0, 0, 11830, 11831, 7, 10, 0, 0, 11831, 11832, 7, 18, 0, 0, 11832, 1716, + 1, 0, 0, 0, 11833, 11834, 7, 9, 0, 0, 11834, 11835, 7, 13, 0, 0, 11835, + 11836, 7, 19, 0, 0, 11836, 11837, 7, 6, 0, 0, 11837, 11838, 7, 17, 0, 0, + 11838, 11839, 7, 0, 0, 0, 11839, 11840, 5, 95, 0, 0, 11840, 11841, 7, 8, + 0, 0, 11841, 11842, 7, 14, 0, 0, 11842, 1718, 1, 0, 0, 0, 11843, 11844, + 7, 9, 0, 0, 11844, 11845, 7, 13, 0, 0, 11845, 11846, 7, 19, 0, 0, 11846, + 11847, 7, 6, 0, 0, 11847, 11848, 7, 17, 0, 0, 11848, 11849, 7, 0, 0, 0, + 11849, 11850, 5, 95, 0, 0, 11850, 11851, 7, 10, 0, 0, 11851, 11852, 7, + 0, 0, 0, 11852, 11853, 7, 17, 0, 0, 11853, 11854, 7, 6, 0, 0, 11854, 1720, + 1, 0, 0, 0, 11855, 11856, 7, 9, 0, 0, 11856, 11857, 7, 13, 0, 0, 11857, + 11858, 7, 19, 0, 0, 11858, 11859, 7, 6, 0, 0, 11859, 11860, 7, 17, 0, 0, + 11860, 11861, 7, 6, 0, 0, 11861, 1722, 1, 0, 0, 0, 11862, 11863, 7, 9, + 0, 0, 11863, 11864, 7, 13, 0, 0, 11864, 11865, 7, 2, 0, 0, 11865, 11866, + 7, 20, 0, 0, 11866, 11867, 7, 6, 0, 0, 11867, 11868, 7, 14, 0, 0, 11868, + 1724, 1, 0, 0, 0, 11869, 11870, 7, 9, 0, 0, 11870, 11871, 7, 13, 0, 0, + 11871, 11872, 7, 2, 0, 0, 11872, 11873, 7, 20, 0, 0, 11873, 11874, 7, 6, + 0, 0, 11874, 11875, 5, 95, 0, 0, 11875, 11876, 7, 8, 0, 0, 11876, 11877, + 7, 14, 0, 0, 11877, 11878, 7, 6, 0, 0, 11878, 11879, 7, 10, 0, 0, 11879, + 11880, 7, 4, 0, 0, 11880, 11881, 7, 8, 0, 0, 11881, 11882, 7, 4, 0, 0, + 11882, 11883, 7, 16, 0, 0, 11883, 1726, 1, 0, 0, 0, 11884, 11885, 7, 9, + 0, 0, 11885, 11886, 7, 13, 0, 0, 11886, 11887, 7, 3, 0, 0, 11887, 11888, + 7, 8, 0, 0, 11888, 11889, 7, 20, 0, 0, 11889, 11890, 7, 4, 0, 0, 11890, + 1728, 1, 0, 0, 0, 11891, 11892, 7, 9, 0, 0, 11892, 11893, 7, 13, 0, 0, + 11893, 11894, 7, 3, 0, 0, 11894, 11895, 7, 2, 0, 0, 11895, 11896, 7, 11, + 0, 0, 11896, 11897, 7, 11, 0, 0, 11897, 1730, 1, 0, 0, 0, 11898, 11899, + 7, 9, 0, 0, 11899, 11900, 7, 13, 0, 0, 11900, 11901, 7, 3, 0, 0, 11901, + 11902, 7, 2, 0, 0, 11902, 11903, 7, 11, 0, 0, 11903, 11904, 7, 11, 0, 0, + 11904, 11905, 5, 95, 0, 0, 11905, 11906, 7, 11, 0, 0, 11906, 11907, 7, + 2, 0, 0, 11907, 11908, 7, 13, 0, 0, 11908, 11909, 7, 21, 0, 0, 11909, 11910, + 7, 9, 0, 0, 11910, 1732, 1, 0, 0, 0, 11911, 11912, 7, 9, 0, 0, 11912, 11913, + 7, 6, 0, 0, 11913, 11914, 7, 0, 0, 0, 11914, 11915, 7, 3, 0, 0, 11915, + 11916, 7, 13, 0, 0, 11916, 11917, 7, 19, 0, 0, 11917, 1734, 1, 0, 0, 0, + 11918, 11919, 7, 9, 0, 0, 11919, 11920, 7, 6, 0, 0, 11920, 11921, 7, 13, + 0, 0, 11921, 11922, 7, 2, 0, 0, 11922, 11923, 7, 10, 0, 0, 11923, 11924, + 7, 14, 0, 0, 11924, 11925, 7, 0, 0, 0, 11925, 11926, 7, 3, 0, 0, 11926, + 11927, 7, 16, 0, 0, 11927, 1736, 1, 0, 0, 0, 11928, 11929, 7, 9, 0, 0, + 11929, 11930, 7, 6, 0, 0, 11930, 11931, 7, 13, 0, 0, 11931, 11932, 7, 2, + 0, 0, 11932, 11933, 7, 10, 0, 0, 11933, 11934, 7, 14, 0, 0, 11934, 11935, + 7, 0, 0, 0, 11935, 11936, 7, 3, 0, 0, 11936, 11937, 7, 16, 0, 0, 11937, + 11938, 5, 95, 0, 0, 11938, 11939, 7, 2, 0, 0, 11939, 11940, 7, 10, 0, 0, + 11940, 11941, 7, 11, 0, 0, 11941, 11942, 7, 16, 0, 0, 11942, 1738, 1, 0, + 0, 0, 11943, 11944, 7, 9, 0, 0, 11944, 11945, 7, 6, 0, 0, 11945, 11946, + 7, 13, 0, 0, 11946, 11947, 7, 2, 0, 0, 11947, 11948, 7, 10, 0, 0, 11948, + 11949, 7, 14, 0, 0, 11949, 11950, 7, 0, 0, 0, 11950, 11951, 7, 3, 0, 0, + 11951, 11952, 7, 16, 0, 0, 11952, 11953, 5, 95, 0, 0, 11953, 11954, 7, + 3, 0, 0, 11954, 11955, 7, 2, 0, 0, 11955, 11956, 7, 11, 0, 0, 11956, 11957, + 7, 6, 0, 0, 11957, 1740, 1, 0, 0, 0, 11958, 11959, 7, 9, 0, 0, 11959, 11960, + 7, 6, 0, 0, 11960, 11961, 7, 13, 0, 0, 11961, 11962, 7, 2, 0, 0, 11962, + 11963, 7, 10, 0, 0, 11963, 11964, 7, 14, 0, 0, 11964, 11965, 7, 9, 0, 0, + 11965, 1742, 1, 0, 0, 0, 11966, 11967, 7, 9, 0, 0, 11967, 11968, 7, 6, + 0, 0, 11968, 11969, 7, 13, 0, 0, 11969, 11970, 7, 3, 0, 0, 11970, 11971, + 7, 6, 0, 0, 11971, 11972, 7, 4, 0, 0, 11972, 1744, 1, 0, 0, 0, 11973, 11974, + 7, 9, 0, 0, 11974, 11975, 7, 6, 0, 0, 11975, 11976, 7, 13, 0, 0, 11976, + 11977, 7, 12, 0, 0, 11977, 11978, 7, 3, 0, 0, 11978, 11979, 7, 0, 0, 0, + 11979, 11980, 7, 1, 0, 0, 11980, 11981, 7, 11, 0, 0, 11981, 11982, 7, 6, + 0, 0, 11982, 11983, 7, 9, 0, 0, 11983, 1746, 1, 0, 0, 0, 11984, 11985, + 7, 9, 0, 0, 11985, 11986, 7, 6, 0, 0, 11986, 11987, 7, 13, 0, 0, 11987, + 11988, 7, 12, 0, 0, 11988, 11989, 7, 3, 0, 0, 11989, 11990, 7, 8, 0, 0, + 11990, 11991, 7, 4, 0, 0, 11991, 11992, 7, 16, 0, 0, 11992, 1748, 1, 0, + 0, 0, 11993, 11994, 7, 9, 0, 0, 11994, 11995, 7, 6, 0, 0, 11995, 11996, + 7, 13, 0, 0, 11996, 11997, 7, 12, 0, 0, 11997, 11998, 7, 3, 0, 0, 11998, + 11999, 7, 8, 0, 0, 11999, 12000, 7, 4, 0, 0, 12000, 12001, 7, 16, 0, 0, + 12001, 12002, 7, 0, 0, 0, 12002, 12003, 7, 12, 0, 0, 12003, 12004, 7, 14, + 0, 0, 12004, 12005, 7, 8, 0, 0, 12005, 12006, 7, 4, 0, 0, 12006, 1750, + 1, 0, 0, 0, 12007, 12008, 7, 9, 0, 0, 12008, 12009, 7, 6, 0, 0, 12009, + 12010, 7, 13, 0, 0, 12010, 12011, 7, 12, 0, 0, 12011, 12012, 7, 3, 0, 0, + 12012, 12013, 7, 8, 0, 0, 12013, 12014, 7, 4, 0, 0, 12014, 12015, 7, 16, + 0, 0, 12015, 12016, 5, 95, 0, 0, 12016, 12017, 7, 11, 0, 0, 12017, 12018, + 7, 2, 0, 0, 12018, 12019, 7, 18, 0, 0, 12019, 1752, 1, 0, 0, 0, 12020, + 12021, 7, 9, 0, 0, 12021, 12022, 7, 6, 0, 0, 12022, 12023, 7, 6, 0, 0, + 12023, 12024, 7, 14, 0, 0, 12024, 12025, 7, 8, 0, 0, 12025, 12026, 7, 10, + 0, 0, 12026, 12027, 7, 18, 0, 0, 12027, 12028, 5, 95, 0, 0, 12028, 12029, + 7, 17, 0, 0, 12029, 12030, 7, 2, 0, 0, 12030, 12031, 7, 14, 0, 0, 12031, + 12032, 7, 6, 0, 0, 12032, 1754, 1, 0, 0, 0, 12033, 12034, 7, 9, 0, 0, 12034, + 12035, 7, 6, 0, 0, 12035, 12036, 7, 11, 0, 0, 12036, 12037, 7, 6, 0, 0, + 12037, 12038, 7, 13, 0, 0, 12038, 12039, 7, 4, 0, 0, 12039, 1756, 1, 0, + 0, 0, 12040, 12041, 7, 9, 0, 0, 12041, 12042, 7, 6, 0, 0, 12042, 12043, + 7, 11, 0, 0, 12043, 12044, 7, 5, 0, 0, 12044, 1758, 1, 0, 0, 0, 12045, + 12046, 7, 9, 0, 0, 12046, 12047, 7, 6, 0, 0, 12047, 12048, 7, 17, 0, 0, + 12048, 12049, 7, 0, 0, 0, 12049, 12050, 7, 10, 0, 0, 12050, 12051, 7, 4, + 0, 0, 12051, 12052, 7, 8, 0, 0, 12052, 12053, 7, 13, 0, 0, 12053, 12054, + 7, 21, 0, 0, 12054, 12055, 7, 6, 0, 0, 12055, 12056, 7, 16, 0, 0, 12056, + 12057, 7, 20, 0, 0, 12057, 12058, 7, 19, 0, 0, 12058, 12059, 7, 3, 0, 0, + 12059, 12060, 7, 0, 0, 0, 12060, 12061, 7, 9, 0, 0, 12061, 12062, 7, 6, + 0, 0, 12062, 12063, 7, 4, 0, 0, 12063, 12064, 7, 0, 0, 0, 12064, 12065, + 7, 1, 0, 0, 12065, 12066, 7, 11, 0, 0, 12066, 12067, 7, 6, 0, 0, 12067, + 1760, 1, 0, 0, 0, 12068, 12069, 7, 9, 0, 0, 12069, 12070, 7, 6, 0, 0, 12070, + 12071, 7, 17, 0, 0, 12071, 12072, 7, 0, 0, 0, 12072, 12073, 7, 10, 0, 0, + 12073, 12074, 7, 4, 0, 0, 12074, 12075, 7, 8, 0, 0, 12075, 12076, 7, 13, + 0, 0, 12076, 12077, 7, 9, 0, 0, 12077, 12078, 7, 8, 0, 0, 12078, 12079, + 7, 17, 0, 0, 12079, 12080, 7, 8, 0, 0, 12080, 12081, 7, 11, 0, 0, 12081, + 12082, 7, 0, 0, 0, 12082, 12083, 7, 3, 0, 0, 12083, 12084, 7, 8, 0, 0, + 12084, 12085, 7, 4, 0, 0, 12085, 12086, 7, 16, 0, 0, 12086, 12087, 7, 14, + 0, 0, 12087, 12088, 7, 6, 0, 0, 12088, 12089, 7, 4, 0, 0, 12089, 12090, + 7, 0, 0, 0, 12090, 12091, 7, 8, 0, 0, 12091, 12092, 7, 11, 0, 0, 12092, + 12093, 7, 9, 0, 0, 12093, 12094, 7, 4, 0, 0, 12094, 12095, 7, 0, 0, 0, + 12095, 12096, 7, 1, 0, 0, 12096, 12097, 7, 11, 0, 0, 12097, 12098, 7, 6, + 0, 0, 12098, 1762, 1, 0, 0, 0, 12099, 12100, 7, 9, 0, 0, 12100, 12101, + 7, 6, 0, 0, 12101, 12102, 7, 17, 0, 0, 12102, 12103, 7, 0, 0, 0, 12103, + 12104, 7, 10, 0, 0, 12104, 12105, 7, 4, 0, 0, 12105, 12106, 7, 8, 0, 0, + 12106, 12107, 7, 13, 0, 0, 12107, 12108, 7, 9, 0, 0, 12108, 12109, 7, 8, + 0, 0, 12109, 12110, 7, 17, 0, 0, 12110, 12111, 7, 8, 0, 0, 12111, 12112, + 7, 11, 0, 0, 12112, 12113, 7, 0, 0, 0, 12113, 12114, 7, 3, 0, 0, 12114, + 12115, 7, 8, 0, 0, 12115, 12116, 7, 4, 0, 0, 12116, 12117, 7, 16, 0, 0, + 12117, 12118, 7, 4, 0, 0, 12118, 12119, 7, 0, 0, 0, 12119, 12120, 7, 1, + 0, 0, 12120, 12121, 7, 11, 0, 0, 12121, 12122, 7, 6, 0, 0, 12122, 1764, + 1, 0, 0, 0, 12123, 12124, 7, 9, 0, 0, 12124, 12125, 7, 6, 0, 0, 12125, + 12126, 7, 17, 0, 0, 12126, 12127, 7, 8, 0, 0, 12127, 12128, 5, 95, 0, 0, + 12128, 12129, 7, 9, 0, 0, 12129, 12130, 7, 6, 0, 0, 12130, 12131, 7, 10, + 0, 0, 12131, 12132, 7, 9, 0, 0, 12132, 12133, 7, 8, 0, 0, 12133, 12134, + 7, 4, 0, 0, 12134, 12135, 7, 8, 0, 0, 12135, 12136, 7, 15, 0, 0, 12136, + 12137, 7, 6, 0, 0, 12137, 1766, 1, 0, 0, 0, 12138, 12139, 7, 9, 0, 0, 12139, + 12140, 7, 6, 0, 0, 12140, 12141, 7, 10, 0, 0, 12141, 12142, 7, 14, 0, 0, + 12142, 1768, 1, 0, 0, 0, 12143, 12144, 7, 9, 0, 0, 12144, 12145, 7, 6, + 0, 0, 12145, 12146, 7, 10, 0, 0, 12146, 12147, 7, 4, 0, 0, 12147, 1770, + 1, 0, 0, 0, 12148, 12149, 7, 9, 0, 0, 12149, 12150, 7, 6, 0, 0, 12150, + 12151, 7, 25, 0, 0, 12151, 12152, 7, 12, 0, 0, 12152, 12153, 7, 6, 0, 0, + 12153, 12154, 7, 10, 0, 0, 12154, 12155, 7, 13, 0, 0, 12155, 12156, 7, + 6, 0, 0, 12156, 1772, 1, 0, 0, 0, 12157, 12158, 7, 9, 0, 0, 12158, 12159, + 7, 6, 0, 0, 12159, 12160, 7, 25, 0, 0, 12160, 12161, 7, 12, 0, 0, 12161, + 12162, 7, 6, 0, 0, 12162, 12163, 7, 10, 0, 0, 12163, 12164, 7, 13, 0, 0, + 12164, 12165, 7, 6, 0, 0, 12165, 12166, 5, 95, 0, 0, 12166, 12167, 7, 10, + 0, 0, 12167, 12168, 7, 12, 0, 0, 12168, 12169, 7, 17, 0, 0, 12169, 12170, + 7, 1, 0, 0, 12170, 12171, 7, 6, 0, 0, 12171, 12172, 7, 3, 0, 0, 12172, + 1774, 1, 0, 0, 0, 12173, 12174, 7, 9, 0, 0, 12174, 12175, 7, 6, 0, 0, 12175, + 12176, 7, 3, 0, 0, 12176, 12177, 7, 8, 0, 0, 12177, 12178, 7, 0, 0, 0, + 12178, 12179, 7, 11, 0, 0, 12179, 12180, 7, 8, 0, 0, 12180, 12181, 7, 23, + 0, 0, 12181, 12182, 7, 0, 0, 0, 12182, 12183, 7, 1, 0, 0, 12183, 12184, + 7, 11, 0, 0, 12184, 12185, 7, 6, 0, 0, 12185, 1776, 1, 0, 0, 0, 12186, + 12187, 7, 9, 0, 0, 12187, 12188, 7, 6, 0, 0, 12188, 12189, 7, 3, 0, 0, + 12189, 12190, 7, 15, 0, 0, 12190, 12191, 7, 6, 0, 0, 12191, 12192, 7, 3, + 0, 0, 12192, 1778, 1, 0, 0, 0, 12193, 12194, 7, 9, 0, 0, 12194, 12195, + 7, 6, 0, 0, 12195, 12196, 7, 3, 0, 0, 12196, 12197, 7, 15, 0, 0, 12197, + 12198, 7, 6, 0, 0, 12198, 12199, 7, 3, 0, 0, 12199, 12200, 7, 20, 0, 0, + 12200, 12201, 7, 3, 0, 0, 12201, 12202, 7, 2, 0, 0, 12202, 12203, 7, 20, + 0, 0, 12203, 12204, 7, 6, 0, 0, 12204, 12205, 7, 3, 0, 0, 12205, 12206, + 7, 4, 0, 0, 12206, 12207, 7, 16, 0, 0, 12207, 1780, 1, 0, 0, 0, 12208, + 12209, 7, 9, 0, 0, 12209, 12210, 7, 6, 0, 0, 12210, 12211, 7, 3, 0, 0, + 12211, 12212, 7, 15, 0, 0, 12212, 12213, 7, 8, 0, 0, 12213, 12214, 7, 13, + 0, 0, 12214, 12215, 7, 6, 0, 0, 12215, 1782, 1, 0, 0, 0, 12216, 12217, + 7, 9, 0, 0, 12217, 12218, 7, 6, 0, 0, 12218, 12219, 7, 3, 0, 0, 12219, + 12220, 7, 15, 0, 0, 12220, 12221, 7, 8, 0, 0, 12221, 12222, 7, 13, 0, 0, + 12222, 12223, 7, 6, 0, 0, 12223, 12224, 7, 1, 0, 0, 12224, 12225, 7, 3, + 0, 0, 12225, 12226, 7, 2, 0, 0, 12226, 12227, 7, 21, 0, 0, 12227, 12228, + 7, 6, 0, 0, 12228, 12229, 7, 3, 0, 0, 12229, 1784, 1, 0, 0, 0, 12230, 12231, + 7, 9, 0, 0, 12231, 12232, 7, 6, 0, 0, 12232, 12233, 7, 3, 0, 0, 12233, + 12234, 7, 15, 0, 0, 12234, 12235, 7, 8, 0, 0, 12235, 12236, 7, 13, 0, 0, + 12236, 12237, 7, 6, 0, 0, 12237, 12238, 5, 95, 0, 0, 12238, 12239, 7, 1, + 0, 0, 12239, 12240, 7, 3, 0, 0, 12240, 12241, 7, 2, 0, 0, 12241, 12242, + 7, 21, 0, 0, 12242, 12243, 7, 6, 0, 0, 12243, 12244, 7, 3, 0, 0, 12244, + 1786, 1, 0, 0, 0, 12245, 12246, 7, 9, 0, 0, 12246, 12247, 7, 6, 0, 0, 12247, + 12248, 7, 3, 0, 0, 12248, 12249, 7, 15, 0, 0, 12249, 12250, 7, 8, 0, 0, + 12250, 12251, 7, 13, 0, 0, 12251, 12252, 7, 6, 0, 0, 12252, 12253, 5, 95, + 0, 0, 12253, 12254, 7, 10, 0, 0, 12254, 12255, 7, 0, 0, 0, 12255, 12256, + 7, 17, 0, 0, 12256, 12257, 7, 6, 0, 0, 12257, 1788, 1, 0, 0, 0, 12258, + 12259, 7, 9, 0, 0, 12259, 12260, 7, 6, 0, 0, 12260, 12261, 7, 9, 0, 0, + 12261, 12262, 7, 9, 0, 0, 12262, 12263, 7, 8, 0, 0, 12263, 12264, 7, 2, + 0, 0, 12264, 12265, 7, 10, 0, 0, 12265, 1790, 1, 0, 0, 0, 12266, 12267, + 7, 9, 0, 0, 12267, 12268, 7, 6, 0, 0, 12268, 12269, 7, 9, 0, 0, 12269, + 12270, 7, 9, 0, 0, 12270, 12271, 7, 8, 0, 0, 12271, 12272, 7, 2, 0, 0, + 12272, 12273, 7, 10, 0, 0, 12273, 12274, 7, 20, 0, 0, 12274, 12275, 7, + 3, 0, 0, 12275, 12276, 7, 2, 0, 0, 12276, 12277, 7, 20, 0, 0, 12277, 12278, + 7, 6, 0, 0, 12278, 12279, 7, 3, 0, 0, 12279, 12280, 7, 4, 0, 0, 12280, + 12281, 7, 16, 0, 0, 12281, 1792, 1, 0, 0, 0, 12282, 12283, 7, 9, 0, 0, + 12283, 12284, 7, 6, 0, 0, 12284, 12285, 7, 9, 0, 0, 12285, 12286, 7, 9, + 0, 0, 12286, 12287, 7, 8, 0, 0, 12287, 12288, 7, 2, 0, 0, 12288, 12289, + 7, 10, 0, 0, 12289, 12290, 5, 95, 0, 0, 12290, 12291, 7, 13, 0, 0, 12291, + 12292, 7, 2, 0, 0, 12292, 12293, 7, 10, 0, 0, 12293, 12294, 7, 4, 0, 0, + 12294, 12295, 7, 6, 0, 0, 12295, 12296, 7, 22, 0, 0, 12296, 12297, 7, 4, + 0, 0, 12297, 1794, 1, 0, 0, 0, 12298, 12299, 7, 9, 0, 0, 12299, 12300, + 7, 6, 0, 0, 12300, 12301, 7, 9, 0, 0, 12301, 12302, 7, 9, 0, 0, 12302, + 12303, 7, 8, 0, 0, 12303, 12304, 7, 2, 0, 0, 12304, 12305, 7, 10, 0, 0, + 12305, 12306, 5, 95, 0, 0, 12306, 12307, 7, 4, 0, 0, 12307, 12308, 7, 8, + 0, 0, 12308, 12309, 7, 17, 0, 0, 12309, 12310, 7, 6, 0, 0, 12310, 12311, + 7, 2, 0, 0, 12311, 12312, 7, 12, 0, 0, 12312, 12313, 7, 4, 0, 0, 12313, + 1796, 1, 0, 0, 0, 12314, 12315, 7, 9, 0, 0, 12315, 12316, 7, 6, 0, 0, 12316, + 12317, 7, 9, 0, 0, 12317, 12318, 7, 9, 0, 0, 12318, 12319, 7, 8, 0, 0, + 12319, 12320, 7, 2, 0, 0, 12320, 12321, 7, 10, 0, 0, 12321, 12322, 5, 95, + 0, 0, 12322, 12323, 7, 12, 0, 0, 12323, 12324, 7, 9, 0, 0, 12324, 12325, + 7, 6, 0, 0, 12325, 12326, 7, 3, 0, 0, 12326, 1798, 1, 0, 0, 0, 12327, 12328, + 7, 9, 0, 0, 12328, 12329, 7, 6, 0, 0, 12329, 12330, 7, 4, 0, 0, 12330, + 1800, 1, 0, 0, 0, 12331, 12332, 7, 9, 0, 0, 12332, 12333, 7, 6, 0, 0, 12333, + 12334, 7, 4, 0, 0, 12334, 12335, 7, 6, 0, 0, 12335, 12336, 7, 3, 0, 0, + 12336, 12337, 7, 3, 0, 0, 12337, 12338, 7, 2, 0, 0, 12338, 12339, 7, 3, + 0, 0, 12339, 1802, 1, 0, 0, 0, 12340, 12341, 7, 9, 0, 0, 12341, 12342, + 7, 6, 0, 0, 12342, 12343, 7, 4, 0, 0, 12343, 12344, 7, 9, 0, 0, 12344, + 1804, 1, 0, 0, 0, 12345, 12346, 7, 9, 0, 0, 12346, 12347, 7, 6, 0, 0, 12347, + 12348, 7, 4, 0, 0, 12348, 12349, 7, 4, 0, 0, 12349, 12350, 7, 8, 0, 0, + 12350, 12351, 7, 10, 0, 0, 12351, 12352, 7, 18, 0, 0, 12352, 12353, 7, + 9, 0, 0, 12353, 1806, 1, 0, 0, 0, 12354, 12355, 7, 9, 0, 0, 12355, 12356, + 7, 6, 0, 0, 12356, 12357, 7, 4, 0, 0, 12357, 12358, 7, 12, 0, 0, 12358, + 12359, 7, 9, 0, 0, 12359, 12360, 7, 6, 0, 0, 12360, 12361, 7, 3, 0, 0, + 12361, 1808, 1, 0, 0, 0, 12362, 12363, 7, 9, 0, 0, 12363, 12364, 7, 19, + 0, 0, 12364, 12365, 7, 0, 0, 0, 12365, 12366, 7, 3, 0, 0, 12366, 12367, + 7, 6, 0, 0, 12367, 1810, 1, 0, 0, 0, 12368, 12369, 7, 9, 0, 0, 12369, 12370, + 7, 19, 0, 0, 12370, 12371, 7, 0, 0, 0, 12371, 12372, 7, 3, 0, 0, 12372, + 12373, 7, 6, 0, 0, 12373, 12374, 7, 14, 0, 0, 12374, 1812, 1, 0, 0, 0, + 12375, 12376, 7, 9, 0, 0, 12376, 12377, 7, 19, 0, 0, 12377, 12378, 7, 2, + 0, 0, 12378, 12379, 7, 7, 0, 0, 12379, 12380, 7, 13, 0, 0, 12380, 12381, + 7, 2, 0, 0, 12381, 12382, 7, 10, 0, 0, 12382, 12383, 7, 4, 0, 0, 12383, + 12384, 7, 8, 0, 0, 12384, 12385, 7, 18, 0, 0, 12385, 1814, 1, 0, 0, 0, + 12386, 12387, 7, 9, 0, 0, 12387, 12388, 7, 19, 0, 0, 12388, 12389, 7, 2, + 0, 0, 12389, 12390, 7, 7, 0, 0, 12390, 12391, 7, 20, 0, 0, 12391, 12392, + 7, 11, 0, 0, 12392, 12393, 7, 0, 0, 0, 12393, 12394, 7, 10, 0, 0, 12394, + 1816, 1, 0, 0, 0, 12395, 12396, 7, 9, 0, 0, 12396, 12397, 7, 19, 0, 0, + 12397, 12398, 7, 2, 0, 0, 12398, 12399, 7, 7, 0, 0, 12399, 12400, 7, 20, + 0, 0, 12400, 12401, 7, 11, 0, 0, 12401, 12402, 7, 0, 0, 0, 12402, 12403, + 7, 10, 0, 0, 12403, 12404, 5, 95, 0, 0, 12404, 12405, 7, 0, 0, 0, 12405, + 12406, 7, 11, 0, 0, 12406, 12407, 7, 11, 0, 0, 12407, 1818, 1, 0, 0, 0, + 12408, 12409, 7, 9, 0, 0, 12409, 12410, 7, 19, 0, 0, 12410, 12411, 7, 2, + 0, 0, 12411, 12412, 7, 7, 0, 0, 12412, 12413, 7, 20, 0, 0, 12413, 12414, + 7, 11, 0, 0, 12414, 12415, 7, 0, 0, 0, 12415, 12416, 7, 10, 0, 0, 12416, + 12417, 5, 95, 0, 0, 12417, 12418, 7, 4, 0, 0, 12418, 12419, 7, 6, 0, 0, + 12419, 12420, 7, 22, 0, 0, 12420, 12421, 7, 4, 0, 0, 12421, 1820, 1, 0, + 0, 0, 12422, 12423, 7, 9, 0, 0, 12423, 12424, 7, 19, 0, 0, 12424, 12425, + 7, 2, 0, 0, 12425, 12426, 7, 7, 0, 0, 12426, 12427, 7, 20, 0, 0, 12427, + 12428, 7, 11, 0, 0, 12428, 12429, 7, 0, 0, 0, 12429, 12430, 7, 10, 0, 0, + 12430, 12431, 5, 95, 0, 0, 12431, 12432, 7, 22, 0, 0, 12432, 12433, 7, + 17, 0, 0, 12433, 12434, 7, 11, 0, 0, 12434, 1822, 1, 0, 0, 0, 12435, 12436, + 7, 9, 0, 0, 12436, 12437, 7, 19, 0, 0, 12437, 12438, 7, 3, 0, 0, 12438, + 12439, 7, 8, 0, 0, 12439, 12440, 7, 10, 0, 0, 12440, 12441, 7, 21, 0, 0, + 12441, 12442, 7, 11, 0, 0, 12442, 12443, 7, 2, 0, 0, 12443, 12444, 7, 18, + 0, 0, 12444, 1824, 1, 0, 0, 0, 12445, 12446, 7, 9, 0, 0, 12446, 12447, + 7, 19, 0, 0, 12447, 12448, 7, 12, 0, 0, 12448, 12449, 7, 4, 0, 0, 12449, + 12450, 7, 14, 0, 0, 12450, 12451, 7, 2, 0, 0, 12451, 12452, 7, 7, 0, 0, + 12452, 12453, 7, 10, 0, 0, 12453, 1826, 1, 0, 0, 0, 12454, 12455, 7, 9, + 0, 0, 12455, 12456, 7, 8, 0, 0, 12456, 12457, 7, 14, 0, 0, 12457, 1828, + 1, 0, 0, 0, 12458, 12459, 7, 9, 0, 0, 12459, 12460, 7, 8, 0, 0, 12460, + 12461, 7, 18, 0, 0, 12461, 12462, 7, 10, 0, 0, 12462, 12463, 7, 0, 0, 0, + 12463, 12464, 7, 4, 0, 0, 12464, 12465, 7, 12, 0, 0, 12465, 12466, 7, 3, + 0, 0, 12466, 12467, 7, 6, 0, 0, 12467, 1830, 1, 0, 0, 0, 12468, 12469, + 7, 9, 0, 0, 12469, 12470, 7, 8, 0, 0, 12470, 12471, 7, 17, 0, 0, 12471, + 12472, 7, 20, 0, 0, 12472, 12473, 7, 11, 0, 0, 12473, 12474, 7, 6, 0, 0, + 12474, 1832, 1, 0, 0, 0, 12475, 12476, 7, 9, 0, 0, 12476, 12477, 7, 8, + 0, 0, 12477, 12478, 7, 10, 0, 0, 12478, 12479, 7, 18, 0, 0, 12479, 12480, + 7, 11, 0, 0, 12480, 12481, 7, 6, 0, 0, 12481, 12482, 5, 95, 0, 0, 12482, + 12483, 7, 12, 0, 0, 12483, 12484, 7, 9, 0, 0, 12484, 12485, 7, 6, 0, 0, + 12485, 12486, 7, 3, 0, 0, 12486, 1834, 1, 0, 0, 0, 12487, 12488, 7, 9, + 0, 0, 12488, 12489, 7, 8, 0, 0, 12489, 12490, 7, 23, 0, 0, 12490, 12491, + 7, 6, 0, 0, 12491, 1836, 1, 0, 0, 0, 12492, 12493, 7, 9, 0, 0, 12493, 12494, + 7, 21, 0, 0, 12494, 12495, 7, 8, 0, 0, 12495, 12496, 7, 20, 0, 0, 12496, + 1838, 1, 0, 0, 0, 12497, 12498, 7, 9, 0, 0, 12498, 12499, 7, 17, 0, 0, + 12499, 12500, 7, 0, 0, 0, 12500, 12501, 7, 11, 0, 0, 12501, 12502, 7, 11, + 0, 0, 12502, 12503, 7, 8, 0, 0, 12503, 12504, 7, 10, 0, 0, 12504, 12505, + 7, 4, 0, 0, 12505, 1840, 1, 0, 0, 0, 12506, 12507, 7, 9, 0, 0, 12507, 12508, + 7, 10, 0, 0, 12508, 12509, 7, 0, 0, 0, 12509, 12510, 7, 20, 0, 0, 12510, + 12511, 7, 9, 0, 0, 12511, 12512, 7, 19, 0, 0, 12512, 12513, 7, 2, 0, 0, + 12513, 12514, 7, 4, 0, 0, 12514, 1842, 1, 0, 0, 0, 12515, 12516, 7, 9, + 0, 0, 12516, 12517, 7, 2, 0, 0, 12517, 12518, 7, 5, 0, 0, 12518, 12519, + 7, 4, 0, 0, 12519, 12520, 7, 10, 0, 0, 12520, 12521, 7, 12, 0, 0, 12521, + 12522, 7, 17, 0, 0, 12522, 12523, 7, 0, 0, 0, 12523, 1844, 1, 0, 0, 0, + 12524, 12525, 7, 9, 0, 0, 12525, 12526, 7, 2, 0, 0, 12526, 12527, 7, 17, + 0, 0, 12527, 12528, 7, 6, 0, 0, 12528, 1846, 1, 0, 0, 0, 12529, 12530, + 7, 9, 0, 0, 12530, 12531, 7, 2, 0, 0, 12531, 12532, 7, 3, 0, 0, 12532, + 12533, 7, 4, 0, 0, 12533, 12534, 5, 95, 0, 0, 12534, 12535, 7, 8, 0, 0, + 12535, 12536, 7, 10, 0, 0, 12536, 12537, 5, 95, 0, 0, 12537, 12538, 7, + 4, 0, 0, 12538, 12539, 7, 6, 0, 0, 12539, 12540, 7, 17, 0, 0, 12540, 12541, + 7, 20, 0, 0, 12541, 12542, 7, 14, 0, 0, 12542, 12543, 7, 1, 0, 0, 12543, + 1848, 1, 0, 0, 0, 12544, 12545, 7, 9, 0, 0, 12545, 12546, 7, 2, 0, 0, 12546, + 12547, 7, 12, 0, 0, 12547, 12548, 7, 10, 0, 0, 12548, 12549, 7, 14, 0, + 0, 12549, 12550, 7, 6, 0, 0, 12550, 12551, 7, 22, 0, 0, 12551, 1850, 1, + 0, 0, 0, 12552, 12553, 7, 9, 0, 0, 12553, 12554, 7, 2, 0, 0, 12554, 12555, + 7, 12, 0, 0, 12555, 12556, 7, 3, 0, 0, 12556, 12557, 7, 13, 0, 0, 12557, + 12558, 7, 6, 0, 0, 12558, 1852, 1, 0, 0, 0, 12559, 12560, 7, 9, 0, 0, 12560, + 12561, 7, 20, 0, 0, 12561, 12562, 7, 0, 0, 0, 12562, 12563, 7, 13, 0, 0, + 12563, 12564, 7, 6, 0, 0, 12564, 1854, 1, 0, 0, 0, 12565, 12566, 7, 9, + 0, 0, 12566, 12567, 7, 20, 0, 0, 12567, 12568, 7, 0, 0, 0, 12568, 12569, + 7, 3, 0, 0, 12569, 12570, 7, 9, 0, 0, 12570, 12571, 7, 6, 0, 0, 12571, + 1856, 1, 0, 0, 0, 12572, 12573, 7, 9, 0, 0, 12573, 12574, 7, 20, 0, 0, + 12574, 12575, 7, 0, 0, 0, 12575, 12576, 7, 4, 0, 0, 12576, 12577, 7, 8, + 0, 0, 12577, 12578, 7, 0, 0, 0, 12578, 12579, 7, 11, 0, 0, 12579, 1858, + 1, 0, 0, 0, 12580, 12581, 7, 9, 0, 0, 12581, 12582, 7, 20, 0, 0, 12582, + 12583, 7, 0, 0, 0, 12583, 12584, 7, 4, 0, 0, 12584, 12585, 7, 8, 0, 0, + 12585, 12586, 7, 0, 0, 0, 12586, 12587, 7, 11, 0, 0, 12587, 12588, 5, 95, + 0, 0, 12588, 12589, 7, 7, 0, 0, 12589, 12590, 7, 8, 0, 0, 12590, 12591, + 7, 10, 0, 0, 12591, 12592, 7, 14, 0, 0, 12592, 12593, 7, 2, 0, 0, 12593, + 12594, 7, 7, 0, 0, 12594, 12595, 5, 95, 0, 0, 12595, 12596, 7, 17, 0, 0, + 12596, 12597, 7, 0, 0, 0, 12597, 12598, 7, 22, 0, 0, 12598, 12599, 5, 95, + 0, 0, 12599, 12600, 7, 13, 0, 0, 12600, 12601, 7, 6, 0, 0, 12601, 12602, + 7, 11, 0, 0, 12602, 12603, 7, 11, 0, 0, 12603, 12604, 7, 9, 0, 0, 12604, + 1860, 1, 0, 0, 0, 12605, 12606, 7, 9, 0, 0, 12606, 12607, 7, 20, 0, 0, + 12607, 12608, 7, 6, 0, 0, 12608, 12609, 7, 13, 0, 0, 12609, 12610, 7, 8, + 0, 0, 12610, 12611, 7, 5, 0, 0, 12611, 12612, 7, 8, 0, 0, 12612, 12613, + 7, 13, 0, 0, 12613, 12614, 7, 0, 0, 0, 12614, 12615, 7, 4, 0, 0, 12615, + 12616, 7, 8, 0, 0, 12616, 12617, 7, 2, 0, 0, 12617, 12618, 7, 10, 0, 0, + 12618, 1862, 1, 0, 0, 0, 12619, 12620, 7, 9, 0, 0, 12620, 12621, 7, 20, + 0, 0, 12621, 12622, 7, 11, 0, 0, 12622, 12623, 7, 8, 0, 0, 12623, 12624, + 7, 4, 0, 0, 12624, 1864, 1, 0, 0, 0, 12625, 12626, 7, 9, 0, 0, 12626, 12627, + 7, 25, 0, 0, 12627, 12628, 7, 11, 0, 0, 12628, 1866, 1, 0, 0, 0, 12629, + 12630, 7, 9, 0, 0, 12630, 12631, 7, 25, 0, 0, 12631, 12632, 7, 11, 0, 0, + 12632, 12633, 7, 14, 0, 0, 12633, 12634, 7, 12, 0, 0, 12634, 12635, 7, + 17, 0, 0, 12635, 12636, 7, 20, 0, 0, 12636, 12637, 7, 6, 0, 0, 12637, 12638, + 7, 3, 0, 0, 12638, 12639, 7, 5, 0, 0, 12639, 12640, 7, 11, 0, 0, 12640, + 12641, 7, 0, 0, 0, 12641, 12642, 7, 18, 0, 0, 12642, 12643, 7, 9, 0, 0, + 12643, 1868, 1, 0, 0, 0, 12644, 12645, 7, 9, 0, 0, 12645, 12646, 7, 25, + 0, 0, 12646, 12647, 7, 11, 0, 0, 12647, 12648, 7, 14, 0, 0, 12648, 12649, + 7, 12, 0, 0, 12649, 12650, 7, 17, 0, 0, 12650, 12651, 7, 20, 0, 0, 12651, + 12652, 7, 6, 0, 0, 12652, 12653, 7, 3, 0, 0, 12653, 12654, 7, 20, 0, 0, + 12654, 12655, 7, 0, 0, 0, 12655, 12656, 7, 4, 0, 0, 12656, 12657, 7, 19, + 0, 0, 12657, 1870, 1, 0, 0, 0, 12658, 12659, 7, 9, 0, 0, 12659, 12660, + 7, 25, 0, 0, 12660, 12661, 7, 11, 0, 0, 12661, 12662, 7, 14, 0, 0, 12662, + 12663, 7, 12, 0, 0, 12663, 12664, 7, 17, 0, 0, 12664, 12665, 7, 20, 0, + 0, 12665, 12666, 7, 6, 0, 0, 12666, 12667, 7, 3, 0, 0, 12667, 12668, 7, + 4, 0, 0, 12668, 12669, 7, 8, 0, 0, 12669, 12670, 7, 17, 0, 0, 12670, 12671, + 7, 6, 0, 0, 12671, 12672, 7, 2, 0, 0, 12672, 12673, 7, 12, 0, 0, 12673, + 12674, 7, 4, 0, 0, 12674, 1872, 1, 0, 0, 0, 12675, 12676, 7, 9, 0, 0, 12676, + 12677, 7, 25, 0, 0, 12677, 12678, 7, 11, 0, 0, 12678, 12679, 5, 95, 0, + 0, 12679, 12680, 7, 15, 0, 0, 12680, 12681, 7, 0, 0, 0, 12681, 12682, 7, + 3, 0, 0, 12682, 12683, 7, 8, 0, 0, 12683, 12684, 7, 0, 0, 0, 12684, 12685, + 7, 10, 0, 0, 12685, 12686, 7, 4, 0, 0, 12686, 12687, 5, 95, 0, 0, 12687, + 12688, 7, 20, 0, 0, 12688, 12689, 7, 3, 0, 0, 12689, 12690, 7, 2, 0, 0, + 12690, 12691, 7, 20, 0, 0, 12691, 12692, 7, 6, 0, 0, 12692, 12693, 7, 3, + 0, 0, 12693, 12694, 7, 4, 0, 0, 12694, 12695, 7, 16, 0, 0, 12695, 1874, + 1, 0, 0, 0, 12696, 12697, 7, 9, 0, 0, 12697, 12698, 7, 4, 0, 0, 12698, + 12699, 7, 0, 0, 0, 12699, 12700, 7, 10, 0, 0, 12700, 12701, 7, 14, 0, 0, + 12701, 12702, 7, 1, 0, 0, 12702, 12703, 7, 16, 0, 0, 12703, 1876, 1, 0, + 0, 0, 12704, 12705, 7, 9, 0, 0, 12705, 12706, 7, 4, 0, 0, 12706, 12707, + 7, 0, 0, 0, 12707, 12708, 7, 3, 0, 0, 12708, 12709, 7, 4, 0, 0, 12709, + 1878, 1, 0, 0, 0, 12710, 12711, 7, 9, 0, 0, 12711, 12712, 7, 4, 0, 0, 12712, + 12713, 7, 0, 0, 0, 12713, 12714, 7, 3, 0, 0, 12714, 12715, 7, 4, 0, 0, + 12715, 12716, 7, 6, 0, 0, 12716, 12717, 7, 14, 0, 0, 12717, 1880, 1, 0, + 0, 0, 12718, 12719, 7, 9, 0, 0, 12719, 12720, 7, 4, 0, 0, 12720, 12721, + 7, 0, 0, 0, 12721, 12722, 7, 3, 0, 0, 12722, 12723, 7, 4, 0, 0, 12723, + 12724, 7, 12, 0, 0, 12724, 12725, 7, 20, 0, 0, 12725, 12726, 5, 95, 0, + 0, 12726, 12727, 7, 9, 0, 0, 12727, 12728, 7, 4, 0, 0, 12728, 12729, 7, + 0, 0, 0, 12729, 12730, 7, 4, 0, 0, 12730, 12731, 7, 6, 0, 0, 12731, 1882, + 1, 0, 0, 0, 12732, 12733, 7, 9, 0, 0, 12733, 12734, 7, 4, 0, 0, 12734, + 12735, 7, 0, 0, 0, 12735, 12736, 7, 3, 0, 0, 12736, 12737, 7, 4, 0, 0, + 12737, 12738, 5, 95, 0, 0, 12738, 12739, 7, 14, 0, 0, 12739, 12740, 7, + 0, 0, 0, 12740, 12741, 7, 4, 0, 0, 12741, 12742, 7, 6, 0, 0, 12742, 1884, + 1, 0, 0, 0, 12743, 12744, 7, 9, 0, 0, 12744, 12745, 7, 4, 0, 0, 12745, + 12746, 7, 0, 0, 0, 12746, 12747, 7, 4, 0, 0, 12747, 12748, 7, 6, 0, 0, + 12748, 1886, 1, 0, 0, 0, 12749, 12750, 7, 9, 0, 0, 12750, 12751, 7, 4, + 0, 0, 12751, 12752, 7, 0, 0, 0, 12752, 12753, 7, 4, 0, 0, 12753, 12754, + 7, 8, 0, 0, 12754, 12755, 7, 13, 0, 0, 12755, 1888, 1, 0, 0, 0, 12756, + 12757, 7, 9, 0, 0, 12757, 12758, 7, 4, 0, 0, 12758, 12759, 7, 0, 0, 0, + 12759, 12760, 7, 4, 0, 0, 12760, 12761, 7, 8, 0, 0, 12761, 12762, 7, 9, + 0, 0, 12762, 12763, 7, 4, 0, 0, 12763, 12764, 7, 8, 0, 0, 12764, 12765, + 7, 13, 0, 0, 12765, 12766, 7, 9, 0, 0, 12766, 1890, 1, 0, 0, 0, 12767, + 12768, 7, 9, 0, 0, 12768, 12769, 7, 4, 0, 0, 12769, 12770, 7, 0, 0, 0, + 12770, 12771, 7, 4, 0, 0, 12771, 12772, 7, 8, 0, 0, 12772, 12773, 7, 9, + 0, 0, 12773, 12774, 7, 4, 0, 0, 12774, 12775, 7, 8, 0, 0, 12775, 12776, + 7, 13, 0, 0, 12776, 12777, 7, 9, 0, 0, 12777, 12778, 5, 95, 0, 0, 12778, + 12779, 7, 8, 0, 0, 12779, 12780, 7, 10, 0, 0, 12780, 12781, 7, 13, 0, 0, + 12781, 12782, 7, 3, 0, 0, 12782, 12783, 7, 6, 0, 0, 12783, 12784, 7, 17, + 0, 0, 12784, 12785, 7, 6, 0, 0, 12785, 12786, 7, 10, 0, 0, 12786, 12787, + 7, 4, 0, 0, 12787, 12788, 7, 0, 0, 0, 12788, 12789, 7, 11, 0, 0, 12789, + 1892, 1, 0, 0, 0, 12790, 12791, 7, 9, 0, 0, 12791, 12792, 7, 4, 0, 0, 12792, + 12793, 7, 0, 0, 0, 12793, 12794, 7, 4, 0, 0, 12794, 12795, 7, 8, 0, 0, + 12795, 12796, 7, 9, 0, 0, 12796, 12797, 7, 4, 0, 0, 12797, 12798, 7, 8, + 0, 0, 12798, 12799, 7, 13, 0, 0, 12799, 12800, 7, 9, 0, 0, 12800, 12801, + 5, 95, 0, 0, 12801, 12802, 7, 10, 0, 0, 12802, 12803, 7, 2, 0, 0, 12803, + 12804, 7, 3, 0, 0, 12804, 12805, 7, 6, 0, 0, 12805, 12806, 7, 13, 0, 0, + 12806, 12807, 7, 2, 0, 0, 12807, 12808, 7, 17, 0, 0, 12808, 12809, 7, 20, + 0, 0, 12809, 12810, 7, 12, 0, 0, 12810, 12811, 7, 4, 0, 0, 12811, 12812, + 7, 6, 0, 0, 12812, 1894, 1, 0, 0, 0, 12813, 12814, 7, 9, 0, 0, 12814, 12815, + 7, 4, 0, 0, 12815, 12816, 7, 0, 0, 0, 12816, 12817, 7, 4, 0, 0, 12817, + 12818, 7, 9, 0, 0, 12818, 1896, 1, 0, 0, 0, 12819, 12820, 7, 9, 0, 0, 12820, + 12821, 7, 4, 0, 0, 12821, 12822, 7, 0, 0, 0, 12822, 12823, 7, 4, 0, 0, + 12823, 12824, 7, 9, 0, 0, 12824, 12825, 5, 95, 0, 0, 12825, 12826, 7, 14, + 0, 0, 12826, 12827, 7, 0, 0, 0, 12827, 12828, 7, 4, 0, 0, 12828, 12829, + 7, 6, 0, 0, 12829, 1898, 1, 0, 0, 0, 12830, 12831, 7, 9, 0, 0, 12831, 12832, + 7, 4, 0, 0, 12832, 12833, 7, 0, 0, 0, 12833, 12834, 7, 4, 0, 0, 12834, + 12835, 7, 9, 0, 0, 12835, 12836, 5, 95, 0, 0, 12836, 12837, 7, 9, 0, 0, + 12837, 12838, 7, 4, 0, 0, 12838, 12839, 7, 3, 0, 0, 12839, 12840, 7, 6, + 0, 0, 12840, 12841, 7, 0, 0, 0, 12841, 12842, 7, 17, 0, 0, 12842, 1900, + 1, 0, 0, 0, 12843, 12844, 7, 9, 0, 0, 12844, 12845, 7, 4, 0, 0, 12845, + 12846, 7, 0, 0, 0, 12846, 12847, 7, 4, 0, 0, 12847, 12848, 7, 12, 0, 0, + 12848, 12849, 7, 9, 0, 0, 12849, 1902, 1, 0, 0, 0, 12850, 12851, 7, 9, + 0, 0, 12851, 12852, 7, 4, 0, 0, 12852, 12853, 7, 0, 0, 0, 12853, 12854, + 7, 4, 0, 0, 12854, 12855, 7, 12, 0, 0, 12855, 12856, 7, 9, 0, 0, 12856, + 12857, 7, 2, 0, 0, 12857, 12858, 7, 10, 0, 0, 12858, 12859, 7, 11, 0, 0, + 12859, 12860, 7, 16, 0, 0, 12860, 1904, 1, 0, 0, 0, 12861, 12862, 7, 9, + 0, 0, 12862, 12863, 7, 4, 0, 0, 12863, 12864, 7, 14, 0, 0, 12864, 12865, + 7, 6, 0, 0, 12865, 12866, 7, 15, 0, 0, 12866, 1906, 1, 0, 0, 0, 12867, + 12868, 7, 9, 0, 0, 12868, 12869, 7, 4, 0, 0, 12869, 12870, 7, 14, 0, 0, + 12870, 12871, 7, 6, 0, 0, 12871, 12872, 7, 15, 0, 0, 12872, 12873, 7, 20, + 0, 0, 12873, 1908, 1, 0, 0, 0, 12874, 12875, 7, 9, 0, 0, 12875, 12876, + 7, 4, 0, 0, 12876, 12877, 7, 2, 0, 0, 12877, 12878, 7, 20, 0, 0, 12878, + 1910, 1, 0, 0, 0, 12879, 12880, 7, 9, 0, 0, 12880, 12881, 7, 4, 0, 0, 12881, + 12882, 7, 2, 0, 0, 12882, 12883, 7, 20, 0, 0, 12883, 12884, 7, 11, 0, 0, + 12884, 12885, 7, 8, 0, 0, 12885, 12886, 7, 9, 0, 0, 12886, 12887, 7, 4, + 0, 0, 12887, 1912, 1, 0, 0, 0, 12888, 12889, 7, 9, 0, 0, 12889, 12890, + 7, 4, 0, 0, 12890, 12891, 7, 2, 0, 0, 12891, 12892, 7, 20, 0, 0, 12892, + 12893, 7, 20, 0, 0, 12893, 12894, 7, 6, 0, 0, 12894, 12895, 7, 14, 0, 0, + 12895, 1914, 1, 0, 0, 0, 12896, 12897, 7, 9, 0, 0, 12897, 12898, 7, 4, + 0, 0, 12898, 12899, 7, 2, 0, 0, 12899, 12900, 7, 20, 0, 0, 12900, 12901, + 5, 95, 0, 0, 12901, 12902, 7, 2, 0, 0, 12902, 12903, 7, 10, 0, 0, 12903, + 12904, 5, 95, 0, 0, 12904, 12905, 7, 6, 0, 0, 12905, 12906, 7, 3, 0, 0, + 12906, 12907, 7, 3, 0, 0, 12907, 12908, 7, 2, 0, 0, 12908, 12909, 7, 3, + 0, 0, 12909, 1916, 1, 0, 0, 0, 12910, 12911, 7, 9, 0, 0, 12911, 12912, + 7, 4, 0, 0, 12912, 12913, 7, 3, 0, 0, 12913, 1918, 1, 0, 0, 0, 12914, 12915, + 7, 9, 0, 0, 12915, 12916, 7, 4, 0, 0, 12916, 12917, 7, 3, 0, 0, 12917, + 12918, 7, 8, 0, 0, 12918, 12919, 7, 10, 0, 0, 12919, 12920, 7, 18, 0, 0, + 12920, 12921, 5, 95, 0, 0, 12921, 12922, 7, 0, 0, 0, 12922, 12923, 7, 18, + 0, 0, 12923, 12924, 7, 18, 0, 0, 12924, 1920, 1, 0, 0, 0, 12925, 12926, + 7, 9, 0, 0, 12926, 12927, 7, 4, 0, 0, 12927, 12928, 7, 3, 0, 0, 12928, + 12929, 7, 8, 0, 0, 12929, 12930, 7, 10, 0, 0, 12930, 12931, 7, 18, 0, 0, + 12931, 12932, 5, 95, 0, 0, 12932, 12933, 7, 6, 0, 0, 12933, 12934, 7, 9, + 0, 0, 12934, 12935, 7, 13, 0, 0, 12935, 12936, 7, 0, 0, 0, 12936, 12937, + 7, 20, 0, 0, 12937, 12938, 7, 6, 0, 0, 12938, 1922, 1, 0, 0, 0, 12939, + 12940, 7, 9, 0, 0, 12940, 12941, 7, 4, 0, 0, 12941, 12942, 7, 12, 0, 0, + 12942, 12943, 7, 5, 0, 0, 12943, 12944, 7, 5, 0, 0, 12944, 1924, 1, 0, + 0, 0, 12945, 12946, 7, 9, 0, 0, 12946, 12947, 7, 12, 0, 0, 12947, 12948, + 7, 1, 0, 0, 12948, 12949, 7, 24, 0, 0, 12949, 12950, 7, 6, 0, 0, 12950, + 12951, 7, 13, 0, 0, 12951, 12952, 7, 4, 0, 0, 12952, 1926, 1, 0, 0, 0, + 12953, 12954, 7, 9, 0, 0, 12954, 12955, 7, 12, 0, 0, 12955, 12956, 7, 1, + 0, 0, 12956, 12957, 7, 9, 0, 0, 12957, 12958, 7, 13, 0, 0, 12958, 12959, + 7, 3, 0, 0, 12959, 12960, 7, 8, 0, 0, 12960, 12961, 7, 1, 0, 0, 12961, + 12962, 7, 6, 0, 0, 12962, 1928, 1, 0, 0, 0, 12963, 12964, 7, 9, 0, 0, 12964, + 12965, 7, 12, 0, 0, 12965, 12966, 7, 1, 0, 0, 12966, 12967, 7, 9, 0, 0, + 12967, 12968, 7, 13, 0, 0, 12968, 12969, 7, 3, 0, 0, 12969, 12970, 7, 8, + 0, 0, 12970, 12971, 7, 20, 0, 0, 12971, 12972, 7, 4, 0, 0, 12972, 12973, + 7, 8, 0, 0, 12973, 12974, 7, 2, 0, 0, 12974, 12975, 7, 10, 0, 0, 12975, + 1930, 1, 0, 0, 0, 12976, 12977, 7, 9, 0, 0, 12977, 12978, 7, 12, 0, 0, + 12978, 12979, 7, 1, 0, 0, 12979, 12980, 7, 9, 0, 0, 12980, 12981, 7, 4, + 0, 0, 12981, 12982, 7, 3, 0, 0, 12982, 12983, 7, 8, 0, 0, 12983, 12984, + 7, 10, 0, 0, 12984, 12985, 7, 18, 0, 0, 12985, 1932, 1, 0, 0, 0, 12986, + 12987, 7, 9, 0, 0, 12987, 12988, 7, 12, 0, 0, 12988, 12989, 7, 17, 0, 0, + 12989, 1934, 1, 0, 0, 0, 12990, 12991, 7, 9, 0, 0, 12991, 12992, 7, 12, + 0, 0, 12992, 12993, 7, 20, 0, 0, 12993, 12994, 7, 20, 0, 0, 12994, 12995, + 7, 2, 0, 0, 12995, 12996, 7, 3, 0, 0, 12996, 12997, 7, 4, 0, 0, 12997, + 12998, 7, 6, 0, 0, 12998, 12999, 7, 14, 0, 0, 12999, 1936, 1, 0, 0, 0, + 13000, 13001, 7, 9, 0, 0, 13001, 13002, 7, 12, 0, 0, 13002, 13003, 7, 9, + 0, 0, 13003, 13004, 7, 6, 0, 0, 13004, 13005, 7, 3, 0, 0, 13005, 13006, + 5, 95, 0, 0, 13006, 13007, 7, 8, 0, 0, 13007, 13008, 7, 14, 0, 0, 13008, + 1938, 1, 0, 0, 0, 13009, 13010, 7, 9, 0, 0, 13010, 13011, 7, 12, 0, 0, + 13011, 13012, 7, 9, 0, 0, 13012, 13013, 7, 6, 0, 0, 13013, 13014, 7, 3, + 0, 0, 13014, 13015, 5, 95, 0, 0, 13015, 13016, 7, 10, 0, 0, 13016, 13017, + 7, 0, 0, 0, 13017, 13018, 7, 17, 0, 0, 13018, 13019, 7, 6, 0, 0, 13019, + 1940, 1, 0, 0, 0, 13020, 13021, 7, 9, 0, 0, 13021, 13022, 7, 12, 0, 0, + 13022, 13023, 7, 9, 0, 0, 13023, 13024, 7, 6, 0, 0, 13024, 13025, 7, 3, + 0, 0, 13025, 13026, 5, 95, 0, 0, 13026, 13027, 7, 9, 0, 0, 13027, 13028, + 7, 8, 0, 0, 13028, 13029, 7, 14, 0, 0, 13029, 1942, 1, 0, 0, 0, 13030, + 13031, 7, 9, 0, 0, 13031, 13032, 7, 12, 0, 0, 13032, 13033, 7, 9, 0, 0, + 13033, 13034, 7, 6, 0, 0, 13034, 13035, 7, 3, 0, 0, 13035, 13036, 5, 95, + 0, 0, 13036, 13037, 7, 9, 0, 0, 13037, 13038, 7, 10, 0, 0, 13038, 13039, + 7, 0, 0, 0, 13039, 13040, 7, 17, 0, 0, 13040, 13041, 7, 6, 0, 0, 13041, + 1944, 1, 0, 0, 0, 13042, 13043, 7, 9, 0, 0, 13043, 13044, 7, 12, 0, 0, + 13044, 13045, 7, 9, 0, 0, 13045, 13046, 7, 20, 0, 0, 13046, 13047, 7, 6, + 0, 0, 13047, 13048, 7, 10, 0, 0, 13048, 13049, 7, 14, 0, 0, 13049, 1946, + 1, 0, 0, 0, 13050, 13051, 7, 9, 0, 0, 13051, 13052, 7, 7, 0, 0, 13052, + 13053, 7, 8, 0, 0, 13053, 13054, 7, 4, 0, 0, 13054, 13055, 7, 13, 0, 0, + 13055, 13056, 7, 19, 0, 0, 13056, 1948, 1, 0, 0, 0, 13057, 13058, 7, 9, + 0, 0, 13058, 13059, 7, 16, 0, 0, 13059, 13060, 7, 17, 0, 0, 13060, 13061, + 7, 17, 0, 0, 13061, 13062, 7, 6, 0, 0, 13062, 13063, 7, 4, 0, 0, 13063, + 13064, 7, 3, 0, 0, 13064, 13065, 7, 8, 0, 0, 13065, 13066, 7, 13, 0, 0, + 13066, 1950, 1, 0, 0, 0, 13067, 13068, 7, 9, 0, 0, 13068, 13069, 7, 16, + 0, 0, 13069, 13070, 7, 10, 0, 0, 13070, 13071, 7, 13, 0, 0, 13071, 13072, + 7, 19, 0, 0, 13072, 13073, 7, 3, 0, 0, 13073, 13074, 7, 2, 0, 0, 13074, + 13075, 7, 10, 0, 0, 13075, 13076, 7, 2, 0, 0, 13076, 13077, 7, 12, 0, 0, + 13077, 13078, 7, 9, 0, 0, 13078, 13079, 5, 95, 0, 0, 13079, 13080, 7, 13, + 0, 0, 13080, 13081, 7, 2, 0, 0, 13081, 13082, 7, 17, 0, 0, 13082, 13083, + 7, 17, 0, 0, 13083, 13084, 7, 8, 0, 0, 13084, 13085, 7, 4, 0, 0, 13085, + 1952, 1, 0, 0, 0, 13086, 13087, 7, 9, 0, 0, 13087, 13088, 7, 16, 0, 0, + 13088, 13089, 7, 10, 0, 0, 13089, 13090, 7, 2, 0, 0, 13090, 13091, 7, 10, + 0, 0, 13091, 13092, 7, 16, 0, 0, 13092, 13093, 7, 17, 0, 0, 13093, 1954, + 1, 0, 0, 0, 13094, 13095, 7, 9, 0, 0, 13095, 13096, 7, 16, 0, 0, 13096, + 13097, 7, 9, 0, 0, 13097, 13098, 7, 4, 0, 0, 13098, 13099, 7, 6, 0, 0, + 13099, 13100, 7, 17, 0, 0, 13100, 1956, 1, 0, 0, 0, 13101, 13102, 7, 9, + 0, 0, 13102, 13103, 7, 16, 0, 0, 13103, 13104, 7, 9, 0, 0, 13104, 13105, + 7, 4, 0, 0, 13105, 13106, 7, 6, 0, 0, 13106, 13107, 7, 17, 0, 0, 13107, + 13108, 5, 95, 0, 0, 13108, 13109, 7, 12, 0, 0, 13109, 13110, 7, 9, 0, 0, + 13110, 13111, 7, 6, 0, 0, 13111, 13112, 7, 3, 0, 0, 13112, 1958, 1, 0, + 0, 0, 13113, 13114, 7, 4, 0, 0, 13114, 13115, 7, 0, 0, 0, 13115, 13116, + 7, 1, 0, 0, 13116, 13117, 7, 11, 0, 0, 13117, 13118, 7, 6, 0, 0, 13118, + 1960, 1, 0, 0, 0, 13119, 13120, 7, 4, 0, 0, 13120, 13121, 7, 0, 0, 0, 13121, + 13122, 7, 1, 0, 0, 13122, 13123, 7, 11, 0, 0, 13123, 13124, 7, 6, 0, 0, + 13124, 13125, 7, 3, 0, 0, 13125, 13126, 7, 6, 0, 0, 13126, 13127, 7, 9, + 0, 0, 13127, 13128, 7, 12, 0, 0, 13128, 13129, 7, 11, 0, 0, 13129, 13130, + 7, 4, 0, 0, 13130, 13131, 7, 9, 0, 0, 13131, 1962, 1, 0, 0, 0, 13132, 13133, + 7, 4, 0, 0, 13133, 13134, 7, 0, 0, 0, 13134, 13135, 7, 1, 0, 0, 13135, + 13136, 7, 11, 0, 0, 13136, 13137, 7, 6, 0, 0, 13137, 13138, 7, 9, 0, 0, + 13138, 13139, 7, 0, 0, 0, 13139, 13140, 7, 17, 0, 0, 13140, 13141, 7, 20, + 0, 0, 13141, 13142, 7, 11, 0, 0, 13142, 13143, 7, 6, 0, 0, 13143, 1964, + 1, 0, 0, 0, 13144, 13145, 7, 4, 0, 0, 13145, 13146, 7, 0, 0, 0, 13146, + 13147, 7, 1, 0, 0, 13147, 13148, 7, 11, 0, 0, 13148, 13149, 7, 2, 0, 0, + 13149, 13150, 7, 13, 0, 0, 13150, 13151, 7, 21, 0, 0, 13151, 1966, 1, 0, + 0, 0, 13152, 13153, 7, 4, 0, 0, 13153, 13154, 7, 0, 0, 0, 13154, 13155, + 7, 1, 0, 0, 13155, 13156, 7, 11, 0, 0, 13156, 13157, 7, 2, 0, 0, 13157, + 13158, 7, 13, 0, 0, 13158, 13159, 7, 21, 0, 0, 13159, 13160, 7, 22, 0, + 0, 13160, 1968, 1, 0, 0, 0, 13161, 13162, 7, 4, 0, 0, 13162, 13163, 7, + 0, 0, 0, 13163, 13164, 7, 21, 0, 0, 13164, 13165, 7, 6, 0, 0, 13165, 1970, + 1, 0, 0, 0, 13166, 13167, 7, 4, 0, 0, 13167, 13168, 7, 0, 0, 0, 13168, + 13169, 7, 20, 0, 0, 13169, 13170, 7, 6, 0, 0, 13170, 1972, 1, 0, 0, 0, + 13171, 13172, 7, 4, 0, 0, 13172, 13173, 7, 0, 0, 0, 13173, 13174, 7, 3, + 0, 0, 13174, 13175, 7, 18, 0, 0, 13175, 13176, 7, 6, 0, 0, 13176, 13177, + 7, 4, 0, 0, 13177, 1974, 1, 0, 0, 0, 13178, 13179, 7, 4, 0, 0, 13179, 13180, + 7, 0, 0, 0, 13180, 13181, 7, 3, 0, 0, 13181, 13182, 7, 18, 0, 0, 13182, + 13183, 7, 6, 0, 0, 13183, 13184, 7, 4, 0, 0, 13184, 13185, 5, 95, 0, 0, + 13185, 13186, 7, 3, 0, 0, 13186, 13187, 7, 6, 0, 0, 13187, 13188, 7, 13, + 0, 0, 13188, 13189, 7, 2, 0, 0, 13189, 13190, 7, 15, 0, 0, 13190, 13191, + 7, 6, 0, 0, 13191, 13192, 7, 3, 0, 0, 13192, 13193, 7, 16, 0, 0, 13193, + 13194, 5, 95, 0, 0, 13194, 13195, 7, 4, 0, 0, 13195, 13196, 7, 8, 0, 0, + 13196, 13197, 7, 17, 0, 0, 13197, 13198, 7, 6, 0, 0, 13198, 1976, 1, 0, + 0, 0, 13199, 13200, 7, 4, 0, 0, 13200, 13201, 7, 1, 0, 0, 13201, 1978, + 1, 0, 0, 0, 13202, 13203, 7, 4, 0, 0, 13203, 13204, 7, 13, 0, 0, 13204, + 13205, 7, 20, 0, 0, 13205, 1980, 1, 0, 0, 0, 13206, 13207, 7, 4, 0, 0, + 13207, 13208, 7, 6, 0, 0, 13208, 13209, 7, 22, 0, 0, 13209, 13210, 7, 4, + 0, 0, 13210, 13211, 7, 8, 0, 0, 13211, 13212, 7, 17, 0, 0, 13212, 13213, + 7, 0, 0, 0, 13213, 13214, 7, 18, 0, 0, 13214, 13215, 7, 6, 0, 0, 13215, + 13216, 5, 95, 0, 0, 13216, 13217, 7, 2, 0, 0, 13217, 13218, 7, 10, 0, 0, + 13218, 1982, 1, 0, 0, 0, 13219, 13220, 7, 4, 0, 0, 13220, 13221, 7, 6, + 0, 0, 13221, 13222, 7, 22, 0, 0, 13222, 13223, 7, 4, 0, 0, 13223, 13224, + 7, 9, 0, 0, 13224, 13225, 7, 8, 0, 0, 13225, 13226, 7, 23, 0, 0, 13226, + 13227, 7, 6, 0, 0, 13227, 1984, 1, 0, 0, 0, 13228, 13229, 7, 4, 0, 0, 13229, + 13230, 7, 19, 0, 0, 13230, 13231, 7, 6, 0, 0, 13231, 13232, 7, 10, 0, 0, + 13232, 1986, 1, 0, 0, 0, 13233, 13234, 7, 4, 0, 0, 13234, 13235, 7, 19, + 0, 0, 13235, 13236, 7, 3, 0, 0, 13236, 13237, 7, 2, 0, 0, 13237, 13238, + 7, 7, 0, 0, 13238, 1988, 1, 0, 0, 0, 13239, 13240, 7, 4, 0, 0, 13240, 13241, + 7, 8, 0, 0, 13241, 13242, 7, 6, 0, 0, 13242, 13243, 7, 9, 0, 0, 13243, + 1990, 1, 0, 0, 0, 13244, 13245, 7, 4, 0, 0, 13245, 13246, 7, 8, 0, 0, 13246, + 13247, 7, 17, 0, 0, 13247, 13248, 7, 6, 0, 0, 13248, 1992, 1, 0, 0, 0, + 13249, 13250, 7, 4, 0, 0, 13250, 13251, 7, 8, 0, 0, 13251, 13252, 7, 17, + 0, 0, 13252, 13253, 7, 6, 0, 0, 13253, 13254, 7, 2, 0, 0, 13254, 13255, + 7, 12, 0, 0, 13255, 13256, 7, 4, 0, 0, 13256, 1994, 1, 0, 0, 0, 13257, + 13258, 7, 4, 0, 0, 13258, 13259, 7, 8, 0, 0, 13259, 13260, 7, 17, 0, 0, + 13260, 13261, 7, 6, 0, 0, 13261, 13262, 7, 3, 0, 0, 13262, 1996, 1, 0, + 0, 0, 13263, 13264, 7, 4, 0, 0, 13264, 13265, 7, 8, 0, 0, 13265, 13266, + 7, 10, 0, 0, 13266, 13267, 7, 16, 0, 0, 13267, 13268, 7, 8, 0, 0, 13268, + 13269, 7, 10, 0, 0, 13269, 13270, 7, 4, 0, 0, 13270, 1998, 1, 0, 0, 0, + 13271, 13272, 7, 4, 0, 0, 13272, 13273, 7, 2, 0, 0, 13273, 2000, 1, 0, + 0, 0, 13274, 13275, 7, 4, 0, 0, 13275, 13276, 7, 2, 0, 0, 13276, 13277, + 7, 20, 0, 0, 13277, 2002, 1, 0, 0, 0, 13278, 13279, 7, 4, 0, 0, 13279, + 13280, 7, 2, 0, 0, 13280, 13281, 7, 3, 0, 0, 13281, 13282, 7, 10, 0, 0, + 13282, 13283, 5, 95, 0, 0, 13283, 13284, 7, 20, 0, 0, 13284, 13285, 7, + 0, 0, 0, 13285, 13286, 7, 18, 0, 0, 13286, 13287, 7, 6, 0, 0, 13287, 13288, + 5, 95, 0, 0, 13288, 13289, 7, 14, 0, 0, 13289, 13290, 7, 6, 0, 0, 13290, + 13291, 7, 4, 0, 0, 13291, 13292, 7, 6, 0, 0, 13292, 13293, 7, 13, 0, 0, + 13293, 13294, 7, 4, 0, 0, 13294, 13295, 7, 8, 0, 0, 13295, 13296, 7, 2, + 0, 0, 13296, 13297, 7, 10, 0, 0, 13297, 2004, 1, 0, 0, 0, 13298, 13299, + 7, 4, 0, 0, 13299, 13300, 7, 2, 0, 0, 13300, 13301, 7, 9, 0, 0, 13301, + 13302, 7, 4, 0, 0, 13302, 13303, 7, 3, 0, 0, 13303, 13304, 7, 8, 0, 0, + 13304, 13305, 7, 10, 0, 0, 13305, 13306, 7, 18, 0, 0, 13306, 2006, 1, 0, + 0, 0, 13307, 13308, 7, 4, 0, 0, 13308, 13309, 7, 3, 0, 0, 13309, 13310, + 7, 0, 0, 0, 13310, 13311, 7, 13, 0, 0, 13311, 13312, 7, 6, 0, 0, 13312, + 2008, 1, 0, 0, 0, 13313, 13314, 7, 4, 0, 0, 13314, 13315, 7, 3, 0, 0, 13315, + 13316, 7, 0, 0, 0, 13316, 13317, 7, 13, 0, 0, 13317, 13318, 7, 21, 0, 0, + 13318, 13319, 7, 8, 0, 0, 13319, 13320, 7, 10, 0, 0, 13320, 13321, 7, 18, + 0, 0, 13321, 2010, 1, 0, 0, 0, 13322, 13323, 7, 4, 0, 0, 13323, 13324, + 7, 3, 0, 0, 13324, 13325, 7, 0, 0, 0, 13325, 13326, 7, 13, 0, 0, 13326, + 13327, 7, 21, 0, 0, 13327, 13328, 5, 95, 0, 0, 13328, 13329, 7, 13, 0, + 0, 13329, 13330, 7, 0, 0, 0, 13330, 13331, 7, 12, 0, 0, 13331, 13332, 7, + 9, 0, 0, 13332, 13333, 7, 0, 0, 0, 13333, 13334, 7, 11, 0, 0, 13334, 13335, + 7, 8, 0, 0, 13335, 13336, 7, 4, 0, 0, 13336, 13337, 7, 16, 0, 0, 13337, + 2012, 1, 0, 0, 0, 13338, 13339, 7, 4, 0, 0, 13339, 13340, 7, 3, 0, 0, 13340, + 13341, 7, 0, 0, 0, 13341, 13342, 7, 10, 0, 0, 13342, 2014, 1, 0, 0, 0, + 13343, 13344, 7, 4, 0, 0, 13344, 13345, 7, 3, 0, 0, 13345, 13346, 7, 0, + 0, 0, 13346, 13347, 7, 10, 0, 0, 13347, 13348, 7, 9, 0, 0, 13348, 13349, + 7, 0, 0, 0, 13349, 13350, 7, 13, 0, 0, 13350, 13351, 7, 4, 0, 0, 13351, + 13352, 7, 8, 0, 0, 13352, 13353, 7, 2, 0, 0, 13353, 13354, 7, 10, 0, 0, + 13354, 2016, 1, 0, 0, 0, 13355, 13356, 7, 4, 0, 0, 13356, 13357, 7, 3, + 0, 0, 13357, 13358, 7, 0, 0, 0, 13358, 13359, 7, 10, 0, 0, 13359, 13360, + 7, 9, 0, 0, 13360, 13361, 7, 0, 0, 0, 13361, 13362, 7, 13, 0, 0, 13362, + 13363, 7, 4, 0, 0, 13363, 13364, 7, 8, 0, 0, 13364, 13365, 7, 2, 0, 0, + 13365, 13366, 7, 10, 0, 0, 13366, 13367, 5, 95, 0, 0, 13367, 13368, 7, + 8, 0, 0, 13368, 13369, 7, 14, 0, 0, 13369, 2018, 1, 0, 0, 0, 13370, 13371, + 7, 4, 0, 0, 13371, 13372, 7, 3, 0, 0, 13372, 13373, 7, 0, 0, 0, 13373, + 13374, 7, 10, 0, 0, 13374, 13375, 7, 9, 0, 0, 13375, 13376, 7, 5, 0, 0, + 13376, 13377, 7, 6, 0, 0, 13377, 13378, 7, 3, 0, 0, 13378, 2020, 1, 0, + 0, 0, 13379, 13380, 7, 4, 0, 0, 13380, 13381, 7, 3, 0, 0, 13381, 13382, + 7, 0, 0, 0, 13382, 13383, 7, 10, 0, 0, 13383, 13384, 7, 9, 0, 0, 13384, + 13385, 7, 5, 0, 0, 13385, 13386, 7, 2, 0, 0, 13386, 13387, 7, 3, 0, 0, + 13387, 13388, 7, 17, 0, 0, 13388, 13389, 5, 95, 0, 0, 13389, 13390, 7, + 10, 0, 0, 13390, 13391, 7, 2, 0, 0, 13391, 13392, 7, 8, 0, 0, 13392, 13393, + 7, 9, 0, 0, 13393, 13394, 7, 6, 0, 0, 13394, 13395, 5, 95, 0, 0, 13395, + 13396, 7, 7, 0, 0, 13396, 13397, 7, 2, 0, 0, 13397, 13398, 7, 3, 0, 0, + 13398, 13399, 7, 14, 0, 0, 13399, 13400, 7, 9, 0, 0, 13400, 2022, 1, 0, + 0, 0, 13401, 13402, 7, 4, 0, 0, 13402, 13403, 7, 3, 0, 0, 13403, 13404, + 7, 0, 0, 0, 13404, 13405, 7, 10, 0, 0, 13405, 13406, 7, 9, 0, 0, 13406, + 13407, 7, 11, 0, 0, 13407, 13408, 7, 0, 0, 0, 13408, 13409, 7, 4, 0, 0, + 13409, 13410, 7, 6, 0, 0, 13410, 2024, 1, 0, 0, 0, 13411, 13412, 7, 4, + 0, 0, 13412, 13413, 7, 3, 0, 0, 13413, 13414, 7, 8, 0, 0, 13414, 13415, + 7, 18, 0, 0, 13415, 13416, 7, 18, 0, 0, 13416, 13417, 7, 6, 0, 0, 13417, + 13418, 7, 3, 0, 0, 13418, 2026, 1, 0, 0, 0, 13419, 13420, 7, 4, 0, 0, 13420, + 13421, 7, 3, 0, 0, 13421, 13422, 7, 8, 0, 0, 13422, 13423, 7, 17, 0, 0, + 13423, 2028, 1, 0, 0, 0, 13424, 13425, 7, 4, 0, 0, 13425, 13426, 7, 3, + 0, 0, 13426, 13427, 7, 8, 0, 0, 13427, 13428, 7, 20, 0, 0, 13428, 13429, + 7, 11, 0, 0, 13429, 13430, 7, 6, 0, 0, 13430, 13431, 5, 95, 0, 0, 13431, + 13432, 7, 14, 0, 0, 13432, 13433, 7, 6, 0, 0, 13433, 13434, 7, 9, 0, 0, + 13434, 2030, 1, 0, 0, 0, 13435, 13436, 7, 4, 0, 0, 13436, 13437, 7, 3, + 0, 0, 13437, 13438, 7, 8, 0, 0, 13438, 13439, 7, 20, 0, 0, 13439, 13440, + 7, 11, 0, 0, 13440, 13441, 7, 6, 0, 0, 13441, 13442, 5, 95, 0, 0, 13442, + 13443, 7, 14, 0, 0, 13443, 13444, 7, 6, 0, 0, 13444, 13445, 7, 9, 0, 0, + 13445, 13446, 5, 95, 0, 0, 13446, 13447, 5, 51, 0, 0, 13447, 13448, 7, + 21, 0, 0, 13448, 13449, 7, 6, 0, 0, 13449, 13450, 7, 16, 0, 0, 13450, 2032, + 1, 0, 0, 0, 13451, 13452, 7, 4, 0, 0, 13452, 13453, 7, 3, 0, 0, 13453, + 13454, 7, 12, 0, 0, 13454, 13455, 7, 10, 0, 0, 13455, 13456, 7, 13, 0, + 0, 13456, 13457, 7, 0, 0, 0, 13457, 13458, 7, 4, 0, 0, 13458, 13459, 7, + 6, 0, 0, 13459, 2034, 1, 0, 0, 0, 13460, 13461, 7, 4, 0, 0, 13461, 13462, + 7, 3, 0, 0, 13462, 13463, 7, 12, 0, 0, 13463, 13464, 7, 9, 0, 0, 13464, + 13465, 7, 4, 0, 0, 13465, 13466, 7, 7, 0, 0, 13466, 13467, 7, 2, 0, 0, + 13467, 13468, 7, 3, 0, 0, 13468, 13469, 7, 4, 0, 0, 13469, 13470, 7, 19, + 0, 0, 13470, 13471, 7, 16, 0, 0, 13471, 2036, 1, 0, 0, 0, 13472, 13473, + 7, 4, 0, 0, 13473, 13474, 7, 3, 0, 0, 13474, 13475, 7, 16, 0, 0, 13475, + 2038, 1, 0, 0, 0, 13476, 13477, 7, 4, 0, 0, 13477, 13478, 7, 3, 0, 0, 13478, + 13479, 7, 16, 0, 0, 13479, 13480, 5, 95, 0, 0, 13480, 13481, 7, 13, 0, + 0, 13481, 13482, 7, 0, 0, 0, 13482, 13483, 7, 9, 0, 0, 13483, 13484, 7, + 4, 0, 0, 13484, 2040, 1, 0, 0, 0, 13485, 13486, 7, 4, 0, 0, 13486, 13487, + 7, 9, 0, 0, 13487, 13488, 7, 6, 0, 0, 13488, 13489, 7, 25, 0, 0, 13489, + 13490, 7, 12, 0, 0, 13490, 13491, 7, 0, 0, 0, 13491, 13492, 7, 11, 0, 0, + 13492, 2042, 1, 0, 0, 0, 13493, 13494, 7, 4, 0, 0, 13494, 13495, 7, 9, + 0, 0, 13495, 13496, 7, 25, 0, 0, 13496, 13497, 7, 11, 0, 0, 13497, 2044, + 1, 0, 0, 0, 13498, 13499, 7, 4, 0, 0, 13499, 13500, 7, 7, 0, 0, 13500, + 13501, 7, 2, 0, 0, 13501, 13502, 5, 95, 0, 0, 13502, 13503, 7, 14, 0, 0, + 13503, 13504, 7, 8, 0, 0, 13504, 13505, 7, 18, 0, 0, 13505, 13506, 7, 8, + 0, 0, 13506, 13507, 7, 4, 0, 0, 13507, 13508, 5, 95, 0, 0, 13508, 13509, + 7, 16, 0, 0, 13509, 13510, 7, 6, 0, 0, 13510, 13511, 7, 0, 0, 0, 13511, + 13512, 7, 3, 0, 0, 13512, 13513, 5, 95, 0, 0, 13513, 13514, 7, 13, 0, 0, + 13514, 13515, 7, 12, 0, 0, 13515, 13516, 7, 4, 0, 0, 13516, 13517, 7, 2, + 0, 0, 13517, 13518, 7, 5, 0, 0, 13518, 13519, 7, 5, 0, 0, 13519, 2046, + 1, 0, 0, 0, 13520, 13521, 7, 4, 0, 0, 13521, 13522, 7, 16, 0, 0, 13522, + 13523, 7, 20, 0, 0, 13523, 13524, 7, 6, 0, 0, 13524, 2048, 1, 0, 0, 0, + 13525, 13526, 7, 4, 0, 0, 13526, 13527, 7, 16, 0, 0, 13527, 13528, 7, 20, + 0, 0, 13528, 13529, 7, 6, 0, 0, 13529, 13530, 7, 20, 0, 0, 13530, 13531, + 7, 3, 0, 0, 13531, 13532, 7, 2, 0, 0, 13532, 13533, 7, 20, 0, 0, 13533, + 13534, 7, 6, 0, 0, 13534, 13535, 7, 3, 0, 0, 13535, 13536, 7, 4, 0, 0, + 13536, 13537, 7, 16, 0, 0, 13537, 2050, 1, 0, 0, 0, 13538, 13539, 7, 4, + 0, 0, 13539, 13540, 7, 16, 0, 0, 13540, 13541, 7, 20, 0, 0, 13541, 13542, + 7, 6, 0, 0, 13542, 13543, 5, 95, 0, 0, 13543, 13544, 7, 8, 0, 0, 13544, + 13545, 7, 14, 0, 0, 13545, 2052, 1, 0, 0, 0, 13546, 13547, 7, 4, 0, 0, + 13547, 13548, 7, 16, 0, 0, 13548, 13549, 7, 20, 0, 0, 13549, 13550, 7, + 6, 0, 0, 13550, 13551, 5, 95, 0, 0, 13551, 13552, 7, 10, 0, 0, 13552, 13553, + 7, 0, 0, 0, 13553, 13554, 7, 17, 0, 0, 13554, 13555, 7, 6, 0, 0, 13555, + 2054, 1, 0, 0, 0, 13556, 13557, 7, 4, 0, 0, 13557, 13558, 7, 16, 0, 0, + 13558, 13559, 7, 20, 0, 0, 13559, 13560, 7, 6, 0, 0, 13560, 13561, 5, 95, + 0, 0, 13561, 13562, 7, 7, 0, 0, 13562, 13563, 7, 0, 0, 0, 13563, 13564, + 7, 3, 0, 0, 13564, 13565, 7, 10, 0, 0, 13565, 13566, 7, 8, 0, 0, 13566, + 13567, 7, 10, 0, 0, 13567, 13568, 7, 18, 0, 0, 13568, 2056, 1, 0, 0, 0, + 13569, 13570, 7, 12, 0, 0, 13570, 13571, 7, 10, 0, 0, 13571, 13572, 7, + 1, 0, 0, 13572, 13573, 7, 2, 0, 0, 13573, 13574, 7, 12, 0, 0, 13574, 13575, + 7, 10, 0, 0, 13575, 13576, 7, 14, 0, 0, 13576, 13577, 7, 6, 0, 0, 13577, + 13578, 7, 14, 0, 0, 13578, 2058, 1, 0, 0, 0, 13579, 13580, 7, 12, 0, 0, + 13580, 13581, 7, 10, 0, 0, 13581, 13582, 7, 13, 0, 0, 13582, 13583, 7, + 19, 0, 0, 13583, 13584, 7, 6, 0, 0, 13584, 13585, 7, 13, 0, 0, 13585, 13586, + 7, 21, 0, 0, 13586, 13587, 7, 6, 0, 0, 13587, 13588, 7, 14, 0, 0, 13588, + 2060, 1, 0, 0, 0, 13589, 13590, 7, 12, 0, 0, 13590, 13591, 7, 10, 0, 0, + 13591, 13592, 7, 13, 0, 0, 13592, 13593, 7, 2, 0, 0, 13593, 13594, 7, 17, + 0, 0, 13594, 13595, 7, 17, 0, 0, 13595, 13596, 7, 8, 0, 0, 13596, 13597, + 7, 4, 0, 0, 13597, 13598, 7, 4, 0, 0, 13598, 13599, 7, 6, 0, 0, 13599, + 13600, 7, 14, 0, 0, 13600, 2062, 1, 0, 0, 0, 13601, 13602, 7, 12, 0, 0, + 13602, 13603, 7, 10, 0, 0, 13603, 13604, 7, 8, 0, 0, 13604, 13605, 7, 13, + 0, 0, 13605, 13606, 7, 2, 0, 0, 13606, 13607, 7, 14, 0, 0, 13607, 13608, + 7, 6, 0, 0, 13608, 2064, 1, 0, 0, 0, 13609, 13610, 7, 12, 0, 0, 13610, + 13611, 7, 10, 0, 0, 13611, 13612, 7, 8, 0, 0, 13612, 13613, 7, 2, 0, 0, + 13613, 13614, 7, 10, 0, 0, 13614, 2066, 1, 0, 0, 0, 13615, 13616, 7, 12, + 0, 0, 13616, 13617, 7, 10, 0, 0, 13617, 13618, 7, 8, 0, 0, 13618, 13619, + 7, 25, 0, 0, 13619, 13620, 7, 12, 0, 0, 13620, 13621, 7, 6, 0, 0, 13621, + 2068, 1, 0, 0, 0, 13622, 13623, 7, 12, 0, 0, 13623, 13624, 7, 10, 0, 0, + 13624, 13625, 7, 21, 0, 0, 13625, 13626, 7, 10, 0, 0, 13626, 13627, 7, + 2, 0, 0, 13627, 13628, 7, 7, 0, 0, 13628, 13629, 7, 10, 0, 0, 13629, 2070, + 1, 0, 0, 0, 13630, 13631, 7, 12, 0, 0, 13631, 13632, 7, 10, 0, 0, 13632, + 13633, 7, 11, 0, 0, 13633, 13634, 7, 8, 0, 0, 13634, 13635, 7, 17, 0, 0, + 13635, 13636, 7, 8, 0, 0, 13636, 13637, 7, 4, 0, 0, 13637, 13638, 7, 6, + 0, 0, 13638, 13639, 7, 14, 0, 0, 13639, 2072, 1, 0, 0, 0, 13640, 13641, + 7, 12, 0, 0, 13641, 13642, 7, 10, 0, 0, 13642, 13643, 7, 11, 0, 0, 13643, + 13644, 7, 2, 0, 0, 13644, 13645, 7, 13, 0, 0, 13645, 13646, 7, 21, 0, 0, + 13646, 2074, 1, 0, 0, 0, 13647, 13648, 7, 12, 0, 0, 13648, 13649, 7, 10, + 0, 0, 13649, 13650, 7, 17, 0, 0, 13650, 13651, 7, 0, 0, 0, 13651, 13652, + 7, 9, 0, 0, 13652, 13653, 7, 21, 0, 0, 13653, 2076, 1, 0, 0, 0, 13654, + 13655, 7, 12, 0, 0, 13655, 13656, 7, 10, 0, 0, 13656, 13657, 7, 20, 0, + 0, 13657, 13658, 7, 8, 0, 0, 13658, 13659, 7, 15, 0, 0, 13659, 13660, 7, + 2, 0, 0, 13660, 13661, 7, 4, 0, 0, 13661, 2078, 1, 0, 0, 0, 13662, 13663, + 7, 12, 0, 0, 13663, 13664, 7, 10, 0, 0, 13664, 13665, 7, 9, 0, 0, 13665, + 13666, 7, 0, 0, 0, 13666, 13667, 7, 5, 0, 0, 13667, 13668, 7, 6, 0, 0, + 13668, 2080, 1, 0, 0, 0, 13669, 13670, 7, 12, 0, 0, 13670, 13671, 7, 2, + 0, 0, 13671, 13672, 7, 7, 0, 0, 13672, 2082, 1, 0, 0, 0, 13673, 13674, + 7, 12, 0, 0, 13674, 13675, 7, 20, 0, 0, 13675, 13676, 7, 14, 0, 0, 13676, + 13677, 7, 0, 0, 0, 13677, 13678, 7, 4, 0, 0, 13678, 13679, 7, 6, 0, 0, + 13679, 2084, 1, 0, 0, 0, 13680, 13681, 7, 12, 0, 0, 13681, 13682, 7, 20, + 0, 0, 13682, 13683, 7, 14, 0, 0, 13683, 13684, 7, 0, 0, 0, 13684, 13685, + 7, 4, 0, 0, 13685, 13686, 7, 6, 0, 0, 13686, 13687, 7, 4, 0, 0, 13687, + 13688, 7, 6, 0, 0, 13688, 13689, 7, 22, 0, 0, 13689, 13690, 7, 4, 0, 0, + 13690, 2086, 1, 0, 0, 0, 13691, 13692, 7, 12, 0, 0, 13692, 13693, 7, 20, + 0, 0, 13693, 13694, 7, 14, 0, 0, 13694, 13695, 7, 11, 0, 0, 13695, 13696, + 7, 2, 0, 0, 13696, 13697, 7, 13, 0, 0, 13697, 13698, 7, 21, 0, 0, 13698, + 2088, 1, 0, 0, 0, 13699, 13700, 7, 12, 0, 0, 13700, 13701, 7, 20, 0, 0, + 13701, 13702, 7, 20, 0, 0, 13702, 13703, 7, 6, 0, 0, 13703, 13704, 7, 3, + 0, 0, 13704, 2090, 1, 0, 0, 0, 13705, 13706, 7, 12, 0, 0, 13706, 13707, + 7, 3, 0, 0, 13707, 13708, 7, 11, 0, 0, 13708, 2092, 1, 0, 0, 0, 13709, + 13710, 7, 12, 0, 0, 13710, 13711, 7, 9, 0, 0, 13711, 13712, 7, 6, 0, 0, + 13712, 2094, 1, 0, 0, 0, 13713, 13714, 7, 12, 0, 0, 13714, 13715, 7, 9, + 0, 0, 13715, 13716, 7, 6, 0, 0, 13716, 13717, 7, 14, 0, 0, 13717, 2096, + 1, 0, 0, 0, 13718, 13719, 7, 12, 0, 0, 13719, 13720, 7, 9, 0, 0, 13720, + 13721, 7, 6, 0, 0, 13721, 13722, 7, 3, 0, 0, 13722, 2098, 1, 0, 0, 0, 13723, + 13724, 7, 12, 0, 0, 13724, 13725, 7, 9, 0, 0, 13725, 13726, 7, 6, 0, 0, + 13726, 13727, 7, 3, 0, 0, 13727, 13728, 5, 95, 0, 0, 13728, 13729, 7, 8, + 0, 0, 13729, 13730, 7, 14, 0, 0, 13730, 2100, 1, 0, 0, 0, 13731, 13732, + 7, 12, 0, 0, 13732, 13733, 7, 9, 0, 0, 13733, 13734, 7, 6, 0, 0, 13734, + 13735, 7, 3, 0, 0, 13735, 13736, 5, 95, 0, 0, 13736, 13737, 7, 10, 0, 0, + 13737, 13738, 7, 0, 0, 0, 13738, 13739, 7, 17, 0, 0, 13739, 13740, 7, 6, + 0, 0, 13740, 2102, 1, 0, 0, 0, 13741, 13742, 7, 12, 0, 0, 13742, 13743, + 7, 9, 0, 0, 13743, 13744, 7, 8, 0, 0, 13744, 13745, 7, 10, 0, 0, 13745, + 13746, 7, 18, 0, 0, 13746, 2104, 1, 0, 0, 0, 13747, 13748, 7, 15, 0, 0, + 13748, 13749, 7, 0, 0, 0, 13749, 13750, 7, 11, 0, 0, 13750, 13751, 7, 8, + 0, 0, 13751, 13752, 7, 14, 0, 0, 13752, 13753, 7, 0, 0, 0, 13753, 13754, + 7, 4, 0, 0, 13754, 13755, 7, 8, 0, 0, 13755, 13756, 7, 2, 0, 0, 13756, + 13757, 7, 10, 0, 0, 13757, 2106, 1, 0, 0, 0, 13758, 13759, 7, 15, 0, 0, + 13759, 13760, 7, 0, 0, 0, 13760, 13761, 7, 11, 0, 0, 13761, 13762, 7, 8, + 0, 0, 13762, 13763, 7, 14, 0, 0, 13763, 13764, 5, 95, 0, 0, 13764, 13765, + 7, 22, 0, 0, 13765, 13766, 7, 17, 0, 0, 13766, 13767, 7, 11, 0, 0, 13767, + 2108, 1, 0, 0, 0, 13768, 13769, 7, 15, 0, 0, 13769, 13770, 7, 0, 0, 0, + 13770, 13771, 7, 11, 0, 0, 13771, 13772, 7, 12, 0, 0, 13772, 13773, 7, + 6, 0, 0, 13773, 2110, 1, 0, 0, 0, 13774, 13775, 7, 15, 0, 0, 13775, 13776, + 7, 0, 0, 0, 13776, 13777, 7, 11, 0, 0, 13777, 13778, 7, 12, 0, 0, 13778, + 13779, 7, 6, 0, 0, 13779, 13780, 7, 9, 0, 0, 13780, 2112, 1, 0, 0, 0, 13781, + 13782, 5, 91, 0, 0, 13782, 13783, 7, 15, 0, 0, 13783, 13784, 7, 0, 0, 0, + 13784, 13785, 7, 11, 0, 0, 13785, 13786, 7, 12, 0, 0, 13786, 13787, 7, + 6, 0, 0, 13787, 13788, 5, 93, 0, 0, 13788, 2114, 1, 0, 0, 0, 13789, 13790, + 7, 15, 0, 0, 13790, 13791, 7, 0, 0, 0, 13791, 13792, 7, 3, 0, 0, 13792, + 2116, 1, 0, 0, 0, 13793, 13794, 7, 15, 0, 0, 13794, 13795, 7, 0, 0, 0, + 13795, 13796, 7, 3, 0, 0, 13796, 13797, 7, 1, 0, 0, 13797, 13798, 7, 8, + 0, 0, 13798, 13799, 7, 10, 0, 0, 13799, 13800, 7, 0, 0, 0, 13800, 13801, + 7, 3, 0, 0, 13801, 13802, 7, 16, 0, 0, 13802, 2118, 1, 0, 0, 0, 13803, + 13804, 7, 15, 0, 0, 13804, 13805, 7, 0, 0, 0, 13805, 13806, 7, 3, 0, 0, + 13806, 13807, 7, 20, 0, 0, 13807, 2120, 1, 0, 0, 0, 13808, 13809, 7, 15, + 0, 0, 13809, 13810, 7, 0, 0, 0, 13810, 13811, 7, 3, 0, 0, 13811, 13812, + 7, 16, 0, 0, 13812, 13813, 7, 8, 0, 0, 13813, 13814, 7, 10, 0, 0, 13814, + 13815, 7, 18, 0, 0, 13815, 2122, 1, 0, 0, 0, 13816, 13817, 7, 15, 0, 0, + 13817, 13818, 7, 6, 0, 0, 13818, 13819, 7, 3, 0, 0, 13819, 13820, 7, 1, + 0, 0, 13820, 13821, 7, 2, 0, 0, 13821, 13822, 7, 9, 0, 0, 13822, 13823, + 7, 6, 0, 0, 13823, 13824, 7, 11, 0, 0, 13824, 13825, 7, 2, 0, 0, 13825, + 13826, 7, 18, 0, 0, 13826, 13827, 7, 18, 0, 0, 13827, 13828, 7, 8, 0, 0, + 13828, 13829, 7, 10, 0, 0, 13829, 13830, 7, 18, 0, 0, 13830, 2124, 1, 0, + 0, 0, 13831, 13832, 7, 15, 0, 0, 13832, 13833, 7, 6, 0, 0, 13833, 13834, + 7, 3, 0, 0, 13834, 13835, 7, 8, 0, 0, 13835, 13836, 7, 5, 0, 0, 13836, + 13837, 7, 16, 0, 0, 13837, 13838, 5, 95, 0, 0, 13838, 13839, 7, 13, 0, + 0, 13839, 13840, 7, 11, 0, 0, 13840, 13841, 7, 2, 0, 0, 13841, 13842, 7, + 10, 0, 0, 13842, 13843, 7, 6, 0, 0, 13843, 13844, 7, 14, 0, 0, 13844, 13845, + 7, 1, 0, 0, 13845, 2126, 1, 0, 0, 0, 13846, 13847, 7, 15, 0, 0, 13847, + 13848, 7, 6, 0, 0, 13848, 13849, 7, 3, 0, 0, 13849, 13850, 7, 9, 0, 0, + 13850, 13851, 7, 8, 0, 0, 13851, 13852, 7, 2, 0, 0, 13852, 13853, 7, 10, + 0, 0, 13853, 2128, 1, 0, 0, 0, 13854, 13855, 7, 15, 0, 0, 13855, 13856, + 7, 8, 0, 0, 13856, 13857, 7, 6, 0, 0, 13857, 13858, 7, 7, 0, 0, 13858, + 2130, 1, 0, 0, 0, 13859, 13860, 7, 15, 0, 0, 13860, 13861, 7, 8, 0, 0, + 13861, 13862, 7, 6, 0, 0, 13862, 13863, 7, 7, 0, 0, 13863, 13864, 7, 9, + 0, 0, 13864, 2132, 1, 0, 0, 0, 13865, 13866, 7, 15, 0, 0, 13866, 13867, + 7, 8, 0, 0, 13867, 13868, 7, 6, 0, 0, 13868, 13869, 7, 7, 0, 0, 13869, + 13870, 5, 95, 0, 0, 13870, 13871, 7, 17, 0, 0, 13871, 13872, 7, 6, 0, 0, + 13872, 13873, 7, 4, 0, 0, 13873, 13874, 7, 0, 0, 0, 13874, 13875, 7, 14, + 0, 0, 13875, 13876, 7, 0, 0, 0, 13876, 13877, 7, 4, 0, 0, 13877, 13878, + 7, 0, 0, 0, 13878, 2134, 1, 0, 0, 0, 13879, 13880, 7, 15, 0, 0, 13880, + 13881, 7, 8, 0, 0, 13881, 13882, 7, 9, 0, 0, 13882, 13883, 7, 8, 0, 0, + 13883, 13884, 7, 1, 0, 0, 13884, 13885, 7, 8, 0, 0, 13885, 13886, 7, 11, + 0, 0, 13886, 13887, 7, 8, 0, 0, 13887, 13888, 7, 4, 0, 0, 13888, 13889, + 7, 16, 0, 0, 13889, 2136, 1, 0, 0, 0, 13890, 13891, 7, 7, 0, 0, 13891, + 13892, 7, 0, 0, 0, 13892, 13893, 7, 8, 0, 0, 13893, 13894, 7, 4, 0, 0, + 13894, 2138, 1, 0, 0, 0, 13895, 13896, 7, 7, 0, 0, 13896, 13897, 7, 0, + 0, 0, 13897, 13898, 7, 8, 0, 0, 13898, 13899, 7, 4, 0, 0, 13899, 13900, + 7, 5, 0, 0, 13900, 13901, 7, 2, 0, 0, 13901, 13902, 7, 3, 0, 0, 13902, + 2140, 1, 0, 0, 0, 13903, 13904, 7, 7, 0, 0, 13904, 13905, 7, 0, 0, 0, 13905, + 13906, 7, 8, 0, 0, 13906, 13907, 7, 4, 0, 0, 13907, 13908, 5, 95, 0, 0, + 13908, 13909, 7, 0, 0, 0, 13909, 13910, 7, 4, 0, 0, 13910, 13911, 5, 95, + 0, 0, 13911, 13912, 7, 11, 0, 0, 13912, 13913, 7, 2, 0, 0, 13913, 13914, + 7, 7, 0, 0, 13914, 13915, 5, 95, 0, 0, 13915, 13916, 7, 20, 0, 0, 13916, + 13917, 7, 3, 0, 0, 13917, 13918, 7, 8, 0, 0, 13918, 13919, 7, 2, 0, 0, + 13919, 13920, 7, 3, 0, 0, 13920, 13921, 7, 8, 0, 0, 13921, 13922, 7, 4, + 0, 0, 13922, 13923, 7, 16, 0, 0, 13923, 2142, 1, 0, 0, 0, 13924, 13925, + 7, 7, 0, 0, 13925, 13926, 7, 6, 0, 0, 13926, 13927, 7, 11, 0, 0, 13927, + 13928, 7, 11, 0, 0, 13928, 13929, 5, 95, 0, 0, 13929, 13930, 7, 5, 0, 0, + 13930, 13931, 7, 2, 0, 0, 13931, 13932, 7, 3, 0, 0, 13932, 13933, 7, 17, + 0, 0, 13933, 13934, 7, 6, 0, 0, 13934, 13935, 7, 14, 0, 0, 13935, 13936, + 5, 95, 0, 0, 13936, 13937, 7, 22, 0, 0, 13937, 13938, 7, 17, 0, 0, 13938, + 13939, 7, 11, 0, 0, 13939, 2144, 1, 0, 0, 0, 13940, 13941, 7, 7, 0, 0, + 13941, 13942, 7, 19, 0, 0, 13942, 13943, 7, 6, 0, 0, 13943, 13944, 7, 10, + 0, 0, 13944, 2146, 1, 0, 0, 0, 13945, 13946, 7, 7, 0, 0, 13946, 13947, + 7, 19, 0, 0, 13947, 13948, 7, 6, 0, 0, 13948, 13949, 7, 3, 0, 0, 13949, + 13950, 7, 6, 0, 0, 13950, 2148, 1, 0, 0, 0, 13951, 13952, 7, 7, 0, 0, 13952, + 13953, 7, 19, 0, 0, 13953, 13954, 7, 8, 0, 0, 13954, 13955, 7, 11, 0, 0, + 13955, 13956, 7, 6, 0, 0, 13956, 2150, 1, 0, 0, 0, 13957, 13958, 7, 7, + 0, 0, 13958, 13959, 7, 8, 0, 0, 13959, 13960, 7, 10, 0, 0, 13960, 13961, + 7, 14, 0, 0, 13961, 13962, 7, 2, 0, 0, 13962, 13963, 7, 7, 0, 0, 13963, + 13964, 7, 9, 0, 0, 13964, 2152, 1, 0, 0, 0, 13965, 13966, 7, 7, 0, 0, 13966, + 13967, 7, 8, 0, 0, 13967, 13968, 7, 4, 0, 0, 13968, 13969, 7, 19, 0, 0, + 13969, 2154, 1, 0, 0, 0, 13970, 13971, 7, 7, 0, 0, 13971, 13972, 7, 8, + 0, 0, 13972, 13973, 7, 4, 0, 0, 13973, 13974, 7, 19, 0, 0, 13974, 13975, + 7, 8, 0, 0, 13975, 13976, 7, 10, 0, 0, 13976, 2156, 1, 0, 0, 0, 13977, + 13978, 7, 7, 0, 0, 13978, 13979, 7, 8, 0, 0, 13979, 13980, 7, 4, 0, 0, + 13980, 13981, 7, 19, 0, 0, 13981, 13982, 7, 2, 0, 0, 13982, 13983, 7, 12, + 0, 0, 13983, 13984, 7, 4, 0, 0, 13984, 2158, 1, 0, 0, 0, 13985, 13986, + 7, 7, 0, 0, 13986, 13987, 7, 8, 0, 0, 13987, 13988, 7, 4, 0, 0, 13988, + 13989, 7, 19, 0, 0, 13989, 13990, 7, 2, 0, 0, 13990, 13991, 7, 12, 0, 0, + 13991, 13992, 7, 4, 0, 0, 13992, 13993, 5, 95, 0, 0, 13993, 13994, 7, 0, + 0, 0, 13994, 13995, 7, 3, 0, 0, 13995, 13996, 7, 3, 0, 0, 13996, 13997, + 7, 0, 0, 0, 13997, 13998, 7, 16, 0, 0, 13998, 13999, 5, 95, 0, 0, 13999, + 14000, 7, 7, 0, 0, 14000, 14001, 7, 3, 0, 0, 14001, 14002, 7, 0, 0, 0, + 14002, 14003, 7, 20, 0, 0, 14003, 14004, 7, 20, 0, 0, 14004, 14005, 7, + 6, 0, 0, 14005, 14006, 7, 3, 0, 0, 14006, 2160, 1, 0, 0, 0, 14007, 14008, + 7, 7, 0, 0, 14008, 14009, 7, 8, 0, 0, 14009, 14010, 7, 4, 0, 0, 14010, + 14011, 7, 10, 0, 0, 14011, 14012, 7, 6, 0, 0, 14012, 14013, 7, 9, 0, 0, + 14013, 14014, 7, 9, 0, 0, 14014, 2162, 1, 0, 0, 0, 14015, 14016, 7, 7, + 0, 0, 14016, 14017, 7, 2, 0, 0, 14017, 14018, 7, 3, 0, 0, 14018, 14019, + 7, 21, 0, 0, 14019, 2164, 1, 0, 0, 0, 14020, 14021, 7, 7, 0, 0, 14021, + 14022, 7, 2, 0, 0, 14022, 14023, 7, 3, 0, 0, 14023, 14024, 7, 21, 0, 0, + 14024, 14025, 7, 11, 0, 0, 14025, 14026, 7, 2, 0, 0, 14026, 14027, 7, 0, + 0, 0, 14027, 14028, 7, 14, 0, 0, 14028, 2166, 1, 0, 0, 0, 14029, 14030, + 7, 7, 0, 0, 14030, 14031, 7, 3, 0, 0, 14031, 14032, 7, 8, 0, 0, 14032, + 14033, 7, 4, 0, 0, 14033, 14034, 7, 6, 0, 0, 14034, 14035, 7, 4, 0, 0, + 14035, 14036, 7, 6, 0, 0, 14036, 14037, 7, 22, 0, 0, 14037, 14038, 7, 4, + 0, 0, 14038, 2168, 1, 0, 0, 0, 14039, 14040, 7, 22, 0, 0, 14040, 14041, + 7, 0, 0, 0, 14041, 14042, 7, 13, 0, 0, 14042, 14043, 7, 4, 0, 0, 14043, + 14044, 5, 95, 0, 0, 14044, 14045, 7, 0, 0, 0, 14045, 14046, 7, 1, 0, 0, + 14046, 14047, 7, 2, 0, 0, 14047, 14048, 7, 3, 0, 0, 14048, 14049, 7, 4, + 0, 0, 14049, 2170, 1, 0, 0, 0, 14050, 14051, 7, 22, 0, 0, 14051, 14052, + 7, 0, 0, 0, 14052, 14053, 7, 13, 0, 0, 14053, 14054, 7, 4, 0, 0, 14054, + 14055, 5, 95, 0, 0, 14055, 14056, 7, 9, 0, 0, 14056, 14057, 7, 4, 0, 0, + 14057, 14058, 7, 0, 0, 0, 14058, 14059, 7, 4, 0, 0, 14059, 14060, 7, 6, + 0, 0, 14060, 2172, 1, 0, 0, 0, 14061, 14062, 7, 22, 0, 0, 14062, 14063, + 7, 11, 0, 0, 14063, 14064, 7, 2, 0, 0, 14064, 14065, 7, 13, 0, 0, 14065, + 14066, 7, 21, 0, 0, 14066, 2174, 1, 0, 0, 0, 14067, 14068, 7, 22, 0, 0, + 14068, 14069, 7, 17, 0, 0, 14069, 14070, 7, 11, 0, 0, 14070, 2176, 1, 0, + 0, 0, 14071, 14072, 7, 22, 0, 0, 14072, 14073, 7, 17, 0, 0, 14073, 14074, + 7, 11, 0, 0, 14074, 14075, 7, 14, 0, 0, 14075, 14076, 7, 0, 0, 0, 14076, + 14077, 7, 4, 0, 0, 14077, 14078, 7, 0, 0, 0, 14078, 2178, 1, 0, 0, 0, 14079, + 14080, 7, 22, 0, 0, 14080, 14081, 7, 17, 0, 0, 14081, 14082, 7, 11, 0, + 0, 14082, 14083, 7, 10, 0, 0, 14083, 14084, 7, 0, 0, 0, 14084, 14085, 7, + 17, 0, 0, 14085, 14086, 7, 6, 0, 0, 14086, 14087, 7, 9, 0, 0, 14087, 14088, + 7, 20, 0, 0, 14088, 14089, 7, 0, 0, 0, 14089, 14090, 7, 13, 0, 0, 14090, + 14091, 7, 6, 0, 0, 14091, 14092, 7, 9, 0, 0, 14092, 2180, 1, 0, 0, 0, 14093, + 14094, 7, 22, 0, 0, 14094, 14095, 7, 17, 0, 0, 14095, 14096, 7, 11, 0, + 0, 14096, 14097, 7, 9, 0, 0, 14097, 14098, 7, 13, 0, 0, 14098, 14099, 7, + 19, 0, 0, 14099, 14100, 7, 6, 0, 0, 14100, 14101, 7, 17, 0, 0, 14101, 14102, + 7, 0, 0, 0, 14102, 2182, 1, 0, 0, 0, 14103, 14104, 7, 22, 0, 0, 14104, + 14105, 7, 17, 0, 0, 14105, 14106, 7, 11, 0, 0, 14106, 14107, 5, 95, 0, + 0, 14107, 14108, 7, 13, 0, 0, 14108, 14109, 7, 2, 0, 0, 14109, 14110, 7, + 17, 0, 0, 14110, 14111, 7, 20, 0, 0, 14111, 14112, 7, 3, 0, 0, 14112, 14113, + 7, 6, 0, 0, 14113, 14114, 7, 9, 0, 0, 14114, 14115, 7, 9, 0, 0, 14115, + 14116, 7, 8, 0, 0, 14116, 14117, 7, 2, 0, 0, 14117, 14118, 7, 10, 0, 0, + 14118, 2184, 1, 0, 0, 0, 14119, 14120, 7, 22, 0, 0, 14120, 14121, 7, 9, + 0, 0, 14121, 14122, 7, 8, 0, 0, 14122, 14123, 7, 10, 0, 0, 14123, 14124, + 7, 8, 0, 0, 14124, 14125, 7, 11, 0, 0, 14125, 2186, 1, 0, 0, 0, 14126, + 14127, 7, 23, 0, 0, 14127, 14128, 7, 2, 0, 0, 14128, 14129, 7, 10, 0, 0, + 14129, 14130, 7, 6, 0, 0, 14130, 2188, 1, 0, 0, 0, 14131, 14132, 7, 0, + 0, 0, 14132, 14133, 7, 1, 0, 0, 14133, 14134, 7, 9, 0, 0, 14134, 2190, + 1, 0, 0, 0, 14135, 14136, 7, 0, 0, 0, 14136, 14137, 7, 13, 0, 0, 14137, + 14138, 7, 2, 0, 0, 14138, 14139, 7, 9, 0, 0, 14139, 2192, 1, 0, 0, 0, 14140, + 14141, 7, 0, 0, 0, 14141, 14142, 7, 9, 0, 0, 14142, 14143, 7, 8, 0, 0, + 14143, 14144, 7, 10, 0, 0, 14144, 2194, 1, 0, 0, 0, 14145, 14146, 7, 0, + 0, 0, 14146, 14147, 7, 4, 0, 0, 14147, 14148, 7, 0, 0, 0, 14148, 14149, + 7, 10, 0, 0, 14149, 2196, 1, 0, 0, 0, 14150, 14151, 7, 0, 0, 0, 14151, + 14152, 7, 4, 0, 0, 14152, 14153, 7, 10, 0, 0, 14153, 14154, 5, 50, 0, 0, + 14154, 2198, 1, 0, 0, 0, 14155, 14156, 7, 13, 0, 0, 14156, 14157, 7, 6, + 0, 0, 14157, 14158, 7, 8, 0, 0, 14158, 14159, 7, 11, 0, 0, 14159, 14160, + 7, 8, 0, 0, 14160, 14161, 7, 10, 0, 0, 14161, 14162, 7, 18, 0, 0, 14162, + 2200, 1, 0, 0, 0, 14163, 14164, 7, 13, 0, 0, 14164, 14165, 7, 2, 0, 0, + 14165, 14166, 7, 9, 0, 0, 14166, 2202, 1, 0, 0, 0, 14167, 14168, 7, 13, + 0, 0, 14168, 14169, 7, 2, 0, 0, 14169, 14170, 7, 4, 0, 0, 14170, 2204, + 1, 0, 0, 0, 14171, 14172, 7, 14, 0, 0, 14172, 14173, 7, 6, 0, 0, 14173, + 14174, 7, 18, 0, 0, 14174, 14175, 7, 3, 0, 0, 14175, 14176, 7, 6, 0, 0, + 14176, 14177, 7, 6, 0, 0, 14177, 14178, 7, 9, 0, 0, 14178, 2206, 1, 0, + 0, 0, 14179, 14180, 7, 6, 0, 0, 14180, 14181, 7, 22, 0, 0, 14181, 14182, + 7, 20, 0, 0, 14182, 2208, 1, 0, 0, 0, 14183, 14184, 7, 5, 0, 0, 14184, + 14185, 7, 11, 0, 0, 14185, 14186, 7, 2, 0, 0, 14186, 14187, 7, 2, 0, 0, + 14187, 14188, 7, 3, 0, 0, 14188, 2210, 1, 0, 0, 0, 14189, 14190, 7, 11, + 0, 0, 14190, 14191, 7, 2, 0, 0, 14191, 14192, 7, 18, 0, 0, 14192, 14193, + 5, 49, 0, 0, 14193, 14194, 5, 48, 0, 0, 14194, 2212, 1, 0, 0, 0, 14195, + 14196, 7, 20, 0, 0, 14196, 14197, 7, 8, 0, 0, 14197, 2214, 1, 0, 0, 0, + 14198, 14199, 7, 20, 0, 0, 14199, 14200, 7, 2, 0, 0, 14200, 14201, 7, 7, + 0, 0, 14201, 14202, 7, 6, 0, 0, 14202, 14203, 7, 3, 0, 0, 14203, 2216, + 1, 0, 0, 0, 14204, 14205, 7, 3, 0, 0, 14205, 14206, 7, 0, 0, 0, 14206, + 14207, 7, 14, 0, 0, 14207, 14208, 7, 8, 0, 0, 14208, 14209, 7, 0, 0, 0, + 14209, 14210, 7, 10, 0, 0, 14210, 14211, 7, 9, 0, 0, 14211, 2218, 1, 0, + 0, 0, 14212, 14213, 7, 3, 0, 0, 14213, 14214, 7, 0, 0, 0, 14214, 14215, + 7, 10, 0, 0, 14215, 14216, 7, 14, 0, 0, 14216, 2220, 1, 0, 0, 0, 14217, + 14218, 7, 3, 0, 0, 14218, 14219, 7, 2, 0, 0, 14219, 14220, 7, 12, 0, 0, + 14220, 14221, 7, 10, 0, 0, 14221, 14222, 7, 14, 0, 0, 14222, 2222, 1, 0, + 0, 0, 14223, 14224, 7, 9, 0, 0, 14224, 14225, 7, 8, 0, 0, 14225, 14226, + 7, 18, 0, 0, 14226, 14227, 7, 10, 0, 0, 14227, 2224, 1, 0, 0, 0, 14228, + 14229, 7, 9, 0, 0, 14229, 14230, 7, 8, 0, 0, 14230, 14231, 7, 10, 0, 0, + 14231, 2226, 1, 0, 0, 0, 14232, 14233, 7, 9, 0, 0, 14233, 14234, 7, 25, + 0, 0, 14234, 14235, 7, 3, 0, 0, 14235, 14236, 7, 4, 0, 0, 14236, 2228, + 1, 0, 0, 0, 14237, 14238, 7, 9, 0, 0, 14238, 14239, 7, 25, 0, 0, 14239, + 14240, 7, 12, 0, 0, 14240, 14241, 7, 0, 0, 0, 14241, 14242, 7, 3, 0, 0, + 14242, 14243, 7, 6, 0, 0, 14243, 2230, 1, 0, 0, 0, 14244, 14245, 7, 4, + 0, 0, 14245, 14246, 7, 0, 0, 0, 14246, 14247, 7, 10, 0, 0, 14247, 2232, + 1, 0, 0, 0, 14248, 14249, 7, 13, 0, 0, 14249, 14250, 7, 12, 0, 0, 14250, + 14251, 7, 3, 0, 0, 14251, 14252, 7, 3, 0, 0, 14252, 14253, 7, 6, 0, 0, + 14253, 14254, 7, 10, 0, 0, 14254, 14255, 7, 4, 0, 0, 14255, 14256, 5, 95, + 0, 0, 14256, 14257, 7, 4, 0, 0, 14257, 14258, 7, 8, 0, 0, 14258, 14259, + 7, 17, 0, 0, 14259, 14260, 7, 6, 0, 0, 14260, 14261, 7, 23, 0, 0, 14261, + 14262, 7, 2, 0, 0, 14262, 14263, 7, 10, 0, 0, 14263, 14264, 7, 6, 0, 0, + 14264, 2234, 1, 0, 0, 0, 14265, 14266, 7, 13, 0, 0, 14266, 14267, 7, 12, + 0, 0, 14267, 14268, 7, 3, 0, 0, 14268, 14269, 7, 3, 0, 0, 14269, 14270, + 7, 6, 0, 0, 14270, 14271, 7, 10, 0, 0, 14271, 14272, 7, 4, 0, 0, 14272, + 14273, 5, 95, 0, 0, 14273, 14274, 7, 4, 0, 0, 14274, 14275, 7, 8, 0, 0, + 14275, 14276, 7, 17, 0, 0, 14276, 14277, 7, 6, 0, 0, 14277, 14278, 7, 23, + 0, 0, 14278, 14279, 7, 2, 0, 0, 14279, 14280, 7, 10, 0, 0, 14280, 14281, + 7, 6, 0, 0, 14281, 14282, 5, 95, 0, 0, 14282, 14283, 7, 8, 0, 0, 14283, + 14284, 7, 14, 0, 0, 14284, 2236, 1, 0, 0, 0, 14285, 14286, 7, 14, 0, 0, + 14286, 14287, 7, 0, 0, 0, 14287, 14288, 7, 4, 0, 0, 14288, 14289, 7, 6, + 0, 0, 14289, 14290, 5, 95, 0, 0, 14290, 14291, 7, 1, 0, 0, 14291, 14292, + 7, 12, 0, 0, 14292, 14293, 7, 13, 0, 0, 14293, 14294, 7, 21, 0, 0, 14294, + 14295, 7, 6, 0, 0, 14295, 14296, 7, 4, 0, 0, 14296, 2238, 1, 0, 0, 0, 14297, + 14298, 7, 14, 0, 0, 14298, 14299, 7, 0, 0, 0, 14299, 14300, 7, 4, 0, 0, + 14300, 14301, 7, 6, 0, 0, 14301, 14302, 7, 14, 0, 0, 14302, 14303, 7, 8, + 0, 0, 14303, 14304, 7, 5, 0, 0, 14304, 14305, 7, 5, 0, 0, 14305, 14306, + 5, 95, 0, 0, 14306, 14307, 7, 1, 0, 0, 14307, 14308, 7, 8, 0, 0, 14308, + 14309, 7, 18, 0, 0, 14309, 2240, 1, 0, 0, 0, 14310, 14311, 7, 14, 0, 0, + 14311, 14312, 7, 0, 0, 0, 14312, 14313, 7, 4, 0, 0, 14313, 14314, 7, 6, + 0, 0, 14314, 14315, 7, 5, 0, 0, 14315, 14316, 7, 3, 0, 0, 14316, 14317, + 7, 2, 0, 0, 14317, 14318, 7, 17, 0, 0, 14318, 14319, 7, 20, 0, 0, 14319, + 14320, 7, 0, 0, 0, 14320, 14321, 7, 3, 0, 0, 14321, 14322, 7, 4, 0, 0, + 14322, 14323, 7, 9, 0, 0, 14323, 2242, 1, 0, 0, 0, 14324, 14325, 7, 14, + 0, 0, 14325, 14326, 7, 0, 0, 0, 14326, 14327, 7, 4, 0, 0, 14327, 14328, + 7, 6, 0, 0, 14328, 14329, 7, 4, 0, 0, 14329, 14330, 7, 8, 0, 0, 14330, + 14331, 7, 17, 0, 0, 14331, 14332, 7, 6, 0, 0, 14332, 14333, 5, 50, 0, 0, + 14333, 14334, 7, 5, 0, 0, 14334, 14335, 7, 3, 0, 0, 14335, 14336, 7, 2, + 0, 0, 14336, 14337, 7, 17, 0, 0, 14337, 14338, 7, 20, 0, 0, 14338, 14339, + 7, 0, 0, 0, 14339, 14340, 7, 3, 0, 0, 14340, 14341, 7, 4, 0, 0, 14341, + 14342, 7, 9, 0, 0, 14342, 2244, 1, 0, 0, 0, 14343, 14344, 7, 14, 0, 0, + 14344, 14345, 7, 0, 0, 0, 14345, 14346, 7, 4, 0, 0, 14346, 14347, 7, 6, + 0, 0, 14347, 14348, 7, 4, 0, 0, 14348, 14349, 7, 8, 0, 0, 14349, 14350, + 7, 17, 0, 0, 14350, 14351, 7, 6, 0, 0, 14351, 14352, 7, 5, 0, 0, 14352, + 14353, 7, 3, 0, 0, 14353, 14354, 7, 2, 0, 0, 14354, 14355, 7, 17, 0, 0, + 14355, 14356, 7, 20, 0, 0, 14356, 14357, 7, 0, 0, 0, 14357, 14358, 7, 3, + 0, 0, 14358, 14359, 7, 4, 0, 0, 14359, 14360, 7, 9, 0, 0, 14360, 2246, + 1, 0, 0, 0, 14361, 14362, 7, 14, 0, 0, 14362, 14363, 7, 0, 0, 0, 14363, + 14364, 7, 4, 0, 0, 14364, 14365, 7, 6, 0, 0, 14365, 14366, 7, 4, 0, 0, + 14366, 14367, 7, 8, 0, 0, 14367, 14368, 7, 17, 0, 0, 14368, 14369, 7, 6, + 0, 0, 14369, 14370, 7, 2, 0, 0, 14370, 14371, 7, 5, 0, 0, 14371, 14372, + 7, 5, 0, 0, 14372, 14373, 7, 9, 0, 0, 14373, 14374, 7, 6, 0, 0, 14374, + 14375, 7, 4, 0, 0, 14375, 14376, 7, 5, 0, 0, 14376, 14377, 7, 3, 0, 0, + 14377, 14378, 7, 2, 0, 0, 14378, 14379, 7, 17, 0, 0, 14379, 14380, 7, 20, + 0, 0, 14380, 14381, 7, 0, 0, 0, 14381, 14382, 7, 3, 0, 0, 14382, 14383, + 7, 4, 0, 0, 14383, 14384, 7, 9, 0, 0, 14384, 2248, 1, 0, 0, 0, 14385, 14386, + 7, 14, 0, 0, 14386, 14387, 7, 0, 0, 0, 14387, 14388, 7, 4, 0, 0, 14388, + 14389, 7, 6, 0, 0, 14389, 14390, 7, 4, 0, 0, 14390, 14391, 7, 3, 0, 0, + 14391, 14392, 7, 12, 0, 0, 14392, 14393, 7, 10, 0, 0, 14393, 14394, 7, + 13, 0, 0, 14394, 2250, 1, 0, 0, 0, 14395, 14396, 7, 14, 0, 0, 14396, 14397, + 7, 0, 0, 0, 14397, 14398, 7, 16, 0, 0, 14398, 2252, 1, 0, 0, 0, 14399, + 14400, 7, 6, 0, 0, 14400, 14401, 7, 2, 0, 0, 14401, 14402, 7, 17, 0, 0, + 14402, 14403, 7, 2, 0, 0, 14403, 14404, 7, 10, 0, 0, 14404, 14405, 7, 4, + 0, 0, 14405, 14406, 7, 19, 0, 0, 14406, 2254, 1, 0, 0, 0, 14407, 14408, + 7, 8, 0, 0, 14408, 14409, 7, 9, 0, 0, 14409, 14410, 7, 14, 0, 0, 14410, + 14411, 7, 0, 0, 0, 14411, 14412, 7, 4, 0, 0, 14412, 14413, 7, 6, 0, 0, + 14413, 2256, 1, 0, 0, 0, 14414, 14415, 7, 17, 0, 0, 14415, 14416, 7, 2, + 0, 0, 14416, 14417, 7, 10, 0, 0, 14417, 14418, 7, 4, 0, 0, 14418, 14419, + 7, 19, 0, 0, 14419, 2258, 1, 0, 0, 0, 14420, 14421, 7, 9, 0, 0, 14421, + 14422, 7, 17, 0, 0, 14422, 14423, 7, 0, 0, 0, 14423, 14424, 7, 11, 0, 0, + 14424, 14425, 7, 11, 0, 0, 14425, 14426, 7, 14, 0, 0, 14426, 14427, 7, + 0, 0, 0, 14427, 14428, 7, 4, 0, 0, 14428, 14429, 7, 6, 0, 0, 14429, 14430, + 7, 4, 0, 0, 14430, 14431, 7, 8, 0, 0, 14431, 14432, 7, 17, 0, 0, 14432, + 14433, 7, 6, 0, 0, 14433, 14434, 7, 5, 0, 0, 14434, 14435, 7, 3, 0, 0, + 14435, 14436, 7, 2, 0, 0, 14436, 14437, 7, 17, 0, 0, 14437, 14438, 7, 20, + 0, 0, 14438, 14439, 7, 0, 0, 0, 14439, 14440, 7, 3, 0, 0, 14440, 14441, + 7, 4, 0, 0, 14441, 14442, 7, 9, 0, 0, 14442, 2260, 1, 0, 0, 0, 14443, 14444, + 7, 9, 0, 0, 14444, 14445, 7, 7, 0, 0, 14445, 14446, 7, 8, 0, 0, 14446, + 14447, 7, 4, 0, 0, 14447, 14448, 7, 13, 0, 0, 14448, 14449, 7, 19, 0, 0, + 14449, 14450, 7, 2, 0, 0, 14450, 14451, 7, 5, 0, 0, 14451, 14452, 7, 5, + 0, 0, 14452, 14453, 7, 9, 0, 0, 14453, 14454, 7, 6, 0, 0, 14454, 14455, + 7, 4, 0, 0, 14455, 2262, 1, 0, 0, 0, 14456, 14457, 7, 9, 0, 0, 14457, 14458, + 7, 16, 0, 0, 14458, 14459, 7, 9, 0, 0, 14459, 14460, 7, 14, 0, 0, 14460, + 14461, 7, 0, 0, 0, 14461, 14462, 7, 4, 0, 0, 14462, 14463, 7, 6, 0, 0, + 14463, 14464, 7, 4, 0, 0, 14464, 14465, 7, 8, 0, 0, 14465, 14466, 7, 17, + 0, 0, 14466, 14467, 7, 6, 0, 0, 14467, 2264, 1, 0, 0, 0, 14468, 14469, + 7, 9, 0, 0, 14469, 14470, 7, 16, 0, 0, 14470, 14471, 7, 9, 0, 0, 14471, + 14472, 7, 14, 0, 0, 14472, 14473, 7, 0, 0, 0, 14473, 14474, 7, 4, 0, 0, + 14474, 14475, 7, 6, 0, 0, 14475, 14476, 7, 4, 0, 0, 14476, 14477, 7, 8, + 0, 0, 14477, 14478, 7, 17, 0, 0, 14478, 14479, 7, 6, 0, 0, 14479, 14480, + 7, 2, 0, 0, 14480, 14481, 7, 5, 0, 0, 14481, 14482, 7, 5, 0, 0, 14482, + 14483, 7, 9, 0, 0, 14483, 14484, 7, 6, 0, 0, 14484, 14485, 7, 4, 0, 0, + 14485, 2266, 1, 0, 0, 0, 14486, 14487, 7, 9, 0, 0, 14487, 14488, 7, 16, + 0, 0, 14488, 14489, 7, 9, 0, 0, 14489, 14490, 7, 12, 0, 0, 14490, 14491, + 7, 4, 0, 0, 14491, 14492, 7, 13, 0, 0, 14492, 14493, 7, 14, 0, 0, 14493, + 14494, 7, 0, 0, 0, 14494, 14495, 7, 4, 0, 0, 14495, 14496, 7, 6, 0, 0, + 14496, 14497, 7, 4, 0, 0, 14497, 14498, 7, 8, 0, 0, 14498, 14499, 7, 17, + 0, 0, 14499, 14500, 7, 6, 0, 0, 14500, 2268, 1, 0, 0, 0, 14501, 14502, + 7, 4, 0, 0, 14502, 14503, 7, 8, 0, 0, 14503, 14504, 7, 17, 0, 0, 14504, + 14505, 7, 6, 0, 0, 14505, 14506, 7, 5, 0, 0, 14506, 14507, 7, 3, 0, 0, + 14507, 14508, 7, 2, 0, 0, 14508, 14509, 7, 17, 0, 0, 14509, 14510, 7, 20, + 0, 0, 14510, 14511, 7, 0, 0, 0, 14511, 14512, 7, 3, 0, 0, 14512, 14513, + 7, 4, 0, 0, 14513, 14514, 7, 9, 0, 0, 14514, 2270, 1, 0, 0, 0, 14515, 14516, + 7, 4, 0, 0, 14516, 14517, 7, 2, 0, 0, 14517, 14518, 7, 14, 0, 0, 14518, + 14519, 7, 0, 0, 0, 14519, 14520, 7, 4, 0, 0, 14520, 14521, 7, 6, 0, 0, + 14521, 14522, 7, 4, 0, 0, 14522, 14523, 7, 8, 0, 0, 14523, 14524, 7, 17, + 0, 0, 14524, 14525, 7, 6, 0, 0, 14525, 14526, 7, 2, 0, 0, 14526, 14527, + 7, 5, 0, 0, 14527, 14528, 7, 5, 0, 0, 14528, 14529, 7, 9, 0, 0, 14529, + 14530, 7, 6, 0, 0, 14530, 14531, 7, 4, 0, 0, 14531, 2272, 1, 0, 0, 0, 14532, + 14533, 7, 16, 0, 0, 14533, 14534, 7, 6, 0, 0, 14534, 14535, 7, 0, 0, 0, + 14535, 14536, 7, 3, 0, 0, 14536, 2274, 1, 0, 0, 0, 14537, 14538, 7, 25, + 0, 0, 14538, 14539, 7, 12, 0, 0, 14539, 14540, 7, 0, 0, 0, 14540, 14541, + 7, 3, 0, 0, 14541, 14542, 7, 4, 0, 0, 14542, 14543, 7, 6, 0, 0, 14543, + 14544, 7, 3, 0, 0, 14544, 2276, 1, 0, 0, 0, 14545, 14546, 7, 14, 0, 0, + 14546, 14547, 7, 0, 0, 0, 14547, 14548, 7, 16, 0, 0, 14548, 14549, 7, 2, + 0, 0, 14549, 14550, 7, 5, 0, 0, 14550, 14551, 7, 16, 0, 0, 14551, 14552, + 7, 6, 0, 0, 14552, 14553, 7, 0, 0, 0, 14553, 14554, 7, 3, 0, 0, 14554, + 2278, 1, 0, 0, 0, 14555, 14556, 7, 7, 0, 0, 14556, 14557, 7, 6, 0, 0, 14557, + 14558, 7, 6, 0, 0, 14558, 14559, 7, 21, 0, 0, 14559, 2280, 1, 0, 0, 0, + 14560, 14561, 7, 19, 0, 0, 14561, 14562, 7, 2, 0, 0, 14562, 14563, 7, 12, + 0, 0, 14563, 14564, 7, 3, 0, 0, 14564, 2282, 1, 0, 0, 0, 14565, 14566, + 7, 17, 0, 0, 14566, 14567, 7, 8, 0, 0, 14567, 14568, 7, 10, 0, 0, 14568, + 14569, 7, 12, 0, 0, 14569, 14570, 7, 4, 0, 0, 14570, 14571, 7, 6, 0, 0, + 14571, 2284, 1, 0, 0, 0, 14572, 14573, 7, 9, 0, 0, 14573, 14574, 7, 6, + 0, 0, 14574, 14575, 7, 13, 0, 0, 14575, 14576, 7, 2, 0, 0, 14576, 14577, + 7, 10, 0, 0, 14577, 14578, 7, 14, 0, 0, 14578, 2286, 1, 0, 0, 0, 14579, + 14580, 7, 17, 0, 0, 14580, 14581, 7, 8, 0, 0, 14581, 14582, 7, 11, 0, 0, + 14582, 14583, 7, 11, 0, 0, 14583, 14584, 7, 8, 0, 0, 14584, 14585, 7, 9, + 0, 0, 14585, 14586, 7, 6, 0, 0, 14586, 14587, 7, 13, 0, 0, 14587, 14588, + 7, 2, 0, 0, 14588, 14589, 7, 10, 0, 0, 14589, 14590, 7, 14, 0, 0, 14590, + 2288, 1, 0, 0, 0, 14591, 14592, 7, 17, 0, 0, 14592, 14593, 7, 8, 0, 0, + 14593, 14594, 7, 13, 0, 0, 14594, 14595, 7, 3, 0, 0, 14595, 14596, 7, 2, + 0, 0, 14596, 14597, 7, 9, 0, 0, 14597, 14598, 7, 6, 0, 0, 14598, 14599, + 7, 13, 0, 0, 14599, 14600, 7, 2, 0, 0, 14600, 14601, 7, 10, 0, 0, 14601, + 14602, 7, 14, 0, 0, 14602, 2290, 1, 0, 0, 0, 14603, 14604, 7, 10, 0, 0, + 14604, 14605, 7, 0, 0, 0, 14605, 14606, 7, 10, 0, 0, 14606, 14607, 7, 2, + 0, 0, 14607, 14608, 7, 9, 0, 0, 14608, 14609, 7, 6, 0, 0, 14609, 14610, + 7, 13, 0, 0, 14610, 14611, 7, 2, 0, 0, 14611, 14612, 7, 10, 0, 0, 14612, + 14613, 7, 14, 0, 0, 14613, 2292, 1, 0, 0, 0, 14614, 14615, 7, 4, 0, 0, + 14615, 14616, 7, 23, 0, 0, 14616, 14617, 7, 2, 0, 0, 14617, 14618, 7, 5, + 0, 0, 14618, 14619, 7, 5, 0, 0, 14619, 14620, 7, 9, 0, 0, 14620, 14621, + 7, 6, 0, 0, 14621, 14622, 7, 4, 0, 0, 14622, 2294, 1, 0, 0, 0, 14623, 14624, + 7, 8, 0, 0, 14624, 14625, 7, 9, 0, 0, 14625, 14626, 7, 2, 0, 0, 14626, + 14627, 5, 95, 0, 0, 14627, 14628, 7, 7, 0, 0, 14628, 14629, 7, 6, 0, 0, + 14629, 14630, 7, 6, 0, 0, 14630, 14631, 7, 21, 0, 0, 14631, 2296, 1, 0, + 0, 0, 14632, 14633, 7, 7, 0, 0, 14633, 14634, 7, 6, 0, 0, 14634, 14635, + 7, 6, 0, 0, 14635, 14636, 7, 21, 0, 0, 14636, 14637, 7, 14, 0, 0, 14637, + 14638, 7, 0, 0, 0, 14638, 14639, 7, 16, 0, 0, 14639, 2298, 1, 0, 0, 0, + 14640, 14641, 7, 16, 0, 0, 14641, 14647, 7, 16, 0, 0, 14642, 14643, 7, + 16, 0, 0, 14643, 14644, 7, 16, 0, 0, 14644, 14645, 7, 16, 0, 0, 14645, + 14647, 7, 16, 0, 0, 14646, 14640, 1, 0, 0, 0, 14646, 14642, 1, 0, 0, 0, + 14647, 2300, 1, 0, 0, 0, 14648, 14649, 7, 25, 0, 0, 14649, 14652, 7, 25, + 0, 0, 14650, 14652, 7, 25, 0, 0, 14651, 14648, 1, 0, 0, 0, 14651, 14650, + 1, 0, 0, 0, 14652, 2302, 1, 0, 0, 0, 14653, 14654, 7, 17, 0, 0, 14654, + 14657, 7, 17, 0, 0, 14655, 14657, 7, 17, 0, 0, 14656, 14653, 1, 0, 0, 0, + 14656, 14655, 1, 0, 0, 0, 14657, 2304, 1, 0, 0, 0, 14658, 14659, 7, 14, + 0, 0, 14659, 14662, 7, 16, 0, 0, 14660, 14662, 7, 16, 0, 0, 14661, 14658, + 1, 0, 0, 0, 14661, 14660, 1, 0, 0, 0, 14662, 2306, 1, 0, 0, 0, 14663, 14664, + 7, 14, 0, 0, 14664, 14667, 7, 14, 0, 0, 14665, 14667, 7, 14, 0, 0, 14666, + 14663, 1, 0, 0, 0, 14666, 14665, 1, 0, 0, 0, 14667, 2308, 1, 0, 0, 0, 14668, + 14669, 7, 7, 0, 0, 14669, 14673, 7, 21, 0, 0, 14670, 14671, 7, 7, 0, 0, + 14671, 14673, 7, 7, 0, 0, 14672, 14668, 1, 0, 0, 0, 14672, 14670, 1, 0, + 0, 0, 14673, 2310, 1, 0, 0, 0, 14674, 14675, 7, 19, 0, 0, 14675, 14676, + 7, 19, 0, 0, 14676, 2312, 1, 0, 0, 0, 14677, 14678, 7, 17, 0, 0, 14678, + 14681, 7, 8, 0, 0, 14679, 14681, 7, 10, 0, 0, 14680, 14677, 1, 0, 0, 0, + 14680, 14679, 1, 0, 0, 0, 14681, 2314, 1, 0, 0, 0, 14682, 14683, 7, 9, + 0, 0, 14683, 14686, 7, 9, 0, 0, 14684, 14686, 7, 9, 0, 0, 14685, 14682, + 1, 0, 0, 0, 14685, 14684, 1, 0, 0, 0, 14686, 2316, 1, 0, 0, 0, 14687, 14688, + 7, 17, 0, 0, 14688, 14689, 7, 9, 0, 0, 14689, 2318, 1, 0, 0, 0, 14690, + 14691, 7, 17, 0, 0, 14691, 14692, 7, 13, 0, 0, 14692, 14693, 7, 9, 0, 0, + 14693, 2320, 1, 0, 0, 0, 14694, 14695, 7, 10, 0, 0, 14695, 14696, 7, 9, + 0, 0, 14696, 2322, 1, 0, 0, 0, 14697, 14698, 7, 4, 0, 0, 14698, 14699, + 7, 23, 0, 0, 14699, 2324, 1, 0, 0, 0, 14700, 14701, 7, 8, 0, 0, 14701, + 14702, 7, 9, 0, 0, 14702, 14703, 7, 2, 0, 0, 14703, 14704, 7, 7, 0, 0, + 14704, 14711, 7, 21, 0, 0, 14705, 14706, 7, 8, 0, 0, 14706, 14707, 7, 9, + 0, 0, 14707, 14708, 7, 2, 0, 0, 14708, 14709, 7, 7, 0, 0, 14709, 14711, + 7, 7, 0, 0, 14710, 14700, 1, 0, 0, 0, 14710, 14705, 1, 0, 0, 0, 14711, + 2326, 1, 0, 0, 0, 14712, 14713, 7, 14, 0, 0, 14713, 14714, 7, 7, 0, 0, + 14714, 2328, 1, 0, 0, 0, 14715, 14716, 7, 9, 0, 0, 14716, 14717, 7, 20, + 0, 0, 14717, 14718, 5, 95, 0, 0, 14718, 14719, 7, 6, 0, 0, 14719, 14720, + 7, 22, 0, 0, 14720, 14721, 7, 6, 0, 0, 14721, 14722, 7, 13, 0, 0, 14722, + 14723, 7, 12, 0, 0, 14723, 14724, 7, 4, 0, 0, 14724, 14725, 7, 6, 0, 0, + 14725, 14726, 7, 9, 0, 0, 14726, 14727, 7, 25, 0, 0, 14727, 14728, 7, 11, + 0, 0, 14728, 2330, 1, 0, 0, 0, 14729, 14730, 7, 15, 0, 0, 14730, 14731, + 7, 0, 0, 0, 14731, 14732, 7, 3, 0, 0, 14732, 14733, 7, 13, 0, 0, 14733, + 14734, 7, 19, 0, 0, 14734, 14735, 7, 0, 0, 0, 14735, 14736, 7, 3, 0, 0, + 14736, 2332, 1, 0, 0, 0, 14737, 14738, 7, 10, 0, 0, 14738, 14739, 7, 15, + 0, 0, 14739, 14740, 7, 0, 0, 0, 14740, 14741, 7, 3, 0, 0, 14741, 14742, + 7, 13, 0, 0, 14742, 14743, 7, 19, 0, 0, 14743, 14744, 7, 0, 0, 0, 14744, + 14745, 7, 3, 0, 0, 14745, 2334, 1, 0, 0, 0, 14746, 14747, 7, 27, 0, 0, + 14747, 14748, 7, 28, 0, 0, 14748, 2336, 1, 0, 0, 0, 14749, 14750, 5, 36, + 0, 0, 14750, 14751, 7, 0, 0, 0, 14751, 14752, 7, 13, 0, 0, 14752, 14753, + 7, 4, 0, 0, 14753, 14754, 7, 8, 0, 0, 14754, 14755, 7, 2, 0, 0, 14755, + 14756, 7, 10, 0, 0, 14756, 2338, 1, 0, 0, 0, 14757, 14758, 5, 64, 0, 0, + 14758, 14759, 5, 64, 0, 0, 14759, 14760, 7, 13, 0, 0, 14760, 14761, 7, + 12, 0, 0, 14761, 14762, 7, 3, 0, 0, 14762, 14763, 7, 9, 0, 0, 14763, 14764, + 7, 2, 0, 0, 14764, 14765, 7, 3, 0, 0, 14765, 14766, 5, 95, 0, 0, 14766, + 14767, 7, 3, 0, 0, 14767, 14768, 7, 2, 0, 0, 14768, 14769, 7, 7, 0, 0, + 14769, 14770, 7, 9, 0, 0, 14770, 2340, 1, 0, 0, 0, 14771, 14772, 5, 64, + 0, 0, 14772, 14773, 5, 64, 0, 0, 14773, 14774, 7, 5, 0, 0, 14774, 14775, + 7, 6, 0, 0, 14775, 14776, 7, 4, 0, 0, 14776, 14777, 7, 13, 0, 0, 14777, + 14778, 7, 19, 0, 0, 14778, 14779, 5, 95, 0, 0, 14779, 14780, 7, 9, 0, 0, + 14780, 14781, 7, 4, 0, 0, 14781, 14782, 7, 0, 0, 0, 14782, 14783, 7, 4, + 0, 0, 14783, 14784, 7, 12, 0, 0, 14784, 14785, 7, 9, 0, 0, 14785, 2342, + 1, 0, 0, 0, 14786, 14788, 3, 2449, 1224, 0, 14787, 14786, 1, 0, 0, 0, 14788, + 14789, 1, 0, 0, 0, 14789, 14787, 1, 0, 0, 0, 14789, 14790, 1, 0, 0, 0, + 14790, 14791, 1, 0, 0, 0, 14791, 14793, 5, 46, 0, 0, 14792, 14794, 3, 2449, + 1224, 0, 14793, 14792, 1, 0, 0, 0, 14794, 14795, 1, 0, 0, 0, 14795, 14793, + 1, 0, 0, 0, 14795, 14796, 1, 0, 0, 0, 14796, 14797, 1, 0, 0, 0, 14797, + 14799, 5, 46, 0, 0, 14798, 14800, 3, 2449, 1224, 0, 14799, 14798, 1, 0, + 0, 0, 14800, 14801, 1, 0, 0, 0, 14801, 14799, 1, 0, 0, 0, 14801, 14802, + 1, 0, 0, 0, 14802, 14803, 1, 0, 0, 0, 14803, 14805, 5, 46, 0, 0, 14804, + 14806, 3, 2449, 1224, 0, 14805, 14804, 1, 0, 0, 0, 14806, 14807, 1, 0, + 0, 0, 14807, 14805, 1, 0, 0, 0, 14807, 14808, 1, 0, 0, 0, 14808, 2344, + 1, 0, 0, 0, 14809, 14810, 7, 29, 0, 0, 14810, 14811, 1, 0, 0, 0, 14811, + 14812, 6, 1172, 0, 0, 14812, 2346, 1, 0, 0, 0, 14813, 14814, 5, 47, 0, + 0, 14814, 14815, 5, 42, 0, 0, 14815, 14820, 1, 0, 0, 0, 14816, 14819, 3, + 2347, 1173, 0, 14817, 14819, 9, 0, 0, 0, 14818, 14816, 1, 0, 0, 0, 14818, + 14817, 1, 0, 0, 0, 14819, 14822, 1, 0, 0, 0, 14820, 14821, 1, 0, 0, 0, + 14820, 14818, 1, 0, 0, 0, 14821, 14823, 1, 0, 0, 0, 14822, 14820, 1, 0, + 0, 0, 14823, 14824, 5, 42, 0, 0, 14824, 14825, 5, 47, 0, 0, 14825, 14826, + 1, 0, 0, 0, 14826, 14827, 6, 1173, 0, 0, 14827, 2348, 1, 0, 0, 0, 14828, + 14829, 5, 45, 0, 0, 14829, 14830, 5, 45, 0, 0, 14830, 14834, 1, 0, 0, 0, + 14831, 14833, 8, 30, 0, 0, 14832, 14831, 1, 0, 0, 0, 14833, 14836, 1, 0, + 0, 0, 14834, 14832, 1, 0, 0, 0, 14834, 14835, 1, 0, 0, 0, 14835, 14837, + 1, 0, 0, 0, 14836, 14834, 1, 0, 0, 0, 14837, 14838, 6, 1174, 0, 0, 14838, + 2350, 1, 0, 0, 0, 14839, 14841, 5, 34, 0, 0, 14840, 14842, 8, 26, 0, 0, + 14841, 14840, 1, 0, 0, 0, 14842, 14843, 1, 0, 0, 0, 14843, 14841, 1, 0, + 0, 0, 14843, 14844, 1, 0, 0, 0, 14844, 14845, 1, 0, 0, 0, 14845, 14846, + 5, 34, 0, 0, 14846, 2352, 1, 0, 0, 0, 14847, 14848, 5, 34, 0, 0, 14848, + 14849, 5, 34, 0, 0, 14849, 2354, 1, 0, 0, 0, 14850, 14851, 5, 39, 0, 0, + 14851, 2356, 1, 0, 0, 0, 14852, 14858, 5, 91, 0, 0, 14853, 14857, 8, 31, + 0, 0, 14854, 14855, 5, 93, 0, 0, 14855, 14857, 5, 93, 0, 0, 14856, 14853, + 1, 0, 0, 0, 14856, 14854, 1, 0, 0, 0, 14857, 14860, 1, 0, 0, 0, 14858, + 14856, 1, 0, 0, 0, 14858, 14859, 1, 0, 0, 0, 14859, 14861, 1, 0, 0, 0, + 14860, 14858, 1, 0, 0, 0, 14861, 14862, 5, 93, 0, 0, 14862, 2358, 1, 0, + 0, 0, 14863, 14868, 5, 64, 0, 0, 14864, 14867, 7, 32, 0, 0, 14865, 14867, + 3, 2451, 1225, 0, 14866, 14864, 1, 0, 0, 0, 14866, 14865, 1, 0, 0, 0, 14867, + 14870, 1, 0, 0, 0, 14868, 14866, 1, 0, 0, 0, 14868, 14869, 1, 0, 0, 0, + 14869, 2360, 1, 0, 0, 0, 14870, 14868, 1, 0, 0, 0, 14871, 14876, 5, 35, + 0, 0, 14872, 14875, 7, 32, 0, 0, 14873, 14875, 3, 2451, 1225, 0, 14874, + 14872, 1, 0, 0, 0, 14874, 14873, 1, 0, 0, 0, 14875, 14878, 1, 0, 0, 0, + 14876, 14874, 1, 0, 0, 0, 14876, 14877, 1, 0, 0, 0, 14877, 2362, 1, 0, + 0, 0, 14878, 14876, 1, 0, 0, 0, 14879, 14881, 3, 2449, 1224, 0, 14880, + 14879, 1, 0, 0, 0, 14881, 14882, 1, 0, 0, 0, 14882, 14880, 1, 0, 0, 0, + 14882, 14883, 1, 0, 0, 0, 14883, 2364, 1, 0, 0, 0, 14884, 14887, 7, 33, + 0, 0, 14885, 14887, 3, 2451, 1225, 0, 14886, 14884, 1, 0, 0, 0, 14886, + 14885, 1, 0, 0, 0, 14887, 14892, 1, 0, 0, 0, 14888, 14891, 7, 32, 0, 0, + 14889, 14891, 3, 2451, 1225, 0, 14890, 14888, 1, 0, 0, 0, 14890, 14889, + 1, 0, 0, 0, 14891, 14894, 1, 0, 0, 0, 14892, 14890, 1, 0, 0, 0, 14892, + 14893, 1, 0, 0, 0, 14893, 2366, 1, 0, 0, 0, 14894, 14892, 1, 0, 0, 0, 14895, + 14897, 5, 78, 0, 0, 14896, 14895, 1, 0, 0, 0, 14896, 14897, 1, 0, 0, 0, + 14897, 14898, 1, 0, 0, 0, 14898, 14904, 5, 39, 0, 0, 14899, 14903, 8, 34, + 0, 0, 14900, 14901, 5, 39, 0, 0, 14901, 14903, 5, 39, 0, 0, 14902, 14899, + 1, 0, 0, 0, 14902, 14900, 1, 0, 0, 0, 14903, 14906, 1, 0, 0, 0, 14904, + 14902, 1, 0, 0, 0, 14904, 14905, 1, 0, 0, 0, 14905, 14907, 1, 0, 0, 0, + 14906, 14904, 1, 0, 0, 0, 14907, 14908, 5, 39, 0, 0, 14908, 2368, 1, 0, + 0, 0, 14909, 14910, 5, 48, 0, 0, 14910, 14914, 7, 22, 0, 0, 14911, 14913, + 3, 2447, 1223, 0, 14912, 14911, 1, 0, 0, 0, 14913, 14916, 1, 0, 0, 0, 14914, + 14912, 1, 0, 0, 0, 14914, 14915, 1, 0, 0, 0, 14915, 2370, 1, 0, 0, 0, 14916, + 14914, 1, 0, 0, 0, 14917, 14918, 3, 2445, 1222, 0, 14918, 2372, 1, 0, 0, + 0, 14919, 14922, 3, 2363, 1181, 0, 14920, 14922, 3, 2445, 1222, 0, 14921, + 14919, 1, 0, 0, 0, 14921, 14920, 1, 0, 0, 0, 14922, 14923, 1, 0, 0, 0, + 14923, 14925, 7, 6, 0, 0, 14924, 14926, 7, 35, 0, 0, 14925, 14924, 1, 0, + 0, 0, 14925, 14926, 1, 0, 0, 0, 14926, 14928, 1, 0, 0, 0, 14927, 14929, + 3, 2449, 1224, 0, 14928, 14927, 1, 0, 0, 0, 14929, 14930, 1, 0, 0, 0, 14930, + 14928, 1, 0, 0, 0, 14930, 14931, 1, 0, 0, 0, 14931, 2374, 1, 0, 0, 0, 14932, + 14933, 5, 61, 0, 0, 14933, 2376, 1, 0, 0, 0, 14934, 14935, 5, 62, 0, 0, + 14935, 2378, 1, 0, 0, 0, 14936, 14937, 5, 60, 0, 0, 14937, 2380, 1, 0, + 0, 0, 14938, 14939, 5, 33, 0, 0, 14939, 2382, 1, 0, 0, 0, 14940, 14941, + 5, 43, 0, 0, 14941, 14942, 5, 61, 0, 0, 14942, 2384, 1, 0, 0, 0, 14943, + 14944, 5, 45, 0, 0, 14944, 14945, 5, 61, 0, 0, 14945, 2386, 1, 0, 0, 0, + 14946, 14947, 5, 42, 0, 0, 14947, 14948, 5, 61, 0, 0, 14948, 2388, 1, 0, + 0, 0, 14949, 14950, 5, 47, 0, 0, 14950, 14951, 5, 61, 0, 0, 14951, 2390, + 1, 0, 0, 0, 14952, 14953, 5, 37, 0, 0, 14953, 14954, 5, 61, 0, 0, 14954, + 2392, 1, 0, 0, 0, 14955, 14956, 5, 38, 0, 0, 14956, 14957, 5, 61, 0, 0, + 14957, 2394, 1, 0, 0, 0, 14958, 14959, 5, 94, 0, 0, 14959, 14960, 5, 61, + 0, 0, 14960, 2396, 1, 0, 0, 0, 14961, 14962, 5, 124, 0, 0, 14962, 14963, + 5, 61, 0, 0, 14963, 2398, 1, 0, 0, 0, 14964, 14965, 5, 124, 0, 0, 14965, + 14966, 5, 124, 0, 0, 14966, 2400, 1, 0, 0, 0, 14967, 14968, 5, 46, 0, 0, + 14968, 2402, 1, 0, 0, 0, 14969, 14970, 5, 95, 0, 0, 14970, 2404, 1, 0, + 0, 0, 14971, 14972, 5, 64, 0, 0, 14972, 2406, 1, 0, 0, 0, 14973, 14974, + 5, 35, 0, 0, 14974, 2408, 1, 0, 0, 0, 14975, 14976, 5, 36, 0, 0, 14976, + 2410, 1, 0, 0, 0, 14977, 14978, 5, 40, 0, 0, 14978, 2412, 1, 0, 0, 0, 14979, + 14980, 5, 41, 0, 0, 14980, 2414, 1, 0, 0, 0, 14981, 14982, 5, 44, 0, 0, + 14982, 2416, 1, 0, 0, 0, 14983, 14984, 5, 59, 0, 0, 14984, 2418, 1, 0, + 0, 0, 14985, 14986, 5, 58, 0, 0, 14986, 2420, 1, 0, 0, 0, 14987, 14988, + 5, 58, 0, 0, 14988, 14989, 5, 58, 0, 0, 14989, 2422, 1, 0, 0, 0, 14990, + 14991, 5, 42, 0, 0, 14991, 2424, 1, 0, 0, 0, 14992, 14993, 5, 47, 0, 0, + 14993, 2426, 1, 0, 0, 0, 14994, 14995, 5, 37, 0, 0, 14995, 2428, 1, 0, + 0, 0, 14996, 14997, 5, 43, 0, 0, 14997, 2430, 1, 0, 0, 0, 14998, 14999, + 5, 45, 0, 0, 14999, 2432, 1, 0, 0, 0, 15000, 15001, 5, 126, 0, 0, 15001, + 2434, 1, 0, 0, 0, 15002, 15003, 5, 124, 0, 0, 15003, 2436, 1, 0, 0, 0, + 15004, 15005, 5, 38, 0, 0, 15005, 2438, 1, 0, 0, 0, 15006, 15007, 5, 94, + 0, 0, 15007, 2440, 1, 0, 0, 0, 15008, 15009, 5, 63, 0, 0, 15009, 2442, + 1, 0, 0, 0, 15010, 15011, 7, 36, 0, 0, 15011, 2444, 1, 0, 0, 0, 15012, + 15014, 3, 2449, 1224, 0, 15013, 15012, 1, 0, 0, 0, 15014, 15015, 1, 0, + 0, 0, 15015, 15013, 1, 0, 0, 0, 15015, 15016, 1, 0, 0, 0, 15016, 15017, + 1, 0, 0, 0, 15017, 15019, 5, 46, 0, 0, 15018, 15020, 3, 2449, 1224, 0, + 15019, 15018, 1, 0, 0, 0, 15020, 15021, 1, 0, 0, 0, 15021, 15019, 1, 0, + 0, 0, 15021, 15022, 1, 0, 0, 0, 15022, 15037, 1, 0, 0, 0, 15023, 15025, + 3, 2449, 1224, 0, 15024, 15023, 1, 0, 0, 0, 15025, 15026, 1, 0, 0, 0, 15026, + 15024, 1, 0, 0, 0, 15026, 15027, 1, 0, 0, 0, 15027, 15028, 1, 0, 0, 0, + 15028, 15029, 5, 46, 0, 0, 15029, 15037, 1, 0, 0, 0, 15030, 15032, 5, 46, + 0, 0, 15031, 15033, 3, 2449, 1224, 0, 15032, 15031, 1, 0, 0, 0, 15033, + 15034, 1, 0, 0, 0, 15034, 15032, 1, 0, 0, 0, 15034, 15035, 1, 0, 0, 0, + 15035, 15037, 1, 0, 0, 0, 15036, 15013, 1, 0, 0, 0, 15036, 15024, 1, 0, + 0, 0, 15036, 15030, 1, 0, 0, 0, 15037, 2446, 1, 0, 0, 0, 15038, 15039, + 7, 37, 0, 0, 15039, 2448, 1, 0, 0, 0, 15040, 15041, 7, 38, 0, 0, 15041, + 2450, 1, 0, 0, 0, 15042, 15043, 7, 39, 0, 0, 15043, 2452, 1, 0, 0, 0, 43, + 0, 4690, 6109, 10065, 14646, 14651, 14656, 14661, 14666, 14672, 14680, + 14685, 14710, 14789, 14795, 14801, 14807, 14818, 14820, 14834, 14843, 14856, + 14858, 14866, 14868, 14874, 14876, 14882, 14886, 14890, 14892, 14896, 14902, + 14904, 14914, 14921, 14925, 14930, 15015, 15021, 15026, 15034, 15036, 1, + 0, 1, 0, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// TSqlLexerInit initializes any static state used to implement TSqlLexer. By default the +// static state used to implement the lexer is lazily initialized during the first call to +// NewTSqlLexer(). You can call this function if you wish to initialize the static state ahead +// of time. +func TSqlLexerInit() { + staticData := &TSqlLexerLexerStaticData + staticData.once.Do(tsqllexerLexerInit) +} + +// NewTSqlLexer produces a new lexer instance for the optional input antlr.CharStream. +func NewTSqlLexer(input antlr.CharStream) *TSqlLexer { + TSqlLexerInit() + l := new(TSqlLexer) + l.BaseLexer = antlr.NewBaseLexer(input) + staticData := &TSqlLexerLexerStaticData + l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) + l.channelNames = staticData.ChannelNames + l.modeNames = staticData.ModeNames + l.RuleNames = staticData.RuleNames + l.LiteralNames = staticData.LiteralNames + l.SymbolicNames = staticData.SymbolicNames + l.GrammarFileName = "TSqlLexer.g4" + // TODO: l.EOF = antlr.TokenEOF + + return l +} + +// TSqlLexer tokens. +const ( + TSqlLexerABORT = 1 + TSqlLexerABORT_AFTER_WAIT = 2 + TSqlLexerABSENT = 3 + TSqlLexerABSOLUTE = 4 + TSqlLexerACCELERATED_DATABASE_RECOVERY = 5 + TSqlLexerACCENT_SENSITIVITY = 6 + TSqlLexerACCESS = 7 + TSqlLexerACTION = 8 + TSqlLexerACTIVATION = 9 + TSqlLexerACTIVE = 10 + TSqlLexerADD = 11 + TSqlLexerADDRESS = 12 + TSqlLexerADMINISTER = 13 + TSqlLexerAES = 14 + TSqlLexerAES_128 = 15 + TSqlLexerAES_192 = 16 + TSqlLexerAES_256 = 17 + TSqlLexerAFFINITY = 18 + TSqlLexerAFTER = 19 + TSqlLexerAGGREGATE = 20 + TSqlLexerALGORITHM = 21 + TSqlLexerALL = 22 + TSqlLexerALLOWED = 23 + TSqlLexerALLOW_CONNECTIONS = 24 + TSqlLexerALLOW_ENCRYPTED_VALUE_MODIFICATIONS = 25 + TSqlLexerALLOW_MULTIPLE_EVENT_LOSS = 26 + TSqlLexerALLOW_PAGE_LOCKS = 27 + TSqlLexerALLOW_ROW_LOCKS = 28 + TSqlLexerALLOW_SINGLE_EVENT_LOSS = 29 + TSqlLexerALLOW_SNAPSHOT_ISOLATION = 30 + TSqlLexerALL_CONSTRAINTS = 31 + TSqlLexerALL_ERRORMSGS = 32 + TSqlLexerALL_INDEXES = 33 + TSqlLexerALL_LEVELS = 34 + TSqlLexerALTER = 35 + TSqlLexerALWAYS = 36 + TSqlLexerAND = 37 + TSqlLexerANONYMOUS = 38 + TSqlLexerANSI_DEFAULTS = 39 + TSqlLexerANSI_NULLS = 40 + TSqlLexerANSI_NULL_DEFAULT = 41 + TSqlLexerANSI_NULL_DFLT_OFF = 42 + TSqlLexerANSI_NULL_DFLT_ON = 43 + TSqlLexerANSI_PADDING = 44 + TSqlLexerANSI_WARNINGS = 45 + TSqlLexerANY = 46 + TSqlLexerAPPEND = 47 + TSqlLexerAPPLICATION = 48 + TSqlLexerAPPLICATION_LOG = 49 + TSqlLexerAPPLOCK_MODE = 50 + TSqlLexerAPPLOCK_TEST = 51 + TSqlLexerAPPLY = 52 + TSqlLexerAPP_NAME = 53 + TSqlLexerARITHABORT = 54 + TSqlLexerARITHIGNORE = 55 + TSqlLexerAS = 56 + TSqlLexerASC = 57 + TSqlLexerASCII = 58 + TSqlLexerASSEMBLY = 59 + TSqlLexerASSEMBLYPROPERTY = 60 + TSqlLexerASYMMETRIC = 61 + TSqlLexerASYNCHRONOUS_COMMIT = 62 + TSqlLexerAT_KEYWORD = 63 + TSqlLexerAUDIT = 64 + TSqlLexerAUDIT_GUID = 65 + TSqlLexerAUTHENTICATE = 66 + TSqlLexerAUTHENTICATION = 67 + TSqlLexerAUTHORIZATION = 68 + TSqlLexerAUTO = 69 + TSqlLexerAUTOGROW_ALL_FILES = 70 + TSqlLexerAUTOGROW_SINGLE_FILE = 71 + TSqlLexerAUTOMATED_BACKUP_PREFERENCE = 72 + TSqlLexerAUTOMATIC = 73 + TSqlLexerAUTO_CLEANUP = 74 + TSqlLexerAUTO_CLOSE = 75 + TSqlLexerAUTO_CREATE_STATISTICS = 76 + TSqlLexerAUTO_DROP = 77 + TSqlLexerAUTO_SHRINK = 78 + TSqlLexerAUTO_UPDATE_STATISTICS = 79 + TSqlLexerAUTO_UPDATE_STATISTICS_ASYNC = 80 + TSqlLexerAVAILABILITY = 81 + TSqlLexerAVAILABILITY_MODE = 82 + TSqlLexerAVG = 83 + TSqlLexerBACKSLASH = 84 + TSqlLexerBACKUP = 85 + TSqlLexerBACKUP_CLONEDB = 86 + TSqlLexerBACKUP_PRIORITY = 87 + TSqlLexerBASE64 = 88 + TSqlLexerBEFORE = 89 + TSqlLexerBEGIN = 90 + TSqlLexerBEGIN_DIALOG = 91 + TSqlLexerBETWEEN = 92 + TSqlLexerBIGINT = 93 + TSqlLexerBINARY_CHECKSUM = 94 + TSqlLexerBINARY_KEYWORD = 95 + TSqlLexerBINDING = 96 + TSqlLexerBLOB_STORAGE = 97 + TSqlLexerBLOCK = 98 + TSqlLexerBLOCKERS = 99 + TSqlLexerBLOCKING_HIERARCHY = 100 + TSqlLexerBLOCKSIZE = 101 + TSqlLexerBOUNDING_BOX = 102 + TSqlLexerBREAK = 103 + TSqlLexerBROKER = 104 + TSqlLexerBROKER_INSTANCE = 105 + TSqlLexerBROWSE = 106 + TSqlLexerBUFFER = 107 + TSqlLexerBUFFERCOUNT = 108 + TSqlLexerBULK = 109 + TSqlLexerBULK_LOGGED = 110 + TSqlLexerBY = 111 + TSqlLexerCACHE = 112 + TSqlLexerCALLED = 113 + TSqlLexerCALLER = 114 + TSqlLexerCAP_CPU_PERCENT = 115 + TSqlLexerCASCADE = 116 + TSqlLexerCASE = 117 + TSqlLexerCAST = 118 + TSqlLexerCATALOG = 119 + TSqlLexerCATCH = 120 + TSqlLexerCELLS_PER_OBJECT = 121 + TSqlLexerCERTENCODED = 122 + TSqlLexerCERTIFICATE = 123 + TSqlLexerCERTPRIVATEKEY = 124 + TSqlLexerCERT_ID = 125 + TSqlLexerCHANGE = 126 + TSqlLexerCHANGES = 127 + TSqlLexerCHANGETABLE = 128 + TSqlLexerCHANGE_RETENTION = 129 + TSqlLexerCHANGE_TRACKING = 130 + TSqlLexerCHAR = 131 + TSqlLexerCHARINDEX = 132 + TSqlLexerCHECK = 133 + TSqlLexerCHECKALLOC = 134 + TSqlLexerCHECKCATALOG = 135 + TSqlLexerCHECKCONSTRAINTS = 136 + TSqlLexerCHECKDB = 137 + TSqlLexerCHECKFILEGROUP = 138 + TSqlLexerCHECKPOINT = 139 + TSqlLexerCHECKSUM = 140 + TSqlLexerCHECKSUM_AGG = 141 + TSqlLexerCHECKTABLE = 142 + TSqlLexerCHECK_EXPIRATION = 143 + TSqlLexerCHECK_POLICY = 144 + TSqlLexerCLASSIFIER_FUNCTION = 145 + TSqlLexerCLEANTABLE = 146 + TSqlLexerCLEANUP = 147 + TSqlLexerCLONEDATABASE = 148 + TSqlLexerCLOSE = 149 + TSqlLexerCLUSTER = 150 + TSqlLexerCLUSTERED = 151 + TSqlLexerCOALESCE = 152 + TSqlLexerCOLLATE = 153 + TSqlLexerCOLLECTION = 154 + TSqlLexerCOLUMN = 155 + TSqlLexerCOLUMNPROPERTY = 156 + TSqlLexerCOLUMNS = 157 + TSqlLexerCOLUMNSTORE = 158 + TSqlLexerCOLUMNSTORE_ARCHIVE = 159 + TSqlLexerCOLUMN_ENCRYPTION_KEY = 160 + TSqlLexerCOLUMN_MASTER_KEY = 161 + TSqlLexerCOL_LENGTH = 162 + TSqlLexerCOL_NAME = 163 + TSqlLexerCOMMIT = 164 + TSqlLexerCOMMITTED = 165 + TSqlLexerCOMPATIBILITY_LEVEL = 166 + TSqlLexerCOMPRESS = 167 + TSqlLexerCOMPRESSION = 168 + TSqlLexerCOMPRESSION_DELAY = 169 + TSqlLexerCOMPRESS_ALL_ROW_GROUPS = 170 + TSqlLexerCOMPUTE = 171 + TSqlLexerCONCAT = 172 + TSqlLexerCONCAT_NULL_YIELDS_NULL = 173 + TSqlLexerCONCAT_WS = 174 + TSqlLexerCONFIGURATION = 175 + TSqlLexerCONNECT = 176 + TSqlLexerCONNECTION = 177 + TSqlLexerCONNECTIONPROPERTY = 178 + TSqlLexerCONSTRAINT = 179 + TSqlLexerCONTAINMENT = 180 + TSqlLexerCONTAINS = 181 + TSqlLexerCONTAINSTABLE = 182 + TSqlLexerCONTENT = 183 + TSqlLexerCONTEXT = 184 + TSqlLexerCONTEXT_INFO = 185 + TSqlLexerCONTINUE = 186 + TSqlLexerCONTINUE_AFTER_ERROR = 187 + TSqlLexerCONTRACT = 188 + TSqlLexerCONTRACT_NAME = 189 + TSqlLexerCONTROL = 190 + TSqlLexerCONVERSATION = 191 + TSqlLexerCONVERT = 192 + TSqlLexerCOOKIE = 193 + TSqlLexerCOPY_ONLY = 194 + TSqlLexerCOUNT = 195 + TSqlLexerCOUNTER = 196 + TSqlLexerCOUNT_BIG = 197 + TSqlLexerCPU = 198 + TSqlLexerCREATE = 199 + TSqlLexerCREATE_NEW = 200 + TSqlLexerCREATION_DISPOSITION = 201 + TSqlLexerCREDENTIAL = 202 + TSqlLexerCROSS = 203 + TSqlLexerCRYPTOGRAPHIC = 204 + TSqlLexerCUME_DIST = 205 + TSqlLexerCURRENT = 206 + TSqlLexerCURRENT_DATE = 207 + TSqlLexerCURRENT_REQUEST_ID = 208 + TSqlLexerCURRENT_TIME = 209 + TSqlLexerCURRENT_TIMESTAMP = 210 + TSqlLexerCURRENT_TRANSACTION_ID = 211 + TSqlLexerCURRENT_USER = 212 + TSqlLexerCURSOR = 213 + TSqlLexerCURSOR_CLOSE_ON_COMMIT = 214 + TSqlLexerCURSOR_DEFAULT = 215 + TSqlLexerCURSOR_STATUS = 216 + TSqlLexerCYCLE = 217 + TSqlLexerDATA = 218 + TSqlLexerDATABASE = 219 + TSqlLexerDATABASEPROPERTYEX = 220 + TSqlLexerDATABASE_MIRRORING = 221 + TSqlLexerDATABASE_PRINCIPAL_ID = 222 + TSqlLexerDATALENGTH = 223 + TSqlLexerDATASPACE = 224 + TSqlLexerDATA_COMPRESSION = 225 + TSqlLexerDATA_PURITY = 226 + TSqlLexerDATA_SOURCE = 227 + TSqlLexerDATEADD = 228 + TSqlLexerDATEDIFF = 229 + TSqlLexerDATENAME = 230 + TSqlLexerDATEPART = 231 + TSqlLexerDATE_CORRELATION_OPTIMIZATION = 232 + TSqlLexerDAYS = 233 + TSqlLexerDBCC = 234 + TSqlLexerDBREINDEX = 235 + TSqlLexerDB_CHAINING = 236 + TSqlLexerDB_FAILOVER = 237 + TSqlLexerDB_ID = 238 + TSqlLexerDB_NAME = 239 + TSqlLexerDDL = 240 + TSqlLexerDEALLOCATE = 241 + TSqlLexerDECLARE = 242 + TSqlLexerDECOMPRESS = 243 + TSqlLexerDECRYPTION = 244 + TSqlLexerDEFAULT = 245 + TSqlLexerDEFAULT_DATABASE = 246 + TSqlLexerDEFAULT_DOUBLE_QUOTE = 247 + TSqlLexerDEFAULT_FULLTEXT_LANGUAGE = 248 + TSqlLexerDEFAULT_LANGUAGE = 249 + TSqlLexerDEFAULT_SCHEMA = 250 + TSqlLexerDEFINITION = 251 + TSqlLexerDELAY = 252 + TSqlLexerDELAYED_DURABILITY = 253 + TSqlLexerDELETE = 254 + TSqlLexerDELETED = 255 + TSqlLexerDENSE_RANK = 256 + TSqlLexerDENY = 257 + TSqlLexerDEPENDENTS = 258 + TSqlLexerDES = 259 + TSqlLexerDESC = 260 + TSqlLexerDESCRIPTION = 261 + TSqlLexerDESX = 262 + TSqlLexerDETERMINISTIC = 263 + TSqlLexerDHCP = 264 + TSqlLexerDIAGNOSTICS = 265 + TSqlLexerDIALOG = 266 + TSqlLexerDIFFERENCE = 267 + TSqlLexerDIFFERENTIAL = 268 + TSqlLexerDIRECTORY_NAME = 269 + TSqlLexerDISABLE = 270 + TSqlLexerDISABLED = 271 + TSqlLexerDISABLE_BROKER = 272 + TSqlLexerDISK = 273 + TSqlLexerDISTINCT = 274 + TSqlLexerDISTRIBUTED = 275 + TSqlLexerDISTRIBUTION = 276 + TSqlLexerDOCUMENT = 277 + TSqlLexerDOLLAR_PARTITION = 278 + TSqlLexerDOUBLE = 279 + TSqlLexerDOUBLE_BACK_SLASH = 280 + TSqlLexerDOUBLE_FORWARD_SLASH = 281 + TSqlLexerDROP = 282 + TSqlLexerDROPCLEANBUFFERS = 283 + TSqlLexerDROP_EXISTING = 284 + TSqlLexerDTC_SUPPORT = 285 + TSqlLexerDUMP = 286 + TSqlLexerDYNAMIC = 287 + TSqlLexerELEMENTS = 288 + TSqlLexerELSE = 289 + TSqlLexerEMERGENCY = 290 + TSqlLexerEMPTY = 291 + TSqlLexerENABLE = 292 + TSqlLexerENABLED = 293 + TSqlLexerENABLE_BROKER = 294 + TSqlLexerENCRYPTED = 295 + TSqlLexerENCRYPTED_VALUE = 296 + TSqlLexerENCRYPTION = 297 + TSqlLexerENCRYPTION_TYPE = 298 + TSqlLexerEND = 299 + TSqlLexerENDPOINT = 300 + TSqlLexerENDPOINT_URL = 301 + TSqlLexerERRLVL = 302 + TSqlLexerERROR = 303 + TSqlLexerERROR_BROKER_CONVERSATIONS = 304 + TSqlLexerERROR_LINE = 305 + TSqlLexerERROR_MESSAGE = 306 + TSqlLexerERROR_NUMBER = 307 + TSqlLexerERROR_PROCEDURE = 308 + TSqlLexerERROR_SEVERITY = 309 + TSqlLexerERROR_STATE = 310 + TSqlLexerESCAPE = 311 + TSqlLexerESTIMATEONLY = 312 + TSqlLexerEVENT = 313 + TSqlLexerEVENTDATA = 314 + TSqlLexerEVENT_RETENTION_MODE = 315 + TSqlLexerEXCEPT = 316 + TSqlLexerEXCLUSIVE = 317 + TSqlLexerEXECUTABLE = 318 + TSqlLexerEXECUTABLE_FILE = 319 + TSqlLexerEXECUTE = 320 + TSqlLexerEXIST = 321 + TSqlLexerEXISTS = 322 + TSqlLexerEXIST_SQUARE_BRACKET = 323 + TSqlLexerEXIT = 324 + TSqlLexerEXPAND = 325 + TSqlLexerEXPIREDATE = 326 + TSqlLexerEXPIRY_DATE = 327 + TSqlLexerEXPLICIT = 328 + TSqlLexerEXTENDED_LOGICAL_CHECKS = 329 + TSqlLexerEXTENSION = 330 + TSqlLexerEXTERNAL = 331 + TSqlLexerEXTERNAL_ACCESS = 332 + TSqlLexerFAILOVER = 333 + TSqlLexerFAILOVER_MODE = 334 + TSqlLexerFAILURE = 335 + TSqlLexerFAILURECONDITIONLEVEL = 336 + TSqlLexerFAILURE_CONDITION_LEVEL = 337 + TSqlLexerFAIL_OPERATION = 338 + TSqlLexerFAN_IN = 339 + TSqlLexerFAST = 340 + TSqlLexerFAST_FORWARD = 341 + TSqlLexerFETCH = 342 + TSqlLexerFILE = 343 + TSqlLexerFILEGROUP = 344 + TSqlLexerFILEGROUPPROPERTY = 345 + TSqlLexerFILEGROUP_ID = 346 + TSqlLexerFILEGROUP_NAME = 347 + TSqlLexerFILEGROWTH = 348 + TSqlLexerFILENAME = 349 + TSqlLexerFILEPATH = 350 + TSqlLexerFILEPROPERTY = 351 + TSqlLexerFILEPROPERTYEX = 352 + TSqlLexerFILESTREAM = 353 + TSqlLexerFILESTREAM_ON = 354 + TSqlLexerFILE_ID = 355 + TSqlLexerFILE_IDEX = 356 + TSqlLexerFILE_NAME = 357 + TSqlLexerFILE_SNAPSHOT = 358 + TSqlLexerFILLFACTOR = 359 + TSqlLexerFILTER = 360 + TSqlLexerFIRST = 361 + TSqlLexerFIRST_VALUE = 362 + TSqlLexerFMTONLY = 363 + TSqlLexerFOLLOWING = 364 + TSqlLexerFOR = 365 + TSqlLexerFORCE = 366 + TSqlLexerFORCED = 367 + TSqlLexerFORCEPLAN = 368 + TSqlLexerFORCESCAN = 369 + TSqlLexerFORCESEEK = 370 + TSqlLexerFORCE_FAILOVER_ALLOW_DATA_LOSS = 371 + TSqlLexerFORCE_SERVICE_ALLOW_DATA_LOSS = 372 + TSqlLexerFOREIGN = 373 + TSqlLexerFORMAT = 374 + TSqlLexerFORMATMESSAGE = 375 + TSqlLexerFORWARD_ONLY = 376 + TSqlLexerFREE = 377 + TSqlLexerFREETEXT = 378 + TSqlLexerFREETEXTTABLE = 379 + TSqlLexerFROM = 380 + TSqlLexerFULL = 381 + TSqlLexerFULLSCAN = 382 + TSqlLexerFULLTEXT = 383 + TSqlLexerFULLTEXTCATALOGPROPERTY = 384 + TSqlLexerFULLTEXTSERVICEPROPERTY = 385 + TSqlLexerFUNCTION = 386 + TSqlLexerGB = 387 + TSqlLexerGENERATED = 388 + TSqlLexerGEOGRAPHY = 389 + TSqlLexerGEOGRAPHY_AUTO_GRID = 390 + TSqlLexerGEOGRAPHY_GRID = 391 + TSqlLexerGEOMETRY = 392 + TSqlLexerGEOMETRY_AUTO_GRID = 393 + TSqlLexerGEOMETRY_GRID = 394 + TSqlLexerGET = 395 + TSqlLexerGRIDS = 396 + TSqlLexerGETANCESTOR = 397 + TSqlLexerGETANSINULL = 398 + TSqlLexerGETDATE = 399 + TSqlLexerGETDESCENDANT = 400 + TSqlLexerGETLEVEL = 401 + TSqlLexerGETREPARENTEDVALUE = 402 + TSqlLexerGETROOT = 403 + TSqlLexerGETUTCDATE = 404 + TSqlLexerGET_FILESTREAM_TRANSACTION_CONTEXT = 405 + TSqlLexerGLOBAL = 406 + TSqlLexerGO = 407 + TSqlLexerGOTO = 408 + TSqlLexerGOVERNOR = 409 + TSqlLexerGRANT = 410 + TSqlLexerGREATEST = 411 + TSqlLexerGROUP = 412 + TSqlLexerGROUPING = 413 + TSqlLexerGROUPING_ID = 414 + TSqlLexerGROUP_MAX_REQUESTS = 415 + TSqlLexerHADR = 416 + TSqlLexerHASH = 417 + TSqlLexerHASHED = 418 + TSqlLexerHAS_DBACCESS = 419 + TSqlLexerHAS_PERMS_BY_NAME = 420 + TSqlLexerHAVING = 421 + TSqlLexerHEALTHCHECKTIMEOUT = 422 + TSqlLexerHEALTH_CHECK_TIMEOUT = 423 + TSqlLexerHEAP = 424 + TSqlLexerHIDDEN_KEYWORD = 425 + TSqlLexerHIERARCHYID = 426 + TSqlLexerHIGH = 427 + TSqlLexerHOLDLOCK = 428 + TSqlLexerHONOR_BROKER_PRIORITY = 429 + TSqlLexerHOST_ID = 430 + TSqlLexerHOST_NAME = 431 + TSqlLexerHOURS = 432 + TSqlLexerIDENTITY = 433 + TSqlLexerIDENTITYCOL = 434 + TSqlLexerIDENTITY_INSERT = 435 + TSqlLexerIDENTITY_VALUE = 436 + TSqlLexerIDENT_CURRENT = 437 + TSqlLexerIDENT_INCR = 438 + TSqlLexerIDENT_SEED = 439 + TSqlLexerIF = 440 + TSqlLexerIGNORE_CONSTRAINTS = 441 + TSqlLexerIGNORE_DUP_KEY = 442 + TSqlLexerIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX = 443 + TSqlLexerIGNORE_REPLICATED_TABLE_CACHE = 444 + TSqlLexerIGNORE_TRIGGERS = 445 + TSqlLexerIIF = 446 + TSqlLexerIMMEDIATE = 447 + TSqlLexerIMPERSONATE = 448 + TSqlLexerIMPLICIT_TRANSACTIONS = 449 + TSqlLexerIMPORTANCE = 450 + TSqlLexerIN = 451 + TSqlLexerINCLUDE = 452 + TSqlLexerINCLUDE_NULL_VALUES = 453 + TSqlLexerINCREMENT = 454 + TSqlLexerINCREMENTAL = 455 + TSqlLexerINDEX = 456 + TSqlLexerINDEXKEY_PROPERTY = 457 + TSqlLexerINDEXPROPERTY = 458 + TSqlLexerINDEX_COL = 459 + TSqlLexerINFINITE = 460 + TSqlLexerINIT = 461 + TSqlLexerINITIATOR = 462 + TSqlLexerINNER = 463 + TSqlLexerINPUT = 464 + TSqlLexerINSENSITIVE = 465 + TSqlLexerINSERT = 466 + TSqlLexerINSERTED = 467 + TSqlLexerINSTEAD = 468 + TSqlLexerINT = 469 + TSqlLexerINTERSECT = 470 + TSqlLexerINTO = 471 + TSqlLexerIO = 472 + TSqlLexerIP = 473 + TSqlLexerIS = 474 + TSqlLexerISDESCENDANTOF = 475 + TSqlLexerISJSON = 476 + TSqlLexerISNULL = 477 + TSqlLexerISNUMERIC = 478 + TSqlLexerISOLATION = 479 + TSqlLexerIS_MEMBER = 480 + TSqlLexerIS_ROLEMEMBER = 481 + TSqlLexerIS_SRVROLEMEMBER = 482 + TSqlLexerJOB = 483 + TSqlLexerJOIN = 484 + TSqlLexerJSON = 485 + TSqlLexerJSON_ARRAY = 486 + TSqlLexerJSON_MODIFY = 487 + TSqlLexerJSON_OBJECT = 488 + TSqlLexerJSON_PATH_EXISTS = 489 + TSqlLexerJSON_QUERY = 490 + TSqlLexerJSON_VALUE = 491 + TSqlLexerKB = 492 + TSqlLexerKEEP = 493 + TSqlLexerKEEPDEFAULTS = 494 + TSqlLexerKEEPFIXED = 495 + TSqlLexerKEEPIDENTITY = 496 + TSqlLexerKERBEROS = 497 + TSqlLexerKEY = 498 + TSqlLexerKEYS = 499 + TSqlLexerKEYSET = 500 + TSqlLexerKEY_PATH = 501 + TSqlLexerKEY_SOURCE = 502 + TSqlLexerKEY_STORE_PROVIDER_NAME = 503 + TSqlLexerKILL = 504 + TSqlLexerLAG = 505 + TSqlLexerLANGUAGE = 506 + TSqlLexerLAST = 507 + TSqlLexerLAST_VALUE = 508 + TSqlLexerLEAD = 509 + TSqlLexerLEAST = 510 + TSqlLexerLEFT = 511 + TSqlLexerLEN = 512 + TSqlLexerLEVEL = 513 + TSqlLexerLEVEL_1 = 514 + TSqlLexerLEVEL_2 = 515 + TSqlLexerLEVEL_3 = 516 + TSqlLexerLEVEL_4 = 517 + TSqlLexerLIBRARY = 518 + TSqlLexerLIFETIME = 519 + TSqlLexerLIKE = 520 + TSqlLexerLINENO = 521 + TSqlLexerLINKED = 522 + TSqlLexerLINUX = 523 + TSqlLexerLIST = 524 + TSqlLexerLISTENER = 525 + TSqlLexerLISTENER_IP = 526 + TSqlLexerLISTENER_PORT = 527 + TSqlLexerLISTENER_URL = 528 + TSqlLexerLOAD = 529 + TSqlLexerLOB_COMPACTION = 530 + TSqlLexerLOCAL = 531 + TSqlLexerLOCAL_SERVICE_NAME = 532 + TSqlLexerLOCATION = 533 + TSqlLexerLOCK = 534 + TSqlLexerLOCK_ESCALATION = 535 + TSqlLexerLOG = 536 + TSqlLexerLOGIN = 537 + TSqlLexerLOGINPROPERTY = 538 + TSqlLexerLOOP = 539 + TSqlLexerLOW = 540 + TSqlLexerLOWER = 541 + TSqlLexerLTRIM = 542 + TSqlLexerMANUAL = 543 + TSqlLexerMARK = 544 + TSqlLexerMASK = 545 + TSqlLexerMASKED = 546 + TSqlLexerMASTER = 547 + TSqlLexerMATCHED = 548 + TSqlLexerMATERIALIZED = 549 + TSqlLexerMAX = 550 + TSqlLexerMAXDOP = 551 + TSqlLexerMAXRECURSION = 552 + TSqlLexerMAXSIZE = 553 + TSqlLexerMAXTRANSFER = 554 + TSqlLexerMAXVALUE = 555 + TSqlLexerMAX_CPU_PERCENT = 556 + TSqlLexerMAX_DISPATCH_LATENCY = 557 + TSqlLexerMAX_DOP = 558 + TSqlLexerMAX_DURATION = 559 + TSqlLexerMAX_EVENT_SIZE = 560 + TSqlLexerMAX_FILES = 561 + TSqlLexerMAX_IOPS_PER_VOLUME = 562 + TSqlLexerMAX_MEMORY = 563 + TSqlLexerMAX_MEMORY_PERCENT = 564 + TSqlLexerMAX_OUTSTANDING_IO_PER_VOLUME = 565 + TSqlLexerMAX_PROCESSES = 566 + TSqlLexerMAX_QUEUE_READERS = 567 + TSqlLexerMAX_ROLLOVER_FILES = 568 + TSqlLexerMAX_SIZE = 569 + TSqlLexerMB = 570 + TSqlLexerMEDIADESCRIPTION = 571 + TSqlLexerMEDIANAME = 572 + TSqlLexerMEDIUM = 573 + TSqlLexerMEMBER = 574 + TSqlLexerMEMORY_OPTIMIZED_DATA = 575 + TSqlLexerMEMORY_PARTITION_MODE = 576 + TSqlLexerMERGE = 577 + TSqlLexerMESSAGE = 578 + TSqlLexerMESSAGE_FORWARDING = 579 + TSqlLexerMESSAGE_FORWARD_SIZE = 580 + TSqlLexerMIN = 581 + TSqlLexerMINUTES = 582 + TSqlLexerMINVALUE = 583 + TSqlLexerMIN_ACTIVE_ROWVERSION = 584 + TSqlLexerMIN_CPU_PERCENT = 585 + TSqlLexerMIN_IOPS_PER_VOLUME = 586 + TSqlLexerMIN_MEMORY_PERCENT = 587 + TSqlLexerMIRROR = 588 + TSqlLexerMIRROR_ADDRESS = 589 + TSqlLexerMIXED_PAGE_ALLOCATION = 590 + TSqlLexerMODE = 591 + TSqlLexerMODIFY = 592 + TSqlLexerMODIFY_SQUARE_BRACKET = 593 + TSqlLexerMOVE = 594 + TSqlLexerMULTI_USER = 595 + TSqlLexerMUST_CHANGE = 596 + TSqlLexerNAME = 597 + TSqlLexerNATIONAL = 598 + TSqlLexerNCHAR = 599 + TSqlLexerNEGOTIATE = 600 + TSqlLexerNESTED_TRIGGERS = 601 + TSqlLexerNEWID = 602 + TSqlLexerNEWNAME = 603 + TSqlLexerNEWSEQUENTIALID = 604 + TSqlLexerNEW_ACCOUNT = 605 + TSqlLexerNEW_BROKER = 606 + TSqlLexerNEW_PASSWORD = 607 + TSqlLexerNEXT = 608 + TSqlLexerNO = 609 + TSqlLexerNOCHECK = 610 + TSqlLexerNOCOUNT = 611 + TSqlLexerNODES = 612 + TSqlLexerNOEXEC = 613 + TSqlLexerNOEXPAND = 614 + TSqlLexerNOFORMAT = 615 + TSqlLexerNOHOLDLOCK = 616 + TSqlLexerNOINDEX = 617 + TSqlLexerNOINIT = 618 + TSqlLexerNOLOCK = 619 + TSqlLexerNONCLUSTERED = 620 + TSqlLexerNONE = 621 + TSqlLexerNON_TRANSACTED_ACCESS = 622 + TSqlLexerNORECOMPUTE = 623 + TSqlLexerNORECOVERY = 624 + TSqlLexerNOREWIND = 625 + TSqlLexerNOSKIP = 626 + TSqlLexerNOT = 627 + TSqlLexerNOTIFICATION = 628 + TSqlLexerNOTIFICATIONS = 629 + TSqlLexerNOUNLOAD = 630 + TSqlLexerNOWAIT = 631 + TSqlLexerNO_CHECKSUM = 632 + TSqlLexerNO_COMPRESSION = 633 + TSqlLexerNO_EVENT_LOSS = 634 + TSqlLexerNO_INFOMSGS = 635 + TSqlLexerNO_QUERYSTORE = 636 + TSqlLexerNO_STATISTICS = 637 + TSqlLexerNO_TRUNCATE = 638 + TSqlLexerNO_WAIT = 639 + TSqlLexerNTILE = 640 + TSqlLexerNTLM = 641 + TSqlLexerNULLIF = 642 + TSqlLexerNULL_ = 643 + TSqlLexerNULL_DOUBLE_QUOTE = 644 + TSqlLexerNUMANODE = 645 + TSqlLexerNUMBER = 646 + TSqlLexerNUMERIC_ROUNDABORT = 647 + TSqlLexerOBJECT = 648 + TSqlLexerOBJECTPROPERTY = 649 + TSqlLexerOBJECTPROPERTYEX = 650 + TSqlLexerOBJECT_DEFINITION = 651 + TSqlLexerOBJECT_ID = 652 + TSqlLexerOBJECT_NAME = 653 + TSqlLexerOBJECT_SCHEMA_NAME = 654 + TSqlLexerOF = 655 + TSqlLexerOFF = 656 + TSqlLexerOFFLINE = 657 + TSqlLexerOFFSET = 658 + TSqlLexerOFFSETS = 659 + TSqlLexerOLD_ACCOUNT = 660 + TSqlLexerOLD_PASSWORD = 661 + TSqlLexerON = 662 + TSqlLexerONLINE = 663 + TSqlLexerONLY = 664 + TSqlLexerON_FAILURE = 665 + TSqlLexerOPEN = 666 + TSqlLexerOPENDATASOURCE = 667 + TSqlLexerOPENJSON = 668 + TSqlLexerOPENQUERY = 669 + TSqlLexerOPENROWSET = 670 + TSqlLexerOPENXML = 671 + TSqlLexerOPEN_EXISTING = 672 + TSqlLexerOPERATIONS = 673 + TSqlLexerOPTIMISTIC = 674 + TSqlLexerOPTIMIZE = 675 + TSqlLexerOPTIMIZE_FOR_SEQUENTIAL_KEY = 676 + TSqlLexerOPTION = 677 + TSqlLexerOR = 678 + TSqlLexerORDER = 679 + TSqlLexerORIGINAL_DB_NAME = 680 + TSqlLexerORIGINAL_LOGIN = 681 + TSqlLexerOUT = 682 + TSqlLexerOUTER = 683 + TSqlLexerOUTPUT = 684 + TSqlLexerOVER = 685 + TSqlLexerOVERRIDE = 686 + TSqlLexerOWNER = 687 + TSqlLexerOWNERSHIP = 688 + TSqlLexerPAD_INDEX = 689 + TSqlLexerPAGE = 690 + TSqlLexerPAGECOUNT = 691 + TSqlLexerPAGE_VERIFY = 692 + TSqlLexerPAGLOCK = 693 + TSqlLexerPARAMETERIZATION = 694 + TSqlLexerPARAM_NODE = 695 + TSqlLexerPARSE = 696 + TSqlLexerPARSENAME = 697 + TSqlLexerPARSEONLY = 698 + TSqlLexerPARTIAL = 699 + TSqlLexerPARTITION = 700 + TSqlLexerPARTITIONS = 701 + TSqlLexerPARTNER = 702 + TSqlLexerPASSWORD = 703 + TSqlLexerPATH = 704 + TSqlLexerPATINDEX = 705 + TSqlLexerPAUSE = 706 + TSqlLexerPDW_SHOWSPACEUSED = 707 + TSqlLexerPERCENT = 708 + TSqlLexerPERCENTILE_CONT = 709 + TSqlLexerPERCENTILE_DISC = 710 + TSqlLexerPERCENT_RANK = 711 + TSqlLexerPERMISSIONS = 712 + TSqlLexerPERMISSION_SET = 713 + TSqlLexerPERSISTED = 714 + TSqlLexerPERSIST_SAMPLE_PERCENT = 715 + TSqlLexerPER_CPU = 716 + TSqlLexerPER_DB = 717 + TSqlLexerPER_NODE = 718 + TSqlLexerPHYSICAL_ONLY = 719 + TSqlLexerPIVOT = 720 + TSqlLexerPLAN = 721 + TSqlLexerPLATFORM = 722 + TSqlLexerPOISON_MESSAGE_HANDLING = 723 + TSqlLexerPOLICY = 724 + TSqlLexerPOOL = 725 + TSqlLexerPORT = 726 + TSqlLexerPRECEDING = 727 + TSqlLexerPRECISION = 728 + TSqlLexerPREDICATE = 729 + TSqlLexerPRIMARY = 730 + TSqlLexerPRIMARY_ROLE = 731 + TSqlLexerPRINT = 732 + TSqlLexerPRIOR = 733 + TSqlLexerPRIORITY = 734 + TSqlLexerPRIORITY_LEVEL = 735 + TSqlLexerPRIVATE = 736 + TSqlLexerPRIVATE_KEY = 737 + TSqlLexerPRIVILEGES = 738 + TSqlLexerPROC = 739 + TSqlLexerPROCCACHE = 740 + TSqlLexerPROCEDURE = 741 + TSqlLexerPROCEDURE_NAME = 742 + TSqlLexerPROCESS = 743 + TSqlLexerPROFILE = 744 + TSqlLexerPROPERTY = 745 + TSqlLexerPROVIDER = 746 + TSqlLexerPROVIDER_KEY_NAME = 747 + TSqlLexerPUBLIC = 748 + TSqlLexerPWDCOMPARE = 749 + TSqlLexerPWDENCRYPT = 750 + TSqlLexerPYTHON = 751 + TSqlLexerQUERY = 752 + TSqlLexerQUERY_SQUARE_BRACKET = 753 + TSqlLexerQUEUE = 754 + TSqlLexerQUEUE_DELAY = 755 + TSqlLexerQUOTED_IDENTIFIER = 756 + TSqlLexerQUOTENAME = 757 + TSqlLexerR = 758 + TSqlLexerRAISERROR = 759 + TSqlLexerRANDOMIZED = 760 + TSqlLexerRANGE = 761 + TSqlLexerRANK = 762 + TSqlLexerRAW = 763 + TSqlLexerRC2 = 764 + TSqlLexerRC4 = 765 + TSqlLexerRC4_128 = 766 + TSqlLexerREAD = 767 + TSqlLexerREADCOMMITTED = 768 + TSqlLexerREADCOMMITTEDLOCK = 769 + TSqlLexerREADONLY = 770 + TSqlLexerREADPAST = 771 + TSqlLexerREADTEXT = 772 + TSqlLexerREADUNCOMMITTED = 773 + TSqlLexerREADWRITE = 774 + TSqlLexerREAD_COMMITTED_SNAPSHOT = 775 + TSqlLexerREAD_ONLY = 776 + TSqlLexerREAD_ONLY_ROUTING_LIST = 777 + TSqlLexerREAD_WRITE = 778 + TSqlLexerREAD_WRITE_FILEGROUPS = 779 + TSqlLexerREBUILD = 780 + TSqlLexerRECEIVE = 781 + TSqlLexerRECOMPILE = 782 + TSqlLexerRECONFIGURE = 783 + TSqlLexerRECOVERY = 784 + TSqlLexerRECURSIVE_TRIGGERS = 785 + TSqlLexerREFERENCES = 786 + TSqlLexerREGENERATE = 787 + TSqlLexerRELATED_CONVERSATION = 788 + TSqlLexerRELATED_CONVERSATION_GROUP = 789 + TSqlLexerRELATIVE = 790 + TSqlLexerREMOTE = 791 + TSqlLexerREMOTE_PROC_TRANSACTIONS = 792 + TSqlLexerREMOTE_SERVICE_NAME = 793 + TSqlLexerREMOVE = 794 + TSqlLexerREORGANIZE = 795 + TSqlLexerREPAIR_ALLOW_DATA_LOSS = 796 + TSqlLexerREPAIR_FAST = 797 + TSqlLexerREPAIR_REBUILD = 798 + TSqlLexerREPEATABLE = 799 + TSqlLexerREPEATABLEREAD = 800 + TSqlLexerREPLACE = 801 + TSqlLexerREPLICA = 802 + TSqlLexerREPLICATE = 803 + TSqlLexerREPLICATION = 804 + TSqlLexerREQUEST_MAX_CPU_TIME_SEC = 805 + TSqlLexerREQUEST_MAX_MEMORY_GRANT_PERCENT = 806 + TSqlLexerREQUEST_MEMORY_GRANT_TIMEOUT_SEC = 807 + TSqlLexerREQUIRED = 808 + TSqlLexerREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT = 809 + TSqlLexerRESAMPLE = 810 + TSqlLexerRESERVE_DISK_SPACE = 811 + TSqlLexerRESET = 812 + TSqlLexerRESOURCE = 813 + TSqlLexerRESOURCES = 814 + TSqlLexerRESOURCE_MANAGER_LOCATION = 815 + TSqlLexerRESTART = 816 + TSqlLexerRESTORE = 817 + TSqlLexerRESTRICT = 818 + TSqlLexerRESTRICTED_USER = 819 + TSqlLexerRESUMABLE = 820 + TSqlLexerRESUME = 821 + TSqlLexerRETAINDAYS = 822 + TSqlLexerRETENTION = 823 + TSqlLexerRETURN = 824 + TSqlLexerRETURNS = 825 + TSqlLexerREVERSE = 826 + TSqlLexerREVERT = 827 + TSqlLexerREVOKE = 828 + TSqlLexerREWIND = 829 + TSqlLexerRIGHT = 830 + TSqlLexerROBUST = 831 + TSqlLexerROLE = 832 + TSqlLexerROLLBACK = 833 + TSqlLexerROOT = 834 + TSqlLexerROUND_ROBIN = 835 + TSqlLexerROUTE = 836 + TSqlLexerROW = 837 + TSqlLexerROWCOUNT = 838 + TSqlLexerROWCOUNT_BIG = 839 + TSqlLexerROWGUID = 840 + TSqlLexerROWGUIDCOL = 841 + TSqlLexerROWLOCK = 842 + TSqlLexerROWS = 843 + TSqlLexerROW_NUMBER = 844 + TSqlLexerRSA_1024 = 845 + TSqlLexerRSA_2048 = 846 + TSqlLexerRSA_3072 = 847 + TSqlLexerRSA_4096 = 848 + TSqlLexerRSA_512 = 849 + TSqlLexerRTRIM = 850 + TSqlLexerRULE = 851 + TSqlLexerSAFE = 852 + TSqlLexerSAFETY = 853 + TSqlLexerSAMPLE = 854 + TSqlLexerSAVE = 855 + TSqlLexerSCHEDULER = 856 + TSqlLexerSCHEMA = 857 + TSqlLexerSCHEMABINDING = 858 + TSqlLexerSCHEMA_ID = 859 + TSqlLexerSCHEMA_NAME = 860 + TSqlLexerSCHEME = 861 + TSqlLexerSCOPED = 862 + TSqlLexerSCOPE_IDENTITY = 863 + TSqlLexerSCRIPT = 864 + TSqlLexerSCROLL = 865 + TSqlLexerSCROLL_LOCKS = 866 + TSqlLexerSEARCH = 867 + TSqlLexerSECONDARY = 868 + TSqlLexerSECONDARY_ONLY = 869 + TSqlLexerSECONDARY_ROLE = 870 + TSqlLexerSECONDS = 871 + TSqlLexerSECRET = 872 + TSqlLexerSECURABLES = 873 + TSqlLexerSECURITY = 874 + TSqlLexerSECURITYAUDIT = 875 + TSqlLexerSECURITY_LOG = 876 + TSqlLexerSEEDING_MODE = 877 + TSqlLexerSELECT = 878 + TSqlLexerSELF = 879 + TSqlLexerSEMANTICKEYPHRASETABLE = 880 + TSqlLexerSEMANTICSIMILARITYDETAILSTABLE = 881 + TSqlLexerSEMANTICSIMILARITYTABLE = 882 + TSqlLexerSEMI_SENSITIVE = 883 + TSqlLexerSEND = 884 + TSqlLexerSENT = 885 + TSqlLexerSEQUENCE = 886 + TSqlLexerSEQUENCE_NUMBER = 887 + TSqlLexerSERIALIZABLE = 888 + TSqlLexerSERVER = 889 + TSqlLexerSERVERPROPERTY = 890 + TSqlLexerSERVICE = 891 + TSqlLexerSERVICEBROKER = 892 + TSqlLexerSERVICE_BROKER = 893 + TSqlLexerSERVICE_NAME = 894 + TSqlLexerSESSION = 895 + TSqlLexerSESSIONPROPERTY = 896 + TSqlLexerSESSION_CONTEXT = 897 + TSqlLexerSESSION_TIMEOUT = 898 + TSqlLexerSESSION_USER = 899 + TSqlLexerSET = 900 + TSqlLexerSETERROR = 901 + TSqlLexerSETS = 902 + TSqlLexerSETTINGS = 903 + TSqlLexerSETUSER = 904 + TSqlLexerSHARE = 905 + TSqlLexerSHARED = 906 + TSqlLexerSHOWCONTIG = 907 + TSqlLexerSHOWPLAN = 908 + TSqlLexerSHOWPLAN_ALL = 909 + TSqlLexerSHOWPLAN_TEXT = 910 + TSqlLexerSHOWPLAN_XML = 911 + TSqlLexerSHRINKLOG = 912 + TSqlLexerSHUTDOWN = 913 + TSqlLexerSID = 914 + TSqlLexerSIGNATURE = 915 + TSqlLexerSIMPLE = 916 + TSqlLexerSINGLE_USER = 917 + TSqlLexerSIZE = 918 + TSqlLexerSKIP_KEYWORD = 919 + TSqlLexerSMALLINT = 920 + TSqlLexerSNAPSHOT = 921 + TSqlLexerSOFTNUMA = 922 + TSqlLexerSOME = 923 + TSqlLexerSORT_IN_TEMPDB = 924 + TSqlLexerSOUNDEX = 925 + TSqlLexerSOURCE = 926 + TSqlLexerSPACE_KEYWORD = 927 + TSqlLexerSPARSE = 928 + TSqlLexerSPATIAL = 929 + TSqlLexerSPATIAL_WINDOW_MAX_CELLS = 930 + TSqlLexerSPECIFICATION = 931 + TSqlLexerSPLIT = 932 + TSqlLexerSQL = 933 + TSqlLexerSQLDUMPERFLAGS = 934 + TSqlLexerSQLDUMPERPATH = 935 + TSqlLexerSQLDUMPERTIMEOUT = 936 + TSqlLexerSQL_VARIANT_PROPERTY = 937 + TSqlLexerSTANDBY = 938 + TSqlLexerSTART = 939 + TSqlLexerSTARTED = 940 + TSqlLexerSTARTUP_STATE = 941 + TSqlLexerSTART_DATE = 942 + TSqlLexerSTATE = 943 + TSqlLexerSTATIC = 944 + TSqlLexerSTATISTICS = 945 + TSqlLexerSTATISTICS_INCREMENTAL = 946 + TSqlLexerSTATISTICS_NORECOMPUTE = 947 + TSqlLexerSTATS = 948 + TSqlLexerSTATS_DATE = 949 + TSqlLexerSTATS_STREAM = 950 + TSqlLexerSTATUS = 951 + TSqlLexerSTATUSONLY = 952 + TSqlLexerSTDEV = 953 + TSqlLexerSTDEVP = 954 + TSqlLexerSTOP = 955 + TSqlLexerSTOPLIST = 956 + TSqlLexerSTOPPED = 957 + TSqlLexerSTOP_ON_ERROR = 958 + TSqlLexerSTR = 959 + TSqlLexerSTRING_AGG = 960 + TSqlLexerSTRING_ESCAPE = 961 + TSqlLexerSTUFF = 962 + TSqlLexerSUBJECT = 963 + TSqlLexerSUBSCRIBE = 964 + TSqlLexerSUBSCRIPTION = 965 + TSqlLexerSUBSTRING = 966 + TSqlLexerSUM = 967 + TSqlLexerSUPPORTED = 968 + TSqlLexerSUSER_ID = 969 + TSqlLexerSUSER_NAME = 970 + TSqlLexerSUSER_SID = 971 + TSqlLexerSUSER_SNAME = 972 + TSqlLexerSUSPEND = 973 + TSqlLexerSWITCH = 974 + TSqlLexerSYMMETRIC = 975 + TSqlLexerSYNCHRONOUS_COMMIT = 976 + TSqlLexerSYNONYM = 977 + TSqlLexerSYSTEM = 978 + TSqlLexerSYSTEM_USER = 979 + TSqlLexerTABLE = 980 + TSqlLexerTABLERESULTS = 981 + TSqlLexerTABLESAMPLE = 982 + TSqlLexerTABLOCK = 983 + TSqlLexerTABLOCKX = 984 + TSqlLexerTAKE = 985 + TSqlLexerTAPE = 986 + TSqlLexerTARGET = 987 + TSqlLexerTARGET_RECOVERY_TIME = 988 + TSqlLexerTB = 989 + TSqlLexerTCP = 990 + TSqlLexerTEXTIMAGE_ON = 991 + TSqlLexerTEXTSIZE = 992 + TSqlLexerTHEN = 993 + TSqlLexerTHROW = 994 + TSqlLexerTIES = 995 + TSqlLexerTIME = 996 + TSqlLexerTIMEOUT = 997 + TSqlLexerTIMER = 998 + TSqlLexerTINYINT = 999 + TSqlLexerTO = 1000 + TSqlLexerTOP = 1001 + TSqlLexerTORN_PAGE_DETECTION = 1002 + TSqlLexerTOSTRING = 1003 + TSqlLexerTRACE = 1004 + TSqlLexerTRACKING = 1005 + TSqlLexerTRACK_CAUSALITY = 1006 + TSqlLexerTRAN = 1007 + TSqlLexerTRANSACTION = 1008 + TSqlLexerTRANSACTION_ID = 1009 + TSqlLexerTRANSFER = 1010 + TSqlLexerTRANSFORM_NOISE_WORDS = 1011 + TSqlLexerTRANSLATE = 1012 + TSqlLexerTRIGGER = 1013 + TSqlLexerTRIM = 1014 + TSqlLexerTRIPLE_DES = 1015 + TSqlLexerTRIPLE_DES_3KEY = 1016 + TSqlLexerTRUNCATE = 1017 + TSqlLexerTRUSTWORTHY = 1018 + TSqlLexerTRY = 1019 + TSqlLexerTRY_CAST = 1020 + TSqlLexerTSEQUAL = 1021 + TSqlLexerTSQL = 1022 + TSqlLexerTWO_DIGIT_YEAR_CUTOFF = 1023 + TSqlLexerTYPE = 1024 + TSqlLexerTYPEPROPERTY = 1025 + TSqlLexerTYPE_ID = 1026 + TSqlLexerTYPE_NAME = 1027 + TSqlLexerTYPE_WARNING = 1028 + TSqlLexerUNBOUNDED = 1029 + TSqlLexerUNCHECKED = 1030 + TSqlLexerUNCOMMITTED = 1031 + TSqlLexerUNICODE = 1032 + TSqlLexerUNION = 1033 + TSqlLexerUNIQUE = 1034 + TSqlLexerUNKNOWN = 1035 + TSqlLexerUNLIMITED = 1036 + TSqlLexerUNLOCK = 1037 + TSqlLexerUNMASK = 1038 + TSqlLexerUNPIVOT = 1039 + TSqlLexerUNSAFE = 1040 + TSqlLexerUOW = 1041 + TSqlLexerUPDATE = 1042 + TSqlLexerUPDATETEXT = 1043 + TSqlLexerUPDLOCK = 1044 + TSqlLexerUPPER = 1045 + TSqlLexerURL = 1046 + TSqlLexerUSE = 1047 + TSqlLexerUSED = 1048 + TSqlLexerUSER = 1049 + TSqlLexerUSER_ID = 1050 + TSqlLexerUSER_NAME = 1051 + TSqlLexerUSING = 1052 + TSqlLexerVALIDATION = 1053 + TSqlLexerVALID_XML = 1054 + TSqlLexerVALUE = 1055 + TSqlLexerVALUES = 1056 + TSqlLexerVALUE_SQUARE_BRACKET = 1057 + TSqlLexerVAR = 1058 + TSqlLexerVARBINARY_KEYWORD = 1059 + TSqlLexerVARP = 1060 + TSqlLexerVARYING = 1061 + TSqlLexerVERBOSELOGGING = 1062 + TSqlLexerVERIFY_CLONEDB = 1063 + TSqlLexerVERSION = 1064 + TSqlLexerVIEW = 1065 + TSqlLexerVIEWS = 1066 + TSqlLexerVIEW_METADATA = 1067 + TSqlLexerVISIBILITY = 1068 + TSqlLexerWAIT = 1069 + TSqlLexerWAITFOR = 1070 + TSqlLexerWAIT_AT_LOW_PRIORITY = 1071 + TSqlLexerWELL_FORMED_XML = 1072 + TSqlLexerWHEN = 1073 + TSqlLexerWHERE = 1074 + TSqlLexerWHILE = 1075 + TSqlLexerWINDOWS = 1076 + TSqlLexerWITH = 1077 + TSqlLexerWITHIN = 1078 + TSqlLexerWITHOUT = 1079 + TSqlLexerWITHOUT_ARRAY_WRAPPER = 1080 + TSqlLexerWITNESS = 1081 + TSqlLexerWORK = 1082 + TSqlLexerWORKLOAD = 1083 + TSqlLexerWRITETEXT = 1084 + TSqlLexerXACT_ABORT = 1085 + TSqlLexerXACT_STATE = 1086 + TSqlLexerXLOCK = 1087 + TSqlLexerXML = 1088 + TSqlLexerXMLDATA = 1089 + TSqlLexerXMLNAMESPACES = 1090 + TSqlLexerXMLSCHEMA = 1091 + TSqlLexerXML_COMPRESSION = 1092 + TSqlLexerXSINIL = 1093 + TSqlLexerZONE = 1094 + TSqlLexerABS = 1095 + TSqlLexerACOS = 1096 + TSqlLexerASIN = 1097 + TSqlLexerATAN = 1098 + TSqlLexerATN2 = 1099 + TSqlLexerCEILING = 1100 + TSqlLexerCOS = 1101 + TSqlLexerCOT = 1102 + TSqlLexerDEGREES = 1103 + TSqlLexerEXP = 1104 + TSqlLexerFLOOR = 1105 + TSqlLexerLOG10 = 1106 + TSqlLexerPI = 1107 + TSqlLexerPOWER = 1108 + TSqlLexerRADIANS = 1109 + TSqlLexerRAND = 1110 + TSqlLexerROUND = 1111 + TSqlLexerSIGN = 1112 + TSqlLexerSIN = 1113 + TSqlLexerSQRT = 1114 + TSqlLexerSQUARE = 1115 + TSqlLexerTAN = 1116 + TSqlLexerCURRENT_TIMEZONE = 1117 + TSqlLexerCURRENT_TIMEZONE_ID = 1118 + TSqlLexerDATE_BUCKET = 1119 + TSqlLexerDATEDIFF_BIG = 1120 + TSqlLexerDATEFROMPARTS = 1121 + TSqlLexerDATETIME2FROMPARTS = 1122 + TSqlLexerDATETIMEFROMPARTS = 1123 + TSqlLexerDATETIMEOFFSETFROMPARTS = 1124 + TSqlLexerDATETRUNC = 1125 + TSqlLexerDAY = 1126 + TSqlLexerEOMONTH = 1127 + TSqlLexerISDATE = 1128 + TSqlLexerMONTH = 1129 + TSqlLexerSMALLDATETIMEFROMPARTS = 1130 + TSqlLexerSWITCHOFFSET = 1131 + TSqlLexerSYSDATETIME = 1132 + TSqlLexerSYSDATETIMEOFFSET = 1133 + TSqlLexerSYSUTCDATETIME = 1134 + TSqlLexerTIMEFROMPARTS = 1135 + TSqlLexerTODATETIMEOFFSET = 1136 + TSqlLexerYEAR = 1137 + TSqlLexerQUARTER = 1138 + TSqlLexerDAYOFYEAR = 1139 + TSqlLexerWEEK = 1140 + TSqlLexerHOUR = 1141 + TSqlLexerMINUTE = 1142 + TSqlLexerSECOND = 1143 + TSqlLexerMILLISECOND = 1144 + TSqlLexerMICROSECOND = 1145 + TSqlLexerNANOSECOND = 1146 + TSqlLexerTZOFFSET = 1147 + TSqlLexerISO_WEEK = 1148 + TSqlLexerWEEKDAY = 1149 + TSqlLexerYEAR_ABBR = 1150 + TSqlLexerQUARTER_ABBR = 1151 + TSqlLexerMONTH_ABBR = 1152 + TSqlLexerDAYOFYEAR_ABBR = 1153 + TSqlLexerDAY_ABBR = 1154 + TSqlLexerWEEK_ABBR = 1155 + TSqlLexerHOUR_ABBR = 1156 + TSqlLexerMINUTE_ABBR = 1157 + TSqlLexerSECOND_ABBR = 1158 + TSqlLexerMILLISECOND_ABBR = 1159 + TSqlLexerMICROSECOND_ABBR = 1160 + TSqlLexerNANOSECOND_ABBR = 1161 + TSqlLexerTZOFFSET_ABBR = 1162 + TSqlLexerISO_WEEK_ABBR = 1163 + TSqlLexerWEEKDAY_ABBR = 1164 + TSqlLexerSP_EXECUTESQL = 1165 + TSqlLexerVARCHAR = 1166 + TSqlLexerNVARCHAR = 1167 + TSqlLexerDISK_DRIVE = 1168 + TSqlLexerDOLLAR_ACTION = 1169 + TSqlLexerCURSOR_ROWS = 1170 + TSqlLexerFETCH_STATUS = 1171 + TSqlLexerIPV4_ADDR = 1172 + TSqlLexerSPACE = 1173 + TSqlLexerCOMMENT = 1174 + TSqlLexerLINE_COMMENT = 1175 + TSqlLexerDOUBLE_QUOTE_ID = 1176 + TSqlLexerDOUBLE_QUOTE_BLANK = 1177 + TSqlLexerSINGLE_QUOTE = 1178 + TSqlLexerSQUARE_BRACKET_ID = 1179 + TSqlLexerLOCAL_ID = 1180 + TSqlLexerTEMP_ID = 1181 + TSqlLexerDECIMAL = 1182 + TSqlLexerID = 1183 + TSqlLexerSTRING = 1184 + TSqlLexerBINARY = 1185 + TSqlLexerFLOAT = 1186 + TSqlLexerREAL = 1187 + TSqlLexerEQUAL = 1188 + TSqlLexerGREATER = 1189 + TSqlLexerLESS = 1190 + TSqlLexerEXCLAMATION = 1191 + TSqlLexerPLUS_ASSIGN = 1192 + TSqlLexerMINUS_ASSIGN = 1193 + TSqlLexerMULT_ASSIGN = 1194 + TSqlLexerDIV_ASSIGN = 1195 + TSqlLexerMOD_ASSIGN = 1196 + TSqlLexerAND_ASSIGN = 1197 + TSqlLexerXOR_ASSIGN = 1198 + TSqlLexerOR_ASSIGN = 1199 + TSqlLexerDOUBLE_BAR = 1200 + TSqlLexerDOT = 1201 + TSqlLexerUNDERLINE = 1202 + TSqlLexerAT = 1203 + TSqlLexerSHARP = 1204 + TSqlLexerDOLLAR = 1205 + TSqlLexerLR_BRACKET = 1206 + TSqlLexerRR_BRACKET = 1207 + TSqlLexerCOMMA = 1208 + TSqlLexerSEMI = 1209 + TSqlLexerCOLON = 1210 + TSqlLexerDOUBLE_COLON = 1211 + TSqlLexerSTAR = 1212 + TSqlLexerDIVIDE = 1213 + TSqlLexerMODULE = 1214 + TSqlLexerPLUS = 1215 + TSqlLexerMINUS = 1216 + TSqlLexerBIT_NOT = 1217 + TSqlLexerBIT_OR = 1218 + TSqlLexerBIT_AND = 1219 + TSqlLexerBIT_XOR = 1220 + TSqlLexerPLACEHOLDER = 1221 +) diff --git a/tsql/tsql_parser.go b/tsql/tsql_parser.go new file mode 100644 index 0000000..02b0b11 --- /dev/null +++ b/tsql/tsql_parser.go @@ -0,0 +1,244528 @@ +// Code generated from TSqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package tsql // TSqlParser +import ( + "fmt" + "strconv" + "sync" + + "github.com/antlr4-go/antlr/v4" +) + +// Suppress unused import errors +var _ = fmt.Printf +var _ = strconv.Itoa +var _ = sync.Once{} + +type TSqlParser struct { + *antlr.BaseParser +} + +var TSqlParserParserStaticData struct { + once sync.Once + serializedATN []int32 + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func tsqlparserParserInit() { + staticData := &TSqlParserParserStaticData + staticData.LiteralNames = []string{ + "", "'ABORT'", "'ABORT_AFTER_WAIT'", "'ABSENT'", "'ABSOLUTE'", "'ACCELERATED_DATABASE_RECOVERY'", + "'ACCENT_SENSITIVITY'", "'ACCESS'", "'ACTION'", "'ACTIVATION'", "'ACTIVE'", + "'ADD'", "'ADDRESS'", "'ADMINISTER'", "'AES'", "'AES_128'", "'AES_192'", + "'AES_256'", "'AFFINITY'", "'AFTER'", "'AGGREGATE'", "'ALGORITHM'", + "'ALL'", "'ALLOWED'", "'ALLOW_CONNECTIONS'", "'ALLOW_ENCRYPTED_VALUE_MODIFICATIONS'", + "'ALLOW_MULTIPLE_EVENT_LOSS'", "'ALLOW_PAGE_LOCKS'", "'ALLOW_ROW_LOCKS'", + "'ALLOW_SINGLE_EVENT_LOSS'", "'ALLOW_SNAPSHOT_ISOLATION'", "'ALL_CONSTRAINTS'", + "'ALL_ERRORMSGS'", "'ALL_INDEXES'", "'ALL_LEVELS'", "'ALTER'", "'ALWAYS'", + "'AND'", "'ANONYMOUS'", "'ANSI_DEFAULTS'", "'ANSI_NULLS'", "'ANSI_NULL_DEFAULT'", + "'ANSI_NULL_DFLT_OFF'", "'ANSI_NULL_DFLT_ON'", "'ANSI_PADDING'", "'ANSI_WARNINGS'", + "'ANY'", "'APPEND'", "'APPLICATION'", "'APPLICATION_LOG'", "'APPLOCK_MODE'", + "'APPLOCK_TEST'", "'APPLY'", "'APP_NAME'", "'ARITHABORT'", "'ARITHIGNORE'", + "'AS'", "'ASC'", "'ASCII'", "'ASSEMBLY'", "'ASSEMBLYPROPERTY'", "'ASYMMETRIC'", + "'ASYNCHRONOUS_COMMIT'", "'AT'", "'AUDIT'", "'AUDIT_GUID'", "'AUTHENTICATE'", + "'AUTHENTICATION'", "'AUTHORIZATION'", "'AUTO'", "'AUTOGROW_ALL_FILES'", + "'AUTOGROW_SINGLE_FILE'", "'AUTOMATED_BACKUP_PREFERENCE'", "'AUTOMATIC'", + "'AUTO_CLEANUP'", "'AUTO_CLOSE'", "'AUTO_CREATE_STATISTICS'", "'AUTO_DROP'", + "'AUTO_SHRINK'", "'AUTO_UPDATE_STATISTICS'", "'AUTO_UPDATE_STATISTICS_ASYNC'", + "'AVAILABILITY'", "'AVAILABILITY_MODE'", "'AVG'", "'\\'", "'BACKUP'", + "'BACKUP_CLONEDB'", "'BACKUP_PRIORITY'", "'BASE64'", "'BEFORE'", "'BEGIN'", + "'BEGIN_DIALOG'", "'BETWEEN'", "'BIGINT'", "'BINARY_CHECKSUM'", "'BINARY'", + "'BINDING'", "'BLOB_STORAGE'", "'BLOCK'", "'BLOCKERS'", "'BLOCKING_HIERARCHY'", + "'BLOCKSIZE'", "'BOUNDING_BOX'", "'BREAK'", "'BROKER'", "'BROKER_INSTANCE'", + "'BROWSE'", "'BUFFER'", "'BUFFERCOUNT'", "'BULK'", "'BULK_LOGGED'", + "'BY'", "'CACHE'", "'CALLED'", "'CALLER'", "'CAP_CPU_PERCENT'", "'CASCADE'", + "'CASE'", "'CAST'", "'CATALOG'", "'CATCH'", "'CELLS_PER_OBJECT'", "'CERTENCODED'", + "'CERTIFICATE'", "'CERTPRIVATEKEY'", "'CERT_ID'", "'CHANGE'", "'CHANGES'", + "'CHANGETABLE'", "'CHANGE_RETENTION'", "'CHANGE_TRACKING'", "'CHAR'", + "'CHARINDEX'", "'CHECK'", "'CHECKALLOC'", "'CHECKCATALOG'", "'CHECKCONSTRAINTS'", + "'CHECKDB'", "'CHECKFILEGROUP'", "'CHECKPOINT'", "'CHECKSUM'", "'CHECKSUM_AGG'", + "'CHECKTABLE'", "'CHECK_EXPIRATION'", "'CHECK_POLICY'", "'CLASSIFIER_FUNCTION'", + "'CLEANTABLE'", "'CLEANUP'", "'CLONEDATABASE'", "'CLOSE'", "'CLUSTER'", + "'CLUSTERED'", "'COALESCE'", "'COLLATE'", "'COLLECTION'", "'COLUMN'", + "'COLUMNPROPERTY'", "'COLUMNS'", "'COLUMNSTORE'", "'COLUMNSTORE_ARCHIVE'", + "'COLUMN_ENCRYPTION_KEY'", "'COLUMN_MASTER_KEY'", "'COL_LENGTH'", "'COL_NAME'", + "'COMMIT'", "'COMMITTED'", "'COMPATIBILITY_LEVEL'", "'COMPRESS'", "'COMPRESSION'", + "'COMPRESSION_DELAY'", "'COMPRESS_ALL_ROW_GROUPS'", "'COMPUTE'", "'CONCAT'", + "'CONCAT_NULL_YIELDS_NULL'", "'CONCAT_WS'", "'CONFIGURATION'", "'CONNECT'", + "'CONNECTION'", "'CONNECTIONPROPERTY'", "'CONSTRAINT'", "'CONTAINMENT'", + "'CONTAINS'", "'CONTAINSTABLE'", "'CONTENT'", "'CONTEXT'", "'CONTEXT_INFO'", + "'CONTINUE'", "'CONTINUE_AFTER_ERROR'", "'CONTRACT'", "'CONTRACT_NAME'", + "'CONTROL'", "'CONVERSATION'", "", "'COOKIE'", "'COPY_ONLY'", "'COUNT'", + "'COUNTER'", "'COUNT_BIG'", "'CPU'", "'CREATE'", "'CREATE_NEW'", "'CREATION_DISPOSITION'", + "'CREDENTIAL'", "'CROSS'", "'CRYPTOGRAPHIC'", "'CUME_DIST'", "'CURRENT'", + "'CURRENT_DATE'", "'CURRENT_REQUEST_ID'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", + "'CURRENT_TRANSACTION_ID'", "'CURRENT_USER'", "'CURSOR'", "'CURSOR_CLOSE_ON_COMMIT'", + "'CURSOR_DEFAULT'", "'CURSOR_STATUS'", "'CYCLE'", "'DATA'", "'DATABASE'", + "'DATABASEPROPERTYEX'", "'DATABASE_MIRRORING'", "'DATABASE_PRINCIPAL_ID'", + "'DATALENGTH'", "'DATASPACE'", "'DATA_COMPRESSION'", "'DATA_PURITY'", + "'DATA_SOURCE'", "'DATEADD'", "'DATEDIFF'", "'DATENAME'", "'DATEPART'", + "'DATE_CORRELATION_OPTIMIZATION'", "'DAYS'", "'DBCC'", "'DBREINDEX'", + "'DB_CHAINING'", "'DB_FAILOVER'", "'DB_ID'", "'DB_NAME'", "'DDL'", "'DEALLOCATE'", + "'DECLARE'", "'DECOMPRESS'", "'DECRYPTION'", "'DEFAULT'", "'DEFAULT_DATABASE'", + "", "'DEFAULT_FULLTEXT_LANGUAGE'", "'DEFAULT_LANGUAGE'", "'DEFAULT_SCHEMA'", + "'DEFINITION'", "'DELAY'", "'DELAYED_DURABILITY'", "'DELETE'", "'DELETED'", + "'DENSE_RANK'", "'DENY'", "'DEPENDENTS'", "'DES'", "'DESC'", "'DESCRIPTION'", + "'DESX'", "'DETERMINISTIC'", "'DHCP'", "'DIAGNOSTICS'", "'DIALOG'", + "'DIFFERENCE'", "'DIFFERENTIAL'", "'DIRECTORY_NAME'", "'DISABLE'", "'DISABLED'", + "'DISABLE_BROKER'", "'DISK'", "'DISTINCT'", "'DISTRIBUTED'", "'DISTRIBUTION'", + "'DOCUMENT'", "'$PARTITION'", "'DOUBLE'", "'\\\\'", "'//'", "'DROP'", + "'DROPCLEANBUFFERS'", "'DROP_EXISTING'", "'DTC_SUPPORT'", "'DUMP'", + "'DYNAMIC'", "'ELEMENTS'", "'ELSE'", "'EMERGENCY'", "'EMPTY'", "'ENABLE'", + "'ENABLED'", "'ENABLE_BROKER'", "'ENCRYPTED'", "'ENCRYPTED_VALUE'", + "'ENCRYPTION'", "'ENCRYPTION_TYPE'", "'END'", "'ENDPOINT'", "'ENDPOINT_URL'", + "'ERRLVL'", "'ERROR'", "'ERROR_BROKER_CONVERSATIONS'", "'ERROR_LINE'", + "'ERROR_MESSAGE'", "'ERROR_NUMBER'", "'ERROR_PROCEDURE'", "'ERROR_SEVERITY'", + "'ERROR_STATE'", "'ESCAPE'", "'ESTIMATEONLY'", "'EVENT'", "'EVENTDATA'", + "'EVENT_RETENTION_MODE'", "'EXCEPT'", "'EXCLUSIVE'", "'EXECUTABLE'", + "'EXECUTABLE_FILE'", "", "'EXIST'", "'EXISTS'", "'[EXIST]'", "'EXIT'", + "'EXPAND'", "'EXPIREDATE'", "'EXPIRY_DATE'", "'EXPLICIT'", "'EXTENDED_LOGICAL_CHECKS'", + "'EXTENSION'", "'EXTERNAL'", "'EXTERNAL_ACCESS'", "'FAILOVER'", "'FAILOVER_MODE'", + "'FAILURE'", "'FAILURECONDITIONLEVEL'", "'FAILURE_CONDITION_LEVEL'", + "'FAIL_OPERATION'", "'FAN_IN'", "'FAST'", "'FAST_FORWARD'", "'FETCH'", + "'FILE'", "'FILEGROUP'", "'FILEGROUPPROPERTY'", "'FILEGROUP_ID'", "'FILEGROUP_NAME'", + "'FILEGROWTH'", "'FILENAME'", "'FILEPATH'", "'FILEPROPERTY'", "'FILEPROPERTYEX'", + "'FILESTREAM'", "'FILESTREAM_ON'", "'FILE_ID'", "'FILE_IDEX'", "'FILE_NAME'", + "'FILE_SNAPSHOT'", "'FILLFACTOR'", "'FILTER'", "'FIRST'", "'FIRST_VALUE'", + "'FMTONLY'", "'FOLLOWING'", "'FOR'", "'FORCE'", "'FORCED'", "'FORCEPLAN'", + "'FORCESCAN'", "'FORCESEEK'", "'FORCE_FAILOVER_ALLOW_DATA_LOSS'", "'FORCE_SERVICE_ALLOW_DATA_LOSS'", + "'FOREIGN'", "'FORMAT'", "'FORMATMESSAGE'", "'FORWARD_ONLY'", "'FREE'", + "'FREETEXT'", "'FREETEXTTABLE'", "'FROM'", "'FULL'", "'FULLSCAN'", "'FULLTEXT'", + "'FULLTEXTCATALOGPROPERTY'", "'FULLTEXTSERVICEPROPERTY'", "'FUNCTION'", + "'GB'", "'GENERATED'", "'GEOGRAPHY'", "'GEOGRAPHY_AUTO_GRID'", "'GEOGRAPHY_GRID'", + "'GEOMETRY'", "'GEOMETRY_AUTO_GRID'", "'GEOMETRY_GRID'", "'GET'", "'GRIDS'", + "'GETANCESTOR'", "'GETANSINULL'", "'GETDATE'", "'GETDESCENDANT'", "'GETLEVEL'", + "'GETREPARENTEDVALUE'", "'GETROOT'", "'GETUTCDATE'", "'GET_FILESTREAM_TRANSACTION_CONTEXT'", + "'GLOBAL'", "'GO'", "'GOTO'", "'GOVERNOR'", "'GRANT'", "'GREATEST'", + "'GROUP'", "'GROUPING'", "'GROUPING_ID'", "'GROUP_MAX_REQUESTS'", "'HADR'", + "'HASH'", "'HASHED'", "'HAS_DBACCESS'", "'HAS_PERMS_BY_NAME'", "'HAVING'", + "'HEALTHCHECKTIMEOUT'", "'HEALTH_CHECK_TIMEOUT'", "'HEAP'", "'HIDDEN'", + "'HIERARCHYID'", "'HIGH'", "'HOLDLOCK'", "'HONOR_BROKER_PRIORITY'", + "'HOST_ID'", "'HOST_NAME'", "'HOURS'", "'IDENTITY'", "'IDENTITYCOL'", + "'IDENTITY_INSERT'", "'IDENTITY_VALUE'", "'IDENT_CURRENT'", "'IDENT_INCR'", + "'IDENT_SEED'", "'IF'", "'IGNORE_CONSTRAINTS'", "'IGNORE_DUP_KEY'", + "'IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX'", "'IGNORE_REPLICATED_TABLE_CACHE'", + "'IGNORE_TRIGGERS'", "'IIF'", "'IMMEDIATE'", "'IMPERSONATE'", "'IMPLICIT_TRANSACTIONS'", + "'IMPORTANCE'", "'IN'", "'INCLUDE'", "'INCLUDE_NULL_VALUES'", "'INCREMENT'", + "'INCREMENTAL'", "'INDEX'", "'INDEXKEY_PROPERTY'", "'INDEXPROPERTY'", + "'INDEX_COL'", "'INFINITE'", "'INIT'", "'INITIATOR'", "'INNER'", "'INPUT'", + "'INSENSITIVE'", "'INSERT'", "'INSERTED'", "'INSTEAD'", "'INT'", "'INTERSECT'", + "'INTO'", "'IO'", "'IP'", "'IS'", "'ISDESCENDANTOF'", "'ISJSON'", "'ISNULL'", + "'ISNUMERIC'", "'ISOLATION'", "'IS_MEMBER'", "'IS_ROLEMEMBER'", "'IS_SRVROLEMEMBER'", + "'JOB'", "'JOIN'", "'JSON'", "'JSON_ARRAY'", "'JSON_MODIFY'", "'JSON_OBJECT'", + "'JSON_PATH_EXISTS'", "'JSON_QUERY'", "'JSON_VALUE'", "'KB'", "'KEEP'", + "'KEEPDEFAULTS'", "'KEEPFIXED'", "'KEEPIDENTITY'", "'KERBEROS'", "'KEY'", + "'KEYS'", "'KEYSET'", "'KEY_PATH'", "'KEY_SOURCE'", "'KEY_STORE_PROVIDER_NAME'", + "'KILL'", "'LAG'", "'LANGUAGE'", "'LAST'", "'LAST_VALUE'", "'LEAD'", + "'LEAST'", "'LEFT'", "'LEN'", "'LEVEL'", "'LEVEL_1'", "'LEVEL_2'", "'LEVEL_3'", + "'LEVEL_4'", "'LIBRARY'", "'LIFETIME'", "'LIKE'", "'LINENO'", "'LINKED'", + "'LINUX'", "'LIST'", "'LISTENER'", "'LISTENER_IP'", "'LISTENER_PORT'", + "'LISTENER_URL'", "'LOAD'", "'LOB_COMPACTION'", "'LOCAL'", "'LOCAL_SERVICE_NAME'", + "'LOCATION'", "'LOCK'", "'LOCK_ESCALATION'", "'LOG'", "'LOGIN'", "'LOGINPROPERTY'", + "'LOOP'", "'LOW'", "'LOWER'", "'LTRIM'", "'MANUAL'", "'MARK'", "'MASK'", + "'MASKED'", "'MASTER'", "'MATCHED'", "'MATERIALIZED'", "'MAX'", "'MAXDOP'", + "'MAXRECURSION'", "'MAXSIZE'", "'MAXTRANSFER'", "'MAXVALUE'", "'MAX_CPU_PERCENT'", + "'MAX_DISPATCH_LATENCY'", "'MAX_DOP'", "'MAX_DURATION'", "'MAX_EVENT_SIZE'", + "'MAX_FILES'", "'MAX_IOPS_PER_VOLUME'", "'MAX_MEMORY'", "'MAX_MEMORY_PERCENT'", + "'MAX_OUTSTANDING_IO_PER_VOLUME'", "'MAX_PROCESSES'", "'MAX_QUEUE_READERS'", + "'MAX_ROLLOVER_FILES'", "'MAX_SIZE'", "'MB'", "'MEDIADESCRIPTION'", + "'MEDIANAME'", "'MEDIUM'", "'MEMBER'", "'MEMORY_OPTIMIZED_DATA'", "'MEMORY_PARTITION_MODE'", + "'MERGE'", "'MESSAGE'", "'MESSAGE_FORWARDING'", "'MESSAGE_FORWARD_SIZE'", + "'MIN'", "'MINUTES'", "'MINVALUE'", "'MIN_ACTIVE_ROWVERSION'", "'MIN_CPU_PERCENT'", + "'MIN_IOPS_PER_VOLUME'", "'MIN_MEMORY_PERCENT'", "'MIRROR'", "'MIRROR_ADDRESS'", + "'MIXED_PAGE_ALLOCATION'", "'MODE'", "'MODIFY'", "'[MODIFY]'", "'MOVE'", + "'MULTI_USER'", "'MUST_CHANGE'", "'NAME'", "'NATIONAL'", "'NCHAR'", + "'NEGOTIATE'", "'NESTED_TRIGGERS'", "'NEWID'", "'NEWNAME'", "'NEWSEQUENTIALID'", + "'NEW_ACCOUNT'", "'NEW_BROKER'", "'NEW_PASSWORD'", "'NEXT'", "'NO'", + "'NOCHECK'", "'NOCOUNT'", "'NODES'", "'NOEXEC'", "'NOEXPAND'", "'NOFORMAT'", + "'NOHOLDLOCK'", "'NOINDEX'", "'NOINIT'", "'NOLOCK'", "'NONCLUSTERED'", + "'NONE'", "'NON_TRANSACTED_ACCESS'", "'NORECOMPUTE'", "'NORECOVERY'", + "'NOREWIND'", "'NOSKIP'", "'NOT'", "'NOTIFICATION'", "'NOTIFICATIONS'", + "'NOUNLOAD'", "'NOWAIT'", "'NO_CHECKSUM'", "'NO_COMPRESSION'", "'NO_EVENT_LOSS'", + "'NO_INFOMSGS'", "'NO_QUERYSTORE'", "'NO_STATISTICS'", "'NO_TRUNCATE'", + "'NO_WAIT'", "'NTILE'", "'NTLM'", "'NULLIF'", "'NULL'", "", "'NUMANODE'", + "'NUMBER'", "'NUMERIC_ROUNDABORT'", "'OBJECT'", "'OBJECTPROPERTY'", + "'OBJECTPROPERTYEX'", "'OBJECT_DEFINITION'", "'OBJECT_ID'", "'OBJECT_NAME'", + "'OBJECT_SCHEMA_NAME'", "'OF'", "'OFF'", "'OFFLINE'", "'OFFSET'", "'OFFSETS'", + "'OLD_ACCOUNT'", "'OLD_PASSWORD'", "'ON'", "'ONLINE'", "'ONLY'", "'ON_FAILURE'", + "'OPEN'", "'OPENDATASOURCE'", "'OPENJSON'", "'OPENQUERY'", "'OPENROWSET'", + "'OPENXML'", "'OPEN_EXISTING'", "'OPERATIONS'", "'OPTIMISTIC'", "'OPTIMIZE'", + "'OPTIMIZE_FOR_SEQUENTIAL_KEY'", "'OPTION'", "'OR'", "'ORDER'", "'ORIGINAL_DB_NAME'", + "'ORIGINAL_LOGIN'", "'OUT'", "'OUTER'", "'OUTPUT'", "'OVER'", "'OVERRIDE'", + "'OWNER'", "'OWNERSHIP'", "'PAD_INDEX'", "'PAGE'", "'PAGECOUNT'", "'PAGE_VERIFY'", + "'PAGLOCK'", "'PARAMETERIZATION'", "'PARAM_NODE'", "", "'PARSENAME'", + "'PARSEONLY'", "'PARTIAL'", "'PARTITION'", "'PARTITIONS'", "'PARTNER'", + "'PASSWORD'", "'PATH'", "'PATINDEX'", "'PAUSE'", "'PDW_SHOWSPACEUSED'", + "'PERCENT'", "'PERCENTILE_CONT'", "'PERCENTILE_DISC'", "'PERCENT_RANK'", + "'PERMISSIONS'", "'PERMISSION_SET'", "'PERSISTED'", "'PERSIST_SAMPLE_PERCENT'", + "'PER_CPU'", "'PER_DB'", "'PER_NODE'", "'PHYSICAL_ONLY'", "'PIVOT'", + "'PLAN'", "'PLATFORM'", "'POISON_MESSAGE_HANDLING'", "'POLICY'", "'POOL'", + "'PORT'", "'PRECEDING'", "'PRECISION'", "'PREDICATE'", "'PRIMARY'", + "'PRIMARY_ROLE'", "'PRINT'", "'PRIOR'", "'PRIORITY'", "'PRIORITY_LEVEL'", + "'PRIVATE'", "'PRIVATE_KEY'", "'PRIVILEGES'", "'PROC'", "'PROCCACHE'", + "'PROCEDURE'", "'PROCEDURE_NAME'", "'PROCESS'", "'PROFILE'", "'PROPERTY'", + "'PROVIDER'", "'PROVIDER_KEY_NAME'", "'PUBLIC'", "'PWDCOMPARE'", "'PWDENCRYPT'", + "'PYTHON'", "'QUERY'", "'[QUERY]'", "'QUEUE'", "'QUEUE_DELAY'", "'QUOTED_IDENTIFIER'", + "'QUOTENAME'", "'R'", "'RAISERROR'", "'RANDOMIZED'", "'RANGE'", "'RANK'", + "'RAW'", "'RC2'", "'RC4'", "'RC4_128'", "'READ'", "'READCOMMITTED'", + "'READCOMMITTEDLOCK'", "'READONLY'", "'READPAST'", "'READTEXT'", "'READUNCOMMITTED'", + "'READWRITE'", "'READ_COMMITTED_SNAPSHOT'", "'READ_ONLY'", "'READ_ONLY_ROUTING_LIST'", + "'READ_WRITE'", "'READ_WRITE_FILEGROUPS'", "'REBUILD'", "'RECEIVE'", + "'RECOMPILE'", "'RECONFIGURE'", "'RECOVERY'", "'RECURSIVE_TRIGGERS'", + "'REFERENCES'", "'REGENERATE'", "'RELATED_CONVERSATION'", "'RELATED_CONVERSATION_GROUP'", + "'RELATIVE'", "'REMOTE'", "'REMOTE_PROC_TRANSACTIONS'", "'REMOTE_SERVICE_NAME'", + "'REMOVE'", "'REORGANIZE'", "'REPAIR_ALLOW_DATA_LOSS'", "'REPAIR_FAST'", + "'REPAIR_REBUILD'", "'REPEATABLE'", "'REPEATABLEREAD'", "'REPLACE'", + "'REPLICA'", "'REPLICATE'", "'REPLICATION'", "'REQUEST_MAX_CPU_TIME_SEC'", + "'REQUEST_MAX_MEMORY_GRANT_PERCENT'", "'REQUEST_MEMORY_GRANT_TIMEOUT_SEC'", + "'REQUIRED'", "'REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT'", "'RESAMPLE'", + "'RESERVE_DISK_SPACE'", "'RESET'", "'RESOURCE'", "'RESOURCES'", "'RESOURCE_MANAGER_LOCATION'", + "'RESTART'", "'RESTORE'", "'RESTRICT'", "'RESTRICTED_USER'", "'RESUMABLE'", + "'RESUME'", "'RETAINDAYS'", "'RETENTION'", "'RETURN'", "'RETURNS'", + "'REVERSE'", "'REVERT'", "'REVOKE'", "'REWIND'", "'RIGHT'", "'ROBUST'", + "'ROLE'", "'ROLLBACK'", "'ROOT'", "'ROUND_ROBIN'", "'ROUTE'", "'ROW'", + "'ROWCOUNT'", "'ROWCOUNT_BIG'", "'ROWGUID'", "'ROWGUIDCOL'", "'ROWLOCK'", + "'ROWS'", "'ROW_NUMBER'", "'RSA_1024'", "'RSA_2048'", "'RSA_3072'", + "'RSA_4096'", "'RSA_512'", "'RTRIM'", "'RULE'", "'SAFE'", "'SAFETY'", + "'SAMPLE'", "'SAVE'", "'SCHEDULER'", "'SCHEMA'", "'SCHEMABINDING'", + "'SCHEMA_ID'", "'SCHEMA_NAME'", "'SCHEME'", "'SCOPED'", "'SCOPE_IDENTITY'", + "'SCRIPT'", "'SCROLL'", "'SCROLL_LOCKS'", "'SEARCH'", "'SECONDARY'", + "'SECONDARY_ONLY'", "'SECONDARY_ROLE'", "'SECONDS'", "'SECRET'", "'SECURABLES'", + "'SECURITY'", "'SECURITYAUDIT'", "'SECURITY_LOG'", "'SEEDING_MODE'", + "'SELECT'", "'SELF'", "'SEMANTICKEYPHRASETABLE'", "'SEMANTICSIMILARITYDETAILSTABLE'", + "'SEMANTICSIMILARITYTABLE'", "'SEMI_SENSITIVE'", "'SEND'", "'SENT'", + "'SEQUENCE'", "'SEQUENCE_NUMBER'", "'SERIALIZABLE'", "'SERVER'", "'SERVERPROPERTY'", + "'SERVICE'", "'SERVICEBROKER'", "'SERVICE_BROKER'", "'SERVICE_NAME'", + "'SESSION'", "'SESSIONPROPERTY'", "'SESSION_CONTEXT'", "'SESSION_TIMEOUT'", + "'SESSION_USER'", "'SET'", "'SETERROR'", "'SETS'", "'SETTINGS'", "'SETUSER'", + "'SHARE'", "'SHARED'", "'SHOWCONTIG'", "'SHOWPLAN'", "'SHOWPLAN_ALL'", + "'SHOWPLAN_TEXT'", "'SHOWPLAN_XML'", "'SHRINKLOG'", "'SHUTDOWN'", "'SID'", + "'SIGNATURE'", "'SIMPLE'", "'SINGLE_USER'", "'SIZE'", "'SKIP'", "'SMALLINT'", + "'SNAPSHOT'", "'SOFTNUMA'", "'SOME'", "'SORT_IN_TEMPDB'", "'SOUNDEX'", + "'SOURCE'", "'SPACE'", "'SPARSE'", "'SPATIAL'", "'SPATIAL_WINDOW_MAX_CELLS'", + "'SPECIFICATION'", "'SPLIT'", "'SQL'", "'SQLDUMPERFLAGS'", "'SQLDUMPERPATH'", + "'SQLDUMPERTIMEOUT'", "'SQL_VARIANT_PROPERTY'", "'STANDBY'", "'START'", + "'STARTED'", "'STARTUP_STATE'", "'START_DATE'", "'STATE'", "'STATIC'", + "'STATISTICS'", "'STATISTICS_INCREMENTAL'", "'STATISTICS_NORECOMPUTE'", + "'STATS'", "'STATS_DATE'", "'STATS_STREAM'", "'STATUS'", "'STATUSONLY'", + "'STDEV'", "'STDEVP'", "'STOP'", "'STOPLIST'", "'STOPPED'", "'STOP_ON_ERROR'", + "'STR'", "'STRING_AGG'", "'STRING_ESCAPE'", "'STUFF'", "'SUBJECT'", + "'SUBSCRIBE'", "'SUBSCRIPTION'", "'SUBSTRING'", "'SUM'", "'SUPPORTED'", + "'SUSER_ID'", "'SUSER_NAME'", "'SUSER_SID'", "'SUSER_SNAME'", "'SUSPEND'", + "'SWITCH'", "'SYMMETRIC'", "'SYNCHRONOUS_COMMIT'", "'SYNONYM'", "'SYSTEM'", + "'SYSTEM_USER'", "'TABLE'", "'TABLERESULTS'", "'TABLESAMPLE'", "'TABLOCK'", + "'TABLOCKX'", "'TAKE'", "'TAPE'", "'TARGET'", "'TARGET_RECOVERY_TIME'", + "'TB'", "'TCP'", "'TEXTIMAGE_ON'", "'TEXTSIZE'", "'THEN'", "'THROW'", + "'TIES'", "'TIME'", "'TIMEOUT'", "'TIMER'", "'TINYINT'", "'TO'", "'TOP'", + "'TORN_PAGE_DETECTION'", "'TOSTRING'", "'TRACE'", "'TRACKING'", "'TRACK_CAUSALITY'", + "'TRAN'", "'TRANSACTION'", "'TRANSACTION_ID'", "'TRANSFER'", "'TRANSFORM_NOISE_WORDS'", + "'TRANSLATE'", "'TRIGGER'", "'TRIM'", "'TRIPLE_DES'", "'TRIPLE_DES_3KEY'", + "'TRUNCATE'", "'TRUSTWORTHY'", "'TRY'", "'TRY_CAST'", "'TSEQUAL'", "'TSQL'", + "'TWO_DIGIT_YEAR_CUTOFF'", "'TYPE'", "'TYPEPROPERTY'", "'TYPE_ID'", + "'TYPE_NAME'", "'TYPE_WARNING'", "'UNBOUNDED'", "'UNCHECKED'", "'UNCOMMITTED'", + "'UNICODE'", "'UNION'", "'UNIQUE'", "'UNKNOWN'", "'UNLIMITED'", "'UNLOCK'", + "'UNMASK'", "'UNPIVOT'", "'UNSAFE'", "'UOW'", "'UPDATE'", "'UPDATETEXT'", + "'UPDLOCK'", "'UPPER'", "'URL'", "'USE'", "'USED'", "'USER'", "'USER_ID'", + "'USER_NAME'", "'USING'", "'VALIDATION'", "'VALID_XML'", "'VALUE'", + "'VALUES'", "'[VALUE]'", "'VAR'", "'VARBINARY'", "'VARP'", "'VARYING'", + "'VERBOSELOGGING'", "'VERIFY_CLONEDB'", "'VERSION'", "'VIEW'", "'VIEWS'", + "'VIEW_METADATA'", "'VISIBILITY'", "'WAIT'", "'WAITFOR'", "'WAIT_AT_LOW_PRIORITY'", + "'WELL_FORMED_XML'", "'WHEN'", "'WHERE'", "'WHILE'", "'WINDOWS'", "'WITH'", + "'WITHIN'", "'WITHOUT'", "'WITHOUT_ARRAY_WRAPPER'", "'WITNESS'", "'WORK'", + "'WORKLOAD'", "'WRITETEXT'", "'XACT_ABORT'", "'XACT_STATE'", "'XLOCK'", + "'XML'", "'XMLDATA'", "'XMLNAMESPACES'", "'XMLSCHEMA'", "'XML_COMPRESSION'", + "'XSINIL'", "'ZONE'", "'ABS'", "'ACOS'", "'ASIN'", "'ATAN'", "'ATN2'", + "'CEILING'", "'COS'", "'COT'", "'DEGREES'", "'EXP'", "'FLOOR'", "'LOG10'", + "'PI'", "'POWER'", "'RADIANS'", "'RAND'", "'ROUND'", "'SIGN'", "'SIN'", + "'SQRT'", "'SQUARE'", "'TAN'", "'CURRENT_TIMEZONE'", "'CURRENT_TIMEZONE_ID'", + "'DATE_BUCKET'", "'DATEDIFF_BIG'", "'DATEFROMPARTS'", "'DATETIME2FROMPARTS'", + "'DATETIMEFROMPARTS'", "'DATETIMEOFFSETFROMPARTS'", "'DATETRUNC'", "'DAY'", + "'EOMONTH'", "'ISDATE'", "'MONTH'", "'SMALLDATETIMEFROMPARTS'", "'SWITCHOFFSET'", + "'SYSDATETIME'", "'SYSDATETIMEOFFSET'", "'SYSUTCDATETIME'", "'TIMEFROMPARTS'", + "'TODATETIMEOFFSET'", "'YEAR'", "'QUARTER'", "'DAYOFYEAR'", "'WEEK'", + "'HOUR'", "'MINUTE'", "'SECOND'", "'MILLISECOND'", "'MICROSECOND'", + "'NANOSECOND'", "'TZOFFSET'", "'ISO_WEEK'", "'WEEKDAY'", "", "", "", + "", "", "", "'hh'", "", "", "'ms'", "'mcs'", "'ns'", "'tz'", "", "'dw'", + "'SP_EXECUTESQL'", "'VARCHAR'", "'NVARCHAR'", "", "'$ACTION'", "'@@CURSOR_ROWS'", + "'@@FETCH_STATUS'", "", "", "", "", "", "'\"\"'", "'''", "", "", "", + "", "", "", "", "", "", "'='", "'>'", "'<'", "'!'", "'+='", "'-='", + "'*='", "'/='", "'%='", "'&='", "'^='", "'|='", "'||'", "'.'", "'_'", + "'@'", "'#'", "'$'", "'('", "')'", "','", "';'", "':'", "'::'", "'*'", + "'/'", "'%'", "'+'", "'-'", "'~'", "'|'", "'&'", "'^'", "'?'", + } + staticData.SymbolicNames = []string{ + "", "ABORT", "ABORT_AFTER_WAIT", "ABSENT", "ABSOLUTE", "ACCELERATED_DATABASE_RECOVERY", + "ACCENT_SENSITIVITY", "ACCESS", "ACTION", "ACTIVATION", "ACTIVE", "ADD", + "ADDRESS", "ADMINISTER", "AES", "AES_128", "AES_192", "AES_256", "AFFINITY", + "AFTER", "AGGREGATE", "ALGORITHM", "ALL", "ALLOWED", "ALLOW_CONNECTIONS", + "ALLOW_ENCRYPTED_VALUE_MODIFICATIONS", "ALLOW_MULTIPLE_EVENT_LOSS", + "ALLOW_PAGE_LOCKS", "ALLOW_ROW_LOCKS", "ALLOW_SINGLE_EVENT_LOSS", "ALLOW_SNAPSHOT_ISOLATION", + "ALL_CONSTRAINTS", "ALL_ERRORMSGS", "ALL_INDEXES", "ALL_LEVELS", "ALTER", + "ALWAYS", "AND", "ANONYMOUS", "ANSI_DEFAULTS", "ANSI_NULLS", "ANSI_NULL_DEFAULT", + "ANSI_NULL_DFLT_OFF", "ANSI_NULL_DFLT_ON", "ANSI_PADDING", "ANSI_WARNINGS", + "ANY", "APPEND", "APPLICATION", "APPLICATION_LOG", "APPLOCK_MODE", "APPLOCK_TEST", + "APPLY", "APP_NAME", "ARITHABORT", "ARITHIGNORE", "AS", "ASC", "ASCII", + "ASSEMBLY", "ASSEMBLYPROPERTY", "ASYMMETRIC", "ASYNCHRONOUS_COMMIT", + "AT_KEYWORD", "AUDIT", "AUDIT_GUID", "AUTHENTICATE", "AUTHENTICATION", + "AUTHORIZATION", "AUTO", "AUTOGROW_ALL_FILES", "AUTOGROW_SINGLE_FILE", + "AUTOMATED_BACKUP_PREFERENCE", "AUTOMATIC", "AUTO_CLEANUP", "AUTO_CLOSE", + "AUTO_CREATE_STATISTICS", "AUTO_DROP", "AUTO_SHRINK", "AUTO_UPDATE_STATISTICS", + "AUTO_UPDATE_STATISTICS_ASYNC", "AVAILABILITY", "AVAILABILITY_MODE", + "AVG", "BACKSLASH", "BACKUP", "BACKUP_CLONEDB", "BACKUP_PRIORITY", "BASE64", + "BEFORE", "BEGIN", "BEGIN_DIALOG", "BETWEEN", "BIGINT", "BINARY_CHECKSUM", + "BINARY_KEYWORD", "BINDING", "BLOB_STORAGE", "BLOCK", "BLOCKERS", "BLOCKING_HIERARCHY", + "BLOCKSIZE", "BOUNDING_BOX", "BREAK", "BROKER", "BROKER_INSTANCE", "BROWSE", + "BUFFER", "BUFFERCOUNT", "BULK", "BULK_LOGGED", "BY", "CACHE", "CALLED", + "CALLER", "CAP_CPU_PERCENT", "CASCADE", "CASE", "CAST", "CATALOG", "CATCH", + "CELLS_PER_OBJECT", "CERTENCODED", "CERTIFICATE", "CERTPRIVATEKEY", + "CERT_ID", "CHANGE", "CHANGES", "CHANGETABLE", "CHANGE_RETENTION", "CHANGE_TRACKING", + "CHAR", "CHARINDEX", "CHECK", "CHECKALLOC", "CHECKCATALOG", "CHECKCONSTRAINTS", + "CHECKDB", "CHECKFILEGROUP", "CHECKPOINT", "CHECKSUM", "CHECKSUM_AGG", + "CHECKTABLE", "CHECK_EXPIRATION", "CHECK_POLICY", "CLASSIFIER_FUNCTION", + "CLEANTABLE", "CLEANUP", "CLONEDATABASE", "CLOSE", "CLUSTER", "CLUSTERED", + "COALESCE", "COLLATE", "COLLECTION", "COLUMN", "COLUMNPROPERTY", "COLUMNS", + "COLUMNSTORE", "COLUMNSTORE_ARCHIVE", "COLUMN_ENCRYPTION_KEY", "COLUMN_MASTER_KEY", + "COL_LENGTH", "COL_NAME", "COMMIT", "COMMITTED", "COMPATIBILITY_LEVEL", + "COMPRESS", "COMPRESSION", "COMPRESSION_DELAY", "COMPRESS_ALL_ROW_GROUPS", + "COMPUTE", "CONCAT", "CONCAT_NULL_YIELDS_NULL", "CONCAT_WS", "CONFIGURATION", + "CONNECT", "CONNECTION", "CONNECTIONPROPERTY", "CONSTRAINT", "CONTAINMENT", + "CONTAINS", "CONTAINSTABLE", "CONTENT", "CONTEXT", "CONTEXT_INFO", "CONTINUE", + "CONTINUE_AFTER_ERROR", "CONTRACT", "CONTRACT_NAME", "CONTROL", "CONVERSATION", + "CONVERT", "COOKIE", "COPY_ONLY", "COUNT", "COUNTER", "COUNT_BIG", "CPU", + "CREATE", "CREATE_NEW", "CREATION_DISPOSITION", "CREDENTIAL", "CROSS", + "CRYPTOGRAPHIC", "CUME_DIST", "CURRENT", "CURRENT_DATE", "CURRENT_REQUEST_ID", + "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_TRANSACTION_ID", "CURRENT_USER", + "CURSOR", "CURSOR_CLOSE_ON_COMMIT", "CURSOR_DEFAULT", "CURSOR_STATUS", + "CYCLE", "DATA", "DATABASE", "DATABASEPROPERTYEX", "DATABASE_MIRRORING", + "DATABASE_PRINCIPAL_ID", "DATALENGTH", "DATASPACE", "DATA_COMPRESSION", + "DATA_PURITY", "DATA_SOURCE", "DATEADD", "DATEDIFF", "DATENAME", "DATEPART", + "DATE_CORRELATION_OPTIMIZATION", "DAYS", "DBCC", "DBREINDEX", "DB_CHAINING", + "DB_FAILOVER", "DB_ID", "DB_NAME", "DDL", "DEALLOCATE", "DECLARE", "DECOMPRESS", + "DECRYPTION", "DEFAULT", "DEFAULT_DATABASE", "DEFAULT_DOUBLE_QUOTE", + "DEFAULT_FULLTEXT_LANGUAGE", "DEFAULT_LANGUAGE", "DEFAULT_SCHEMA", "DEFINITION", + "DELAY", "DELAYED_DURABILITY", "DELETE", "DELETED", "DENSE_RANK", "DENY", + "DEPENDENTS", "DES", "DESC", "DESCRIPTION", "DESX", "DETERMINISTIC", + "DHCP", "DIAGNOSTICS", "DIALOG", "DIFFERENCE", "DIFFERENTIAL", "DIRECTORY_NAME", + "DISABLE", "DISABLED", "DISABLE_BROKER", "DISK", "DISTINCT", "DISTRIBUTED", + "DISTRIBUTION", "DOCUMENT", "DOLLAR_PARTITION", "DOUBLE", "DOUBLE_BACK_SLASH", + "DOUBLE_FORWARD_SLASH", "DROP", "DROPCLEANBUFFERS", "DROP_EXISTING", + "DTC_SUPPORT", "DUMP", "DYNAMIC", "ELEMENTS", "ELSE", "EMERGENCY", "EMPTY", + "ENABLE", "ENABLED", "ENABLE_BROKER", "ENCRYPTED", "ENCRYPTED_VALUE", + "ENCRYPTION", "ENCRYPTION_TYPE", "END", "ENDPOINT", "ENDPOINT_URL", + "ERRLVL", "ERROR", "ERROR_BROKER_CONVERSATIONS", "ERROR_LINE", "ERROR_MESSAGE", + "ERROR_NUMBER", "ERROR_PROCEDURE", "ERROR_SEVERITY", "ERROR_STATE", + "ESCAPE", "ESTIMATEONLY", "EVENT", "EVENTDATA", "EVENT_RETENTION_MODE", + "EXCEPT", "EXCLUSIVE", "EXECUTABLE", "EXECUTABLE_FILE", "EXECUTE", "EXIST", + "EXISTS", "EXIST_SQUARE_BRACKET", "EXIT", "EXPAND", "EXPIREDATE", "EXPIRY_DATE", + "EXPLICIT", "EXTENDED_LOGICAL_CHECKS", "EXTENSION", "EXTERNAL", "EXTERNAL_ACCESS", + "FAILOVER", "FAILOVER_MODE", "FAILURE", "FAILURECONDITIONLEVEL", "FAILURE_CONDITION_LEVEL", + "FAIL_OPERATION", "FAN_IN", "FAST", "FAST_FORWARD", "FETCH", "FILE", + "FILEGROUP", "FILEGROUPPROPERTY", "FILEGROUP_ID", "FILEGROUP_NAME", + "FILEGROWTH", "FILENAME", "FILEPATH", "FILEPROPERTY", "FILEPROPERTYEX", + "FILESTREAM", "FILESTREAM_ON", "FILE_ID", "FILE_IDEX", "FILE_NAME", + "FILE_SNAPSHOT", "FILLFACTOR", "FILTER", "FIRST", "FIRST_VALUE", "FMTONLY", + "FOLLOWING", "FOR", "FORCE", "FORCED", "FORCEPLAN", "FORCESCAN", "FORCESEEK", + "FORCE_FAILOVER_ALLOW_DATA_LOSS", "FORCE_SERVICE_ALLOW_DATA_LOSS", "FOREIGN", + "FORMAT", "FORMATMESSAGE", "FORWARD_ONLY", "FREE", "FREETEXT", "FREETEXTTABLE", + "FROM", "FULL", "FULLSCAN", "FULLTEXT", "FULLTEXTCATALOGPROPERTY", "FULLTEXTSERVICEPROPERTY", + "FUNCTION", "GB", "GENERATED", "GEOGRAPHY", "GEOGRAPHY_AUTO_GRID", "GEOGRAPHY_GRID", + "GEOMETRY", "GEOMETRY_AUTO_GRID", "GEOMETRY_GRID", "GET", "GRIDS", "GETANCESTOR", + "GETANSINULL", "GETDATE", "GETDESCENDANT", "GETLEVEL", "GETREPARENTEDVALUE", + "GETROOT", "GETUTCDATE", "GET_FILESTREAM_TRANSACTION_CONTEXT", "GLOBAL", + "GO", "GOTO", "GOVERNOR", "GRANT", "GREATEST", "GROUP", "GROUPING", + "GROUPING_ID", "GROUP_MAX_REQUESTS", "HADR", "HASH", "HASHED", "HAS_DBACCESS", + "HAS_PERMS_BY_NAME", "HAVING", "HEALTHCHECKTIMEOUT", "HEALTH_CHECK_TIMEOUT", + "HEAP", "HIDDEN_KEYWORD", "HIERARCHYID", "HIGH", "HOLDLOCK", "HONOR_BROKER_PRIORITY", + "HOST_ID", "HOST_NAME", "HOURS", "IDENTITY", "IDENTITYCOL", "IDENTITY_INSERT", + "IDENTITY_VALUE", "IDENT_CURRENT", "IDENT_INCR", "IDENT_SEED", "IF", + "IGNORE_CONSTRAINTS", "IGNORE_DUP_KEY", "IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX", + "IGNORE_REPLICATED_TABLE_CACHE", "IGNORE_TRIGGERS", "IIF", "IMMEDIATE", + "IMPERSONATE", "IMPLICIT_TRANSACTIONS", "IMPORTANCE", "IN", "INCLUDE", + "INCLUDE_NULL_VALUES", "INCREMENT", "INCREMENTAL", "INDEX", "INDEXKEY_PROPERTY", + "INDEXPROPERTY", "INDEX_COL", "INFINITE", "INIT", "INITIATOR", "INNER", + "INPUT", "INSENSITIVE", "INSERT", "INSERTED", "INSTEAD", "INT", "INTERSECT", + "INTO", "IO", "IP", "IS", "ISDESCENDANTOF", "ISJSON", "ISNULL", "ISNUMERIC", + "ISOLATION", "IS_MEMBER", "IS_ROLEMEMBER", "IS_SRVROLEMEMBER", "JOB", + "JOIN", "JSON", "JSON_ARRAY", "JSON_MODIFY", "JSON_OBJECT", "JSON_PATH_EXISTS", + "JSON_QUERY", "JSON_VALUE", "KB", "KEEP", "KEEPDEFAULTS", "KEEPFIXED", + "KEEPIDENTITY", "KERBEROS", "KEY", "KEYS", "KEYSET", "KEY_PATH", "KEY_SOURCE", + "KEY_STORE_PROVIDER_NAME", "KILL", "LAG", "LANGUAGE", "LAST", "LAST_VALUE", + "LEAD", "LEAST", "LEFT", "LEN", "LEVEL", "LEVEL_1", "LEVEL_2", "LEVEL_3", + "LEVEL_4", "LIBRARY", "LIFETIME", "LIKE", "LINENO", "LINKED", "LINUX", + "LIST", "LISTENER", "LISTENER_IP", "LISTENER_PORT", "LISTENER_URL", + "LOAD", "LOB_COMPACTION", "LOCAL", "LOCAL_SERVICE_NAME", "LOCATION", + "LOCK", "LOCK_ESCALATION", "LOG", "LOGIN", "LOGINPROPERTY", "LOOP", + "LOW", "LOWER", "LTRIM", "MANUAL", "MARK", "MASK", "MASKED", "MASTER", + "MATCHED", "MATERIALIZED", "MAX", "MAXDOP", "MAXRECURSION", "MAXSIZE", + "MAXTRANSFER", "MAXVALUE", "MAX_CPU_PERCENT", "MAX_DISPATCH_LATENCY", + "MAX_DOP", "MAX_DURATION", "MAX_EVENT_SIZE", "MAX_FILES", "MAX_IOPS_PER_VOLUME", + "MAX_MEMORY", "MAX_MEMORY_PERCENT", "MAX_OUTSTANDING_IO_PER_VOLUME", + "MAX_PROCESSES", "MAX_QUEUE_READERS", "MAX_ROLLOVER_FILES", "MAX_SIZE", + "MB", "MEDIADESCRIPTION", "MEDIANAME", "MEDIUM", "MEMBER", "MEMORY_OPTIMIZED_DATA", + "MEMORY_PARTITION_MODE", "MERGE", "MESSAGE", "MESSAGE_FORWARDING", "MESSAGE_FORWARD_SIZE", + "MIN", "MINUTES", "MINVALUE", "MIN_ACTIVE_ROWVERSION", "MIN_CPU_PERCENT", + "MIN_IOPS_PER_VOLUME", "MIN_MEMORY_PERCENT", "MIRROR", "MIRROR_ADDRESS", + "MIXED_PAGE_ALLOCATION", "MODE", "MODIFY", "MODIFY_SQUARE_BRACKET", + "MOVE", "MULTI_USER", "MUST_CHANGE", "NAME", "NATIONAL", "NCHAR", "NEGOTIATE", + "NESTED_TRIGGERS", "NEWID", "NEWNAME", "NEWSEQUENTIALID", "NEW_ACCOUNT", + "NEW_BROKER", "NEW_PASSWORD", "NEXT", "NO", "NOCHECK", "NOCOUNT", "NODES", + "NOEXEC", "NOEXPAND", "NOFORMAT", "NOHOLDLOCK", "NOINDEX", "NOINIT", + "NOLOCK", "NONCLUSTERED", "NONE", "NON_TRANSACTED_ACCESS", "NORECOMPUTE", + "NORECOVERY", "NOREWIND", "NOSKIP", "NOT", "NOTIFICATION", "NOTIFICATIONS", + "NOUNLOAD", "NOWAIT", "NO_CHECKSUM", "NO_COMPRESSION", "NO_EVENT_LOSS", + "NO_INFOMSGS", "NO_QUERYSTORE", "NO_STATISTICS", "NO_TRUNCATE", "NO_WAIT", + "NTILE", "NTLM", "NULLIF", "NULL_", "NULL_DOUBLE_QUOTE", "NUMANODE", + "NUMBER", "NUMERIC_ROUNDABORT", "OBJECT", "OBJECTPROPERTY", "OBJECTPROPERTYEX", + "OBJECT_DEFINITION", "OBJECT_ID", "OBJECT_NAME", "OBJECT_SCHEMA_NAME", + "OF", "OFF", "OFFLINE", "OFFSET", "OFFSETS", "OLD_ACCOUNT", "OLD_PASSWORD", + "ON", "ONLINE", "ONLY", "ON_FAILURE", "OPEN", "OPENDATASOURCE", "OPENJSON", + "OPENQUERY", "OPENROWSET", "OPENXML", "OPEN_EXISTING", "OPERATIONS", + "OPTIMISTIC", "OPTIMIZE", "OPTIMIZE_FOR_SEQUENTIAL_KEY", "OPTION", "OR", + "ORDER", "ORIGINAL_DB_NAME", "ORIGINAL_LOGIN", "OUT", "OUTER", "OUTPUT", + "OVER", "OVERRIDE", "OWNER", "OWNERSHIP", "PAD_INDEX", "PAGE", "PAGECOUNT", + "PAGE_VERIFY", "PAGLOCK", "PARAMETERIZATION", "PARAM_NODE", "PARSE", + "PARSENAME", "PARSEONLY", "PARTIAL", "PARTITION", "PARTITIONS", "PARTNER", + "PASSWORD", "PATH", "PATINDEX", "PAUSE", "PDW_SHOWSPACEUSED", "PERCENT", + "PERCENTILE_CONT", "PERCENTILE_DISC", "PERCENT_RANK", "PERMISSIONS", + "PERMISSION_SET", "PERSISTED", "PERSIST_SAMPLE_PERCENT", "PER_CPU", + "PER_DB", "PER_NODE", "PHYSICAL_ONLY", "PIVOT", "PLAN", "PLATFORM", + "POISON_MESSAGE_HANDLING", "POLICY", "POOL", "PORT", "PRECEDING", "PRECISION", + "PREDICATE", "PRIMARY", "PRIMARY_ROLE", "PRINT", "PRIOR", "PRIORITY", + "PRIORITY_LEVEL", "PRIVATE", "PRIVATE_KEY", "PRIVILEGES", "PROC", "PROCCACHE", + "PROCEDURE", "PROCEDURE_NAME", "PROCESS", "PROFILE", "PROPERTY", "PROVIDER", + "PROVIDER_KEY_NAME", "PUBLIC", "PWDCOMPARE", "PWDENCRYPT", "PYTHON", + "QUERY", "QUERY_SQUARE_BRACKET", "QUEUE", "QUEUE_DELAY", "QUOTED_IDENTIFIER", + "QUOTENAME", "R", "RAISERROR", "RANDOMIZED", "RANGE", "RANK", "RAW", + "RC2", "RC4", "RC4_128", "READ", "READCOMMITTED", "READCOMMITTEDLOCK", + "READONLY", "READPAST", "READTEXT", "READUNCOMMITTED", "READWRITE", + "READ_COMMITTED_SNAPSHOT", "READ_ONLY", "READ_ONLY_ROUTING_LIST", "READ_WRITE", + "READ_WRITE_FILEGROUPS", "REBUILD", "RECEIVE", "RECOMPILE", "RECONFIGURE", + "RECOVERY", "RECURSIVE_TRIGGERS", "REFERENCES", "REGENERATE", "RELATED_CONVERSATION", + "RELATED_CONVERSATION_GROUP", "RELATIVE", "REMOTE", "REMOTE_PROC_TRANSACTIONS", + "REMOTE_SERVICE_NAME", "REMOVE", "REORGANIZE", "REPAIR_ALLOW_DATA_LOSS", + "REPAIR_FAST", "REPAIR_REBUILD", "REPEATABLE", "REPEATABLEREAD", "REPLACE", + "REPLICA", "REPLICATE", "REPLICATION", "REQUEST_MAX_CPU_TIME_SEC", "REQUEST_MAX_MEMORY_GRANT_PERCENT", + "REQUEST_MEMORY_GRANT_TIMEOUT_SEC", "REQUIRED", "REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT", + "RESAMPLE", "RESERVE_DISK_SPACE", "RESET", "RESOURCE", "RESOURCES", + "RESOURCE_MANAGER_LOCATION", "RESTART", "RESTORE", "RESTRICT", "RESTRICTED_USER", + "RESUMABLE", "RESUME", "RETAINDAYS", "RETENTION", "RETURN", "RETURNS", + "REVERSE", "REVERT", "REVOKE", "REWIND", "RIGHT", "ROBUST", "ROLE", + "ROLLBACK", "ROOT", "ROUND_ROBIN", "ROUTE", "ROW", "ROWCOUNT", "ROWCOUNT_BIG", + "ROWGUID", "ROWGUIDCOL", "ROWLOCK", "ROWS", "ROW_NUMBER", "RSA_1024", + "RSA_2048", "RSA_3072", "RSA_4096", "RSA_512", "RTRIM", "RULE", "SAFE", + "SAFETY", "SAMPLE", "SAVE", "SCHEDULER", "SCHEMA", "SCHEMABINDING", + "SCHEMA_ID", "SCHEMA_NAME", "SCHEME", "SCOPED", "SCOPE_IDENTITY", "SCRIPT", + "SCROLL", "SCROLL_LOCKS", "SEARCH", "SECONDARY", "SECONDARY_ONLY", "SECONDARY_ROLE", + "SECONDS", "SECRET", "SECURABLES", "SECURITY", "SECURITYAUDIT", "SECURITY_LOG", + "SEEDING_MODE", "SELECT", "SELF", "SEMANTICKEYPHRASETABLE", "SEMANTICSIMILARITYDETAILSTABLE", + "SEMANTICSIMILARITYTABLE", "SEMI_SENSITIVE", "SEND", "SENT", "SEQUENCE", + "SEQUENCE_NUMBER", "SERIALIZABLE", "SERVER", "SERVERPROPERTY", "SERVICE", + "SERVICEBROKER", "SERVICE_BROKER", "SERVICE_NAME", "SESSION", "SESSIONPROPERTY", + "SESSION_CONTEXT", "SESSION_TIMEOUT", "SESSION_USER", "SET", "SETERROR", + "SETS", "SETTINGS", "SETUSER", "SHARE", "SHARED", "SHOWCONTIG", "SHOWPLAN", + "SHOWPLAN_ALL", "SHOWPLAN_TEXT", "SHOWPLAN_XML", "SHRINKLOG", "SHUTDOWN", + "SID", "SIGNATURE", "SIMPLE", "SINGLE_USER", "SIZE", "SKIP_KEYWORD", + "SMALLINT", "SNAPSHOT", "SOFTNUMA", "SOME", "SORT_IN_TEMPDB", "SOUNDEX", + "SOURCE", "SPACE_KEYWORD", "SPARSE", "SPATIAL", "SPATIAL_WINDOW_MAX_CELLS", + "SPECIFICATION", "SPLIT", "SQL", "SQLDUMPERFLAGS", "SQLDUMPERPATH", + "SQLDUMPERTIMEOUT", "SQL_VARIANT_PROPERTY", "STANDBY", "START", "STARTED", + "STARTUP_STATE", "START_DATE", "STATE", "STATIC", "STATISTICS", "STATISTICS_INCREMENTAL", + "STATISTICS_NORECOMPUTE", "STATS", "STATS_DATE", "STATS_STREAM", "STATUS", + "STATUSONLY", "STDEV", "STDEVP", "STOP", "STOPLIST", "STOPPED", "STOP_ON_ERROR", + "STR", "STRING_AGG", "STRING_ESCAPE", "STUFF", "SUBJECT", "SUBSCRIBE", + "SUBSCRIPTION", "SUBSTRING", "SUM", "SUPPORTED", "SUSER_ID", "SUSER_NAME", + "SUSER_SID", "SUSER_SNAME", "SUSPEND", "SWITCH", "SYMMETRIC", "SYNCHRONOUS_COMMIT", + "SYNONYM", "SYSTEM", "SYSTEM_USER", "TABLE", "TABLERESULTS", "TABLESAMPLE", + "TABLOCK", "TABLOCKX", "TAKE", "TAPE", "TARGET", "TARGET_RECOVERY_TIME", + "TB", "TCP", "TEXTIMAGE_ON", "TEXTSIZE", "THEN", "THROW", "TIES", "TIME", + "TIMEOUT", "TIMER", "TINYINT", "TO", "TOP", "TORN_PAGE_DETECTION", "TOSTRING", + "TRACE", "TRACKING", "TRACK_CAUSALITY", "TRAN", "TRANSACTION", "TRANSACTION_ID", + "TRANSFER", "TRANSFORM_NOISE_WORDS", "TRANSLATE", "TRIGGER", "TRIM", + "TRIPLE_DES", "TRIPLE_DES_3KEY", "TRUNCATE", "TRUSTWORTHY", "TRY", "TRY_CAST", + "TSEQUAL", "TSQL", "TWO_DIGIT_YEAR_CUTOFF", "TYPE", "TYPEPROPERTY", + "TYPE_ID", "TYPE_NAME", "TYPE_WARNING", "UNBOUNDED", "UNCHECKED", "UNCOMMITTED", + "UNICODE", "UNION", "UNIQUE", "UNKNOWN", "UNLIMITED", "UNLOCK", "UNMASK", + "UNPIVOT", "UNSAFE", "UOW", "UPDATE", "UPDATETEXT", "UPDLOCK", "UPPER", + "URL", "USE", "USED", "USER", "USER_ID", "USER_NAME", "USING", "VALIDATION", + "VALID_XML", "VALUE", "VALUES", "VALUE_SQUARE_BRACKET", "VAR", "VARBINARY_KEYWORD", + "VARP", "VARYING", "VERBOSELOGGING", "VERIFY_CLONEDB", "VERSION", "VIEW", + "VIEWS", "VIEW_METADATA", "VISIBILITY", "WAIT", "WAITFOR", "WAIT_AT_LOW_PRIORITY", + "WELL_FORMED_XML", "WHEN", "WHERE", "WHILE", "WINDOWS", "WITH", "WITHIN", + "WITHOUT", "WITHOUT_ARRAY_WRAPPER", "WITNESS", "WORK", "WORKLOAD", "WRITETEXT", + "XACT_ABORT", "XACT_STATE", "XLOCK", "XML", "XMLDATA", "XMLNAMESPACES", + "XMLSCHEMA", "XML_COMPRESSION", "XSINIL", "ZONE", "ABS", "ACOS", "ASIN", + "ATAN", "ATN2", "CEILING", "COS", "COT", "DEGREES", "EXP", "FLOOR", + "LOG10", "PI", "POWER", "RADIANS", "RAND", "ROUND", "SIGN", "SIN", "SQRT", + "SQUARE", "TAN", "CURRENT_TIMEZONE", "CURRENT_TIMEZONE_ID", "DATE_BUCKET", + "DATEDIFF_BIG", "DATEFROMPARTS", "DATETIME2FROMPARTS", "DATETIMEFROMPARTS", + "DATETIMEOFFSETFROMPARTS", "DATETRUNC", "DAY", "EOMONTH", "ISDATE", + "MONTH", "SMALLDATETIMEFROMPARTS", "SWITCHOFFSET", "SYSDATETIME", "SYSDATETIMEOFFSET", + "SYSUTCDATETIME", "TIMEFROMPARTS", "TODATETIMEOFFSET", "YEAR", "QUARTER", + "DAYOFYEAR", "WEEK", "HOUR", "MINUTE", "SECOND", "MILLISECOND", "MICROSECOND", + "NANOSECOND", "TZOFFSET", "ISO_WEEK", "WEEKDAY", "YEAR_ABBR", "QUARTER_ABBR", + "MONTH_ABBR", "DAYOFYEAR_ABBR", "DAY_ABBR", "WEEK_ABBR", "HOUR_ABBR", + "MINUTE_ABBR", "SECOND_ABBR", "MILLISECOND_ABBR", "MICROSECOND_ABBR", + "NANOSECOND_ABBR", "TZOFFSET_ABBR", "ISO_WEEK_ABBR", "WEEKDAY_ABBR", + "SP_EXECUTESQL", "VARCHAR", "NVARCHAR", "DISK_DRIVE", "DOLLAR_ACTION", + "CURSOR_ROWS", "FETCH_STATUS", "IPV4_ADDR", "SPACE", "COMMENT", "LINE_COMMENT", + "DOUBLE_QUOTE_ID", "DOUBLE_QUOTE_BLANK", "SINGLE_QUOTE", "SQUARE_BRACKET_ID", + "LOCAL_ID", "TEMP_ID", "DECIMAL", "ID", "STRING", "BINARY", "FLOAT", + "REAL", "EQUAL", "GREATER", "LESS", "EXCLAMATION", "PLUS_ASSIGN", "MINUS_ASSIGN", + "MULT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", + "OR_ASSIGN", "DOUBLE_BAR", "DOT", "UNDERLINE", "AT", "SHARP", "DOLLAR", + "LR_BRACKET", "RR_BRACKET", "COMMA", "SEMI", "COLON", "DOUBLE_COLON", + "STAR", "DIVIDE", "MODULE", "PLUS", "MINUS", "BIT_NOT", "BIT_OR", "BIT_AND", + "BIT_XOR", "PLACEHOLDER", + } + staticData.RuleNames = []string{ + "tsql_file", "batch_without_go", "batch_level_statement", "sql_clauses", + "dml_clause", "ddl_clause", "backup_statement", "cfl_statement", "block_statement", + "break_statement", "continue_statement", "goto_statement", "return_statement", + "if_statement", "throw_statement", "throw_error_number", "throw_message", + "throw_state", "try_catch_statement", "waitfor_statement", "while_statement", + "print_statement", "raiseerror_statement", "empty_statement", "another_statement", + "alter_application_role", "alter_xml_schema_collection", "create_application_role", + "drop_aggregate", "drop_application_role", "alter_assembly", "alter_assembly_start", + "alter_assembly_clause", "alter_assembly_from_clause", "alter_assembly_from_clause_start", + "alter_assembly_drop_clause", "alter_assembly_drop_multiple_files", + "alter_assembly_drop", "alter_assembly_add_clause", "alter_asssembly_add_clause_start", + "alter_assembly_client_file_clause", "alter_assembly_file_name", "alter_assembly_file_bits", + "alter_assembly_as", "alter_assembly_with_clause", "alter_assembly_with", + "client_assembly_specifier", "assembly_option", "network_file_share", + "network_computer", "network_file_start", "file_path", "file_directory_path_separator", + "local_file", "local_drive", "multiple_local_files", "multiple_local_file_start", + "create_assembly", "drop_assembly", "alter_asymmetric_key", "alter_asymmetric_key_start", + "asymmetric_key_option", "asymmetric_key_option_start", "asymmetric_key_password_change_option", + "create_asymmetric_key", "drop_asymmetric_key", "alter_authorization", + "authorization_grantee", "entity_to", "colon_colon", "alter_authorization_start", + "alter_authorization_for_sql_database", "alter_authorization_for_azure_dw", + "alter_authorization_for_parallel_dw", "class_type", "class_type_for_sql_database", + "class_type_for_azure_dw", "class_type_for_parallel_dw", "class_type_for_grant", + "drop_availability_group", "alter_availability_group", "alter_availability_group_start", + "alter_availability_group_options", "ip_v4_failover", "ip_v6_failover", + "create_or_alter_broker_priority", "drop_broker_priority", "alter_certificate", + "alter_column_encryption_key", "create_column_encryption_key", "drop_certificate", + "drop_column_encryption_key", "drop_column_master_key", "drop_contract", + "drop_credential", "drop_cryptograhic_provider", "drop_database", "drop_database_audit_specification", + "drop_database_encryption_key", "drop_database_scoped_credential", "drop_default", + "drop_endpoint", "drop_external_data_source", "drop_external_file_format", + "drop_external_library", "drop_external_resource_pool", "drop_external_table", + "drop_event_notifications", "drop_event_session", "drop_fulltext_catalog", + "drop_fulltext_index", "drop_fulltext_stoplist", "drop_login", "drop_master_key", + "drop_message_type", "drop_partition_function", "drop_partition_scheme", + "drop_queue", "drop_remote_service_binding", "drop_resource_pool", "drop_db_role", + "drop_route", "drop_rule", "drop_schema", "drop_search_property_list", + "drop_security_policy", "drop_sequence", "drop_server_audit", "drop_server_audit_specification", + "drop_server_role", "drop_service", "drop_signature", "drop_statistics_name_azure_dw_and_pdw", + "drop_symmetric_key", "drop_synonym", "drop_user", "drop_workload_group", + "drop_xml_schema_collection", "disable_trigger", "enable_trigger", "lock_table", + "truncate_table", "create_column_master_key", "alter_credential", "create_credential", + "alter_cryptographic_provider", "create_cryptographic_provider", "create_endpoint", + "endpoint_encryption_alogorithm_clause", "endpoint_authentication_clause", + "endpoint_listener_clause", "create_event_notification", "create_or_alter_event_session", + "event_session_predicate_expression", "event_session_predicate_factor", + "event_session_predicate_leaf", "alter_external_data_source", "alter_external_library", + "create_external_library", "alter_external_resource_pool", "create_external_resource_pool", + "alter_fulltext_catalog", "create_fulltext_catalog", "alter_fulltext_stoplist", + "create_fulltext_stoplist", "alter_login_sql_server", "create_login_sql_server", + "alter_login_azure_sql", "create_login_azure_sql", "alter_login_azure_sql_dw_and_pdw", + "create_login_pdw", "alter_master_key_sql_server", "create_master_key_sql_server", + "alter_master_key_azure_sql", "create_master_key_azure_sql", "alter_message_type", + "alter_partition_function", "alter_partition_scheme", "alter_remote_service_binding", + "create_remote_service_binding", "create_resource_pool", "alter_resource_governor", + "alter_database_audit_specification", "audit_action_spec_group", "audit_action_specification", + "action_specification", "audit_class_name", "audit_securable", "alter_db_role", + "create_database_audit_specification", "create_db_role", "create_route", + "create_rule", "alter_schema_sql", "create_schema", "create_schema_azure_sql_dw_and_pdw", + "alter_schema_azure_sql_dw_and_pdw", "create_search_property_list", + "create_security_policy", "alter_sequence", "create_sequence", "alter_server_audit", + "create_server_audit", "alter_server_audit_specification", "create_server_audit_specification", + "alter_server_configuration", "alter_server_role", "create_server_role", + "alter_server_role_pdw", "alter_service", "opt_arg_clause", "create_service", + "alter_service_master_key", "alter_symmetric_key", "create_synonym", + "alter_user", "create_user", "create_user_azure_sql_dw", "alter_user_azure_sql", + "alter_workload_group", "create_workload_group", "create_xml_schema_collection", + "create_partition_function", "create_partition_scheme", "create_queue", + "queue_settings", "alter_queue", "queue_action", "queue_rebuild_options", + "create_contract", "conversation_statement", "message_statement", "merge_statement", + "when_matches", "merge_matched", "merge_not_matched", "delete_statement", + "delete_statement_from", "insert_statement", "insert_statement_value", + "receive_statement", "select_statement_standalone", "select_statement", + "time", "update_statement", "output_clause", "output_dml_list_elem", + "create_database", "create_index", "create_spatial_index", "spatial_tessellation_scheme", + "spatial_index_options", "spatial_index_option", "signed_decimal", "spatial_grid_level", + "spatial_grid_density", "create_index_options", "relational_index_option", + "alter_index", "resumable_index_options", "resumable_index_option", + "reorganize_partition", "reorganize_options", "reorganize_option", "set_index_options", + "set_index_option", "rebuild_partition", "rebuild_index_options", "rebuild_index_option", + "single_partition_rebuild_index_options", "single_partition_rebuild_index_option", + "on_partitions", "create_columnstore_index", "create_columnstore_index_options", + "columnstore_index_option", "create_nonclustered_columnstore_index", + "create_xml_index", "xml_index_options", "xml_index_option", "create_or_alter_procedure", + "as_external_name", "create_or_alter_trigger", "create_or_alter_dml_trigger", + "dml_trigger_option", "dml_trigger_operation", "create_or_alter_ddl_trigger", + "ddl_trigger_operation", "create_or_alter_function", "func_body_returns_select", + "func_body_returns_table", "func_body_returns_scalar", "procedure_param_default_value", + "procedure_param", "procedure_option", "function_option", "create_statistics", + "update_statistics", "update_statistics_options", "update_statistics_option", + "create_table", "table_indices", "table_options", "table_option", "create_table_index_options", + "create_table_index_option", "create_view", "view_attribute", "alter_table", + "switch_partition", "low_priority_lock_wait", "alter_database", "add_or_modify_files", + "filespec", "add_or_modify_filegroups", "filegroup_updatability_option", + "database_optionspec", "auto_option", "change_tracking_option", "change_tracking_option_list", + "containment_option", "cursor_option", "alter_endpoint", "database_mirroring_option", + "mirroring_set_option", "mirroring_partner", "mirroring_witness", "witness_partner_equal", + "partner_option", "witness_option", "witness_server", "partner_server", + "mirroring_host_port_seperator", "partner_server_tcp_prefix", "port_number", + "host", "date_correlation_optimization_option", "db_encryption_option", + "db_state_option", "db_update_option", "db_user_access_option", "delayed_durability_option", + "external_access_option", "hadr_options", "mixed_page_allocation_option", + "parameterization_option", "recovery_option", "service_broker_option", + "snapshot_option", "sql_option", "target_recovery_time_option", "termination", + "drop_index", "drop_relational_or_xml_or_spatial_index", "drop_backward_compatible_index", + "drop_procedure", "drop_trigger", "drop_dml_trigger", "drop_ddl_trigger", + "drop_function", "drop_statistics", "drop_table", "drop_view", "create_type", + "drop_type", "rowset_function_limited", "openquery", "opendatasource", + "declare_statement", "xml_declaration", "cursor_statement", "backup_database", + "backup_log", "backup_certificate", "backup_master_key", "backup_service_master_key", + "kill_statement", "kill_process", "kill_query_notification", "kill_stats_job", + "execute_statement", "execute_body_batch", "execute_body", "execute_statement_arg", + "execute_statement_arg_named", "execute_statement_arg_unnamed", "execute_parameter", + "execute_var_string", "security_statement", "principal_id", "create_certificate", + "existing_keys", "private_key_options", "generate_new_keys", "date_options", + "open_key", "close_key", "create_key", "key_options", "algorithm", "encryption_mechanism", + "decryption_mechanism", "grant_permission", "set_statement", "transaction_statement", + "go_statement", "use_statement", "setuser_statement", "reconfigure_statement", + "shutdown_statement", "checkpoint_statement", "dbcc_checkalloc_option", + "dbcc_checkalloc", "dbcc_checkcatalog", "dbcc_checkconstraints_option", + "dbcc_checkconstraints", "dbcc_checkdb_table_option", "dbcc_checkdb", + "dbcc_checkfilegroup_option", "dbcc_checkfilegroup", "dbcc_checktable", + "dbcc_cleantable", "dbcc_clonedatabase_option", "dbcc_clonedatabase", + "dbcc_pdw_showspaceused", "dbcc_proccache", "dbcc_showcontig_option", + "dbcc_showcontig", "dbcc_shrinklog", "dbcc_dbreindex", "dbcc_dll_free", + "dbcc_dropcleanbuffers", "dbcc_clause", "execute_clause", "declare_local", + "table_type_definition", "table_type_indices", "xml_type_definition", + "xml_schema_collection", "column_def_table_constraints", "column_def_table_constraint", + "column_definition", "column_definition_element", "column_modifier", + "materialized_column_definition", "column_constraint", "column_index", + "on_partition_or_filegroup", "table_constraint", "connection_node", + "primary_key_options", "foreign_key_options", "check_constraint", "on_delete", + "on_update", "alter_table_index_options", "alter_table_index_option", + "declare_cursor", "declare_set_cursor_common", "declare_set_cursor_common_partial", + "fetch_cursor", "set_special", "special_list", "constant_LOCAL_ID", + "expression", "parameter", "time_zone", "primitive_expression", "case_expression", + "unary_operator_expression", "bracket_expression", "subquery", "with_expression", + "common_table_expression", "update_elem", "update_elem_merge", "search_condition", + "predicate", "query_expression", "sql_union", "query_specification", + "group_by_clause", "having_clause", "from_table_sources", "top_clause", + "top_percent", "top_count", "order_by_clause", "select_order_by_clause", + "for_clause", "xml_common_directives", "order_by_expression", "grouping_sets_item", + "group_by_item", "option_clause", "option", "optimize_for_arg", "select_list", + "udt_method_arguments", "asterisk", "udt_elem", "expression_elem", "select_list_elem", + "table_sources", "table_source", "table_source_item", "open_xml", "open_json", + "json_declaration", "json_column_declaration", "schema_declaration", + "column_declaration", "change_table", "change_table_changes", "change_table_version", + "join_part", "join_on", "cross_join", "apply_", "pivot", "unpivot", + "pivot_clause", "unpivot_clause", "full_column_name_list", "rowset_function", + "bulk_option", "derived_table", "function_call", "partition_function", + "freetext_function", "freetext_predicate", "json_key_value", "json_null_clause", + "built_in_functions", "xml_data_type_methods", "dateparts_9", "dateparts_12", + "dateparts_15", "dateparts_datetrunc", "value_method", "value_call", + "query_method", "query_call", "exist_method", "exist_call", "modify_method", + "modify_call", "hierarchyid_call", "hierarchyid_static_method", "nodes_method", + "switch_section", "switch_search_condition_section", "as_column_alias", + "as_table_alias", "table_alias", "with_table_hints", "deprecated_table_hint", + "sybase_legacy_hints", "sybase_legacy_hint", "table_hint", "index_value", + "column_alias_list", "column_alias", "table_value_constructor", "expression_list_", + "ranking_windowed_function", "aggregate_windowed_function", "analytic_windowed_function", + "all_distinct_expression", "over_clause", "row_or_range_clause", "window_frame_extent", + "window_frame_bound", "window_frame_preceding", "window_frame_following", + "create_database_option", "database_filestream_option", "database_file_spec", + "file_group", "file_spec", "entity_name", "entity_name_for_azure_dw", + "entity_name_for_parallel_dw", "full_table_name", "dotID", "doubleDotID", + "table_name", "simple_name", "func_proc_name_schema", "func_proc_name_database_schema", + "func_proc_name_server_database_schema", "ddl_object", "full_column_name", + "column_name_list_with_order", "column_name_with_order", "insert_column_name_list", + "insert_column_id", "column_name_list", "cursor_name", "on_off", "clustered", + "null_notnull", "scalar_function_name", "begin_conversation_timer", + "begin_conversation_dialog", "contract_name", "service_name", "end_conversation", + "waitfor_conversation", "get_conversation", "queue_id", "send_conversation", + "data_type", "constant", "primitive_constant", "keyword", "id_", "simple_id", + "id_or_string", "comparison_operator", "assignment_operator", "file_size", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 1, 1221, 14618, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, + 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, + 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, + 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, + 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, + 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, + 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, + 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, + 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, + 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, + 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, + 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, + 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, + 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, + 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, + 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, + 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, + 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, + 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, + 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, + 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, + 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, + 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, + 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, + 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, + 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, + 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, + 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, + 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, + 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, + 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, + 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, + 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, + 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, + 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, + 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, + 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, + 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, + 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, + 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, + 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, + 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, + 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, + 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, + 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, + 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, + 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, + 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, + 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, + 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, + 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, + 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, + 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, + 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, + 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, + 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, + 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, + 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, + 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, + 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, + 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, + 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, + 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, + 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, + 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, + 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2, + 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, 7, + 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2, + 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, + 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, + 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, + 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2, + 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7, + 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2, + 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7, + 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, 2, + 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, 360, 7, + 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, 2, + 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, 7, + 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, 2, + 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, 7, + 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, 2, + 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, 7, + 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, 2, + 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, 396, 7, + 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, 400, 2, + 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, 405, 7, + 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, 409, 2, + 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, 414, 7, + 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, 418, 2, + 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, 423, 7, + 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, 427, 2, + 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, 432, 7, + 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, 436, 2, + 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, 441, 7, + 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, 445, 2, + 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, 450, 7, + 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, 454, 2, + 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, 459, 7, + 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, 463, 2, + 464, 7, 464, 2, 465, 7, 465, 2, 466, 7, 466, 2, 467, 7, 467, 2, 468, 7, + 468, 2, 469, 7, 469, 2, 470, 7, 470, 2, 471, 7, 471, 2, 472, 7, 472, 2, + 473, 7, 473, 2, 474, 7, 474, 2, 475, 7, 475, 2, 476, 7, 476, 2, 477, 7, + 477, 2, 478, 7, 478, 2, 479, 7, 479, 2, 480, 7, 480, 2, 481, 7, 481, 2, + 482, 7, 482, 2, 483, 7, 483, 2, 484, 7, 484, 2, 485, 7, 485, 2, 486, 7, + 486, 2, 487, 7, 487, 2, 488, 7, 488, 2, 489, 7, 489, 2, 490, 7, 490, 2, + 491, 7, 491, 2, 492, 7, 492, 2, 493, 7, 493, 2, 494, 7, 494, 2, 495, 7, + 495, 2, 496, 7, 496, 2, 497, 7, 497, 2, 498, 7, 498, 2, 499, 7, 499, 2, + 500, 7, 500, 2, 501, 7, 501, 2, 502, 7, 502, 2, 503, 7, 503, 2, 504, 7, + 504, 2, 505, 7, 505, 2, 506, 7, 506, 2, 507, 7, 507, 2, 508, 7, 508, 2, + 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 2, 513, 7, + 513, 2, 514, 7, 514, 2, 515, 7, 515, 2, 516, 7, 516, 2, 517, 7, 517, 2, + 518, 7, 518, 2, 519, 7, 519, 2, 520, 7, 520, 2, 521, 7, 521, 2, 522, 7, + 522, 2, 523, 7, 523, 2, 524, 7, 524, 2, 525, 7, 525, 2, 526, 7, 526, 2, + 527, 7, 527, 2, 528, 7, 528, 2, 529, 7, 529, 2, 530, 7, 530, 2, 531, 7, + 531, 2, 532, 7, 532, 2, 533, 7, 533, 2, 534, 7, 534, 2, 535, 7, 535, 2, + 536, 7, 536, 2, 537, 7, 537, 2, 538, 7, 538, 2, 539, 7, 539, 2, 540, 7, + 540, 2, 541, 7, 541, 2, 542, 7, 542, 2, 543, 7, 543, 2, 544, 7, 544, 2, + 545, 7, 545, 2, 546, 7, 546, 2, 547, 7, 547, 2, 548, 7, 548, 2, 549, 7, + 549, 2, 550, 7, 550, 2, 551, 7, 551, 2, 552, 7, 552, 2, 553, 7, 553, 2, + 554, 7, 554, 2, 555, 7, 555, 2, 556, 7, 556, 2, 557, 7, 557, 2, 558, 7, + 558, 2, 559, 7, 559, 2, 560, 7, 560, 2, 561, 7, 561, 2, 562, 7, 562, 2, + 563, 7, 563, 2, 564, 7, 564, 2, 565, 7, 565, 2, 566, 7, 566, 2, 567, 7, + 567, 2, 568, 7, 568, 2, 569, 7, 569, 2, 570, 7, 570, 2, 571, 7, 571, 2, + 572, 7, 572, 2, 573, 7, 573, 2, 574, 7, 574, 2, 575, 7, 575, 2, 576, 7, + 576, 2, 577, 7, 577, 2, 578, 7, 578, 2, 579, 7, 579, 2, 580, 7, 580, 2, + 581, 7, 581, 2, 582, 7, 582, 2, 583, 7, 583, 2, 584, 7, 584, 2, 585, 7, + 585, 2, 586, 7, 586, 2, 587, 7, 587, 2, 588, 7, 588, 2, 589, 7, 589, 2, + 590, 7, 590, 2, 591, 7, 591, 2, 592, 7, 592, 2, 593, 7, 593, 2, 594, 7, + 594, 2, 595, 7, 595, 2, 596, 7, 596, 2, 597, 7, 597, 2, 598, 7, 598, 2, + 599, 7, 599, 2, 600, 7, 600, 2, 601, 7, 601, 2, 602, 7, 602, 2, 603, 7, + 603, 2, 604, 7, 604, 2, 605, 7, 605, 2, 606, 7, 606, 2, 607, 7, 607, 2, + 608, 7, 608, 2, 609, 7, 609, 2, 610, 7, 610, 2, 611, 7, 611, 2, 612, 7, + 612, 2, 613, 7, 613, 2, 614, 7, 614, 2, 615, 7, 615, 2, 616, 7, 616, 2, + 617, 7, 617, 2, 618, 7, 618, 2, 619, 7, 619, 2, 620, 7, 620, 1, 0, 5, 0, + 1244, 8, 0, 10, 0, 12, 0, 1247, 9, 0, 1, 0, 1, 0, 1, 0, 1, 0, 3, 0, 1253, + 8, 0, 5, 0, 1255, 8, 0, 10, 0, 12, 0, 1258, 9, 0, 1, 0, 3, 0, 1261, 8, + 0, 1, 0, 1, 0, 3, 0, 1265, 8, 0, 1, 1, 4, 1, 1268, 8, 1, 11, 1, 12, 1, + 1269, 1, 1, 1, 1, 1, 1, 5, 1, 1275, 8, 1, 10, 1, 12, 1, 1278, 9, 1, 3, + 1, 1280, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 1286, 8, 2, 1, 3, 1, 3, 3, + 3, 1290, 8, 3, 1, 3, 1, 3, 3, 3, 1294, 8, 3, 1, 3, 1, 3, 3, 3, 1298, 8, + 3, 1, 3, 1, 3, 3, 3, 1302, 8, 3, 1, 3, 1, 3, 3, 3, 1306, 8, 3, 1, 3, 1, + 3, 3, 3, 1310, 8, 3, 1, 3, 3, 3, 1313, 8, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 3, 4, 1320, 8, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, + 5, 1, 5, 3, 5, 1488, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 1495, 8, + 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, + 7, 3, 7, 1509, 8, 7, 1, 8, 1, 8, 3, 8, 1513, 8, 8, 1, 8, 5, 8, 1516, 8, + 8, 10, 8, 12, 8, 1519, 9, 8, 1, 8, 1, 8, 3, 8, 1523, 8, 8, 1, 9, 1, 9, + 3, 9, 1527, 8, 9, 1, 10, 1, 10, 3, 10, 1531, 8, 10, 1, 11, 1, 11, 1, 11, + 3, 11, 1536, 8, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1541, 8, 11, 3, 11, 1543, + 8, 11, 1, 12, 1, 12, 3, 12, 1547, 8, 12, 1, 12, 3, 12, 1550, 8, 12, 1, + 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 1557, 8, 13, 1, 13, 3, 13, 1560, + 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 1569, 8, + 14, 1, 14, 3, 14, 1572, 8, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, + 1, 18, 1, 18, 1, 18, 3, 18, 1583, 8, 18, 1, 18, 4, 18, 1586, 8, 18, 11, + 18, 12, 18, 1587, 1, 18, 1, 18, 1, 18, 3, 18, 1593, 8, 18, 1, 18, 1, 18, + 1, 18, 3, 18, 1598, 8, 18, 1, 18, 5, 18, 1601, 8, 18, 10, 18, 12, 18, 1604, + 9, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1609, 8, 18, 1, 19, 1, 19, 3, 19, 1613, + 8, 19, 1, 19, 3, 19, 1616, 8, 19, 1, 19, 1, 19, 3, 19, 1620, 8, 19, 1, + 19, 3, 19, 1623, 8, 19, 1, 19, 3, 19, 1626, 8, 19, 1, 20, 1, 20, 1, 20, + 1, 20, 1, 20, 3, 20, 1633, 8, 20, 1, 20, 1, 20, 3, 20, 1637, 8, 20, 3, + 20, 1639, 8, 20, 1, 21, 1, 21, 1, 21, 3, 21, 1644, 8, 21, 1, 21, 1, 21, + 5, 21, 1648, 8, 21, 10, 21, 12, 21, 1651, 9, 21, 1, 21, 3, 21, 1654, 8, + 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, + 3, 22, 1666, 8, 22, 5, 22, 1668, 8, 22, 10, 22, 12, 22, 1671, 9, 22, 1, + 22, 1, 22, 1, 22, 3, 22, 1676, 8, 22, 1, 22, 3, 22, 1679, 8, 22, 1, 22, + 1, 22, 1, 22, 1, 22, 1, 22, 5, 22, 1686, 8, 22, 10, 22, 12, 22, 1689, 9, + 22, 3, 22, 1691, 8, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, + 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, + 24, 1, 24, 3, 24, 1712, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, + 3, 25, 1720, 8, 25, 1, 25, 1, 25, 1, 25, 3, 25, 1725, 8, 25, 1, 25, 3, + 25, 1728, 8, 25, 1, 25, 1, 25, 1, 25, 3, 25, 1733, 8, 25, 1, 25, 3, 25, + 1736, 8, 25, 1, 25, 1, 25, 1, 25, 3, 25, 1741, 8, 25, 1, 26, 1, 26, 1, + 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 1750, 8, 26, 1, 26, 1, 26, 1, 26, + 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 1762, 8, 27, 1, + 27, 1, 27, 1, 27, 3, 27, 1767, 8, 27, 1, 27, 3, 27, 1770, 8, 27, 1, 27, + 1, 27, 1, 27, 3, 27, 1775, 8, 27, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1781, + 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1786, 8, 28, 1, 28, 1, 28, 1, 29, 1, + 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, + 1, 32, 3, 32, 1803, 8, 32, 1, 32, 3, 32, 1806, 8, 32, 1, 32, 3, 32, 1809, + 8, 32, 1, 32, 3, 32, 1812, 8, 32, 1, 33, 1, 33, 1, 33, 3, 33, 1817, 8, + 33, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 3, 36, 1826, 8, 36, + 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, + 40, 1, 40, 1, 40, 3, 40, 1841, 8, 40, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, + 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 3, + 46, 1858, 8, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, + 1, 47, 3, 47, 1869, 8, 47, 1, 47, 1, 47, 5, 47, 1873, 8, 47, 10, 47, 12, + 47, 1876, 9, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 50, 1, 50, + 1, 51, 1, 51, 1, 51, 1, 51, 3, 51, 1890, 8, 51, 1, 52, 1, 52, 1, 53, 1, + 53, 1, 53, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, + 1905, 8, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1914, + 8, 57, 1, 57, 1, 57, 3, 57, 1918, 8, 57, 1, 57, 4, 57, 1921, 8, 57, 11, + 57, 12, 57, 1922, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1929, 8, 57, 1, 58, + 1, 58, 1, 58, 1, 58, 3, 58, 1935, 8, 58, 1, 58, 3, 58, 1938, 8, 58, 1, + 58, 4, 58, 1941, 8, 58, 11, 58, 12, 58, 1942, 1, 58, 1, 58, 1, 58, 3, 58, + 1948, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 3, 59, 1956, 8, + 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1966, + 8, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, + 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 1985, 8, 63, + 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1993, 8, 64, 1, 64, 1, + 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, + 2006, 8, 64, 3, 64, 2008, 8, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, + 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 2020, 8, 64, 3, 64, 2022, 8, 64, + 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 2029, 8, 64, 1, 65, 1, 65, 1, + 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 2038, 8, 65, 1, 66, 1, 66, 1, 66, + 1, 66, 3, 66, 2044, 8, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, + 67, 3, 67, 2053, 8, 67, 1, 68, 1, 68, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, + 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 2067, 8, 71, 1, 71, 1, 71, 1, + 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 2077, 8, 72, 1, 72, 1, 72, + 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 2087, 8, 73, 1, 73, 1, + 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, + 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, + 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, + 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2127, 8, 74, 1, 75, 1, 75, 1, + 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, + 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 2150, 8, + 75, 1, 76, 1, 76, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, + 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, + 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, + 1, 78, 1, 78, 1, 78, 3, 78, 2186, 8, 78, 3, 78, 2188, 8, 78, 1, 78, 1, + 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, + 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 2206, 8, 78, 1, 78, 1, 78, 1, 78, 1, + 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, + 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 2230, 8, + 78, 1, 78, 3, 78, 2233, 8, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, + 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 2247, 8, 78, 1, 79, 1, + 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, + 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, + 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2279, 8, 82, + 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, + 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2297, 8, 82, 1, 82, 3, 82, + 2300, 8, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2305, 8, 82, 1, 82, 3, 82, 2308, + 8, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2313, 8, 82, 1, 82, 3, 82, 2316, 8, + 82, 1, 82, 1, 82, 1, 82, 3, 82, 2321, 8, 82, 1, 82, 3, 82, 2324, 8, 82, + 1, 82, 1, 82, 1, 82, 3, 82, 2329, 8, 82, 1, 82, 3, 82, 2332, 8, 82, 1, + 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2340, 8, 82, 1, 82, 3, 82, + 2343, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2351, 8, + 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, + 1, 82, 3, 82, 2364, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, + 82, 1, 82, 1, 82, 3, 82, 2375, 8, 82, 1, 82, 5, 82, 2378, 8, 82, 10, 82, + 12, 82, 2381, 9, 82, 1, 82, 3, 82, 2384, 8, 82, 1, 82, 1, 82, 1, 82, 1, + 82, 3, 82, 2390, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, + 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, + 82, 1, 82, 1, 82, 1, 82, 3, 82, 2413, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, + 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2425, 8, 82, 1, 82, 1, + 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2436, 8, 82, + 1, 82, 5, 82, 2439, 8, 82, 10, 82, 12, 82, 2442, 9, 82, 1, 82, 3, 82, 2445, + 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2451, 8, 82, 3, 82, 2453, 8, + 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, + 1, 82, 3, 82, 2466, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, + 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, + 1, 82, 1, 82, 4, 82, 2487, 8, 82, 11, 82, 12, 82, 2488, 1, 82, 1, 82, 1, + 82, 1, 82, 1, 82, 3, 82, 2496, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, + 1, 82, 1, 82, 3, 82, 2505, 8, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2510, 8, + 82, 1, 82, 3, 82, 2513, 8, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2518, 8, 82, + 1, 82, 3, 82, 2521, 8, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2526, 8, 82, 1, + 82, 4, 82, 2529, 8, 82, 11, 82, 12, 82, 2530, 1, 82, 1, 82, 1, 82, 1, 82, + 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, + 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, + 1, 82, 3, 82, 2559, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, + 82, 2567, 8, 82, 1, 82, 1, 82, 4, 82, 2571, 8, 82, 11, 82, 12, 82, 2572, + 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2580, 8, 82, 3, 82, 2582, 8, + 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, + 1, 82, 3, 82, 2595, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 2602, + 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, + 82, 1, 82, 1, 82, 1, 82, 3, 82, 2617, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, + 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, + 85, 1, 85, 3, 85, 2635, 8, 85, 1, 85, 3, 85, 2638, 8, 85, 3, 85, 2640, + 8, 85, 1, 85, 1, 85, 1, 85, 3, 85, 2645, 8, 85, 1, 85, 1, 85, 3, 85, 2649, + 8, 85, 1, 85, 3, 85, 2652, 8, 85, 3, 85, 2654, 8, 85, 1, 85, 1, 85, 1, + 85, 1, 85, 3, 85, 2660, 8, 85, 1, 85, 3, 85, 2663, 8, 85, 3, 85, 2665, + 8, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 2671, 8, 85, 3, 85, 2673, 8, + 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, + 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, + 87, 2695, 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2703, + 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2711, 8, 87, 4, + 87, 2713, 8, 87, 11, 87, 12, 87, 2714, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, + 1, 87, 1, 87, 3, 87, 2724, 8, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, + 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, + 1, 88, 1, 88, 1, 88, 3, 88, 2745, 8, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, + 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 2758, 8, 89, 1, 89, + 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, + 89, 1, 89, 3, 89, 2773, 8, 89, 4, 89, 2775, 8, 89, 11, 89, 12, 89, 2776, + 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, + 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, + 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, + 96, 1, 96, 3, 96, 2812, 8, 96, 1, 96, 3, 96, 2815, 8, 96, 1, 96, 4, 96, + 2818, 8, 96, 11, 96, 12, 96, 2819, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, + 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, + 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2843, 8, 100, 1, 100, 3, + 100, 2846, 8, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2851, 8, 100, 1, 100, + 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, + 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, + 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2877, 8, 104, 1, 105, 1, + 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, + 106, 1, 106, 3, 106, 2891, 8, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2896, + 8, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 3, 107, 2904, 8, + 107, 1, 107, 4, 107, 2907, 8, 107, 11, 107, 12, 107, 2908, 1, 107, 1, 107, + 1, 107, 1, 107, 1, 107, 3, 107, 2916, 8, 107, 1, 108, 1, 108, 1, 108, 1, + 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, + 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 2937, 8, 110, + 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, + 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, + 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, + 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, + 2974, 8, 117, 1, 117, 1, 117, 1, 117, 3, 117, 2979, 8, 117, 1, 117, 1, + 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, + 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2998, 8, 120, + 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, + 1, 122, 3, 122, 3010, 8, 122, 1, 122, 3, 122, 3013, 8, 122, 1, 122, 1, + 122, 1, 122, 3, 122, 3018, 8, 122, 1, 122, 3, 122, 3021, 8, 122, 1, 123, + 1, 123, 1, 123, 1, 123, 3, 123, 3027, 8, 123, 1, 123, 1, 123, 1, 124, 1, + 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, + 125, 3, 125, 3042, 8, 125, 1, 125, 1, 125, 1, 125, 3, 125, 3047, 8, 125, + 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 3055, 8, 126, 1, + 126, 3, 126, 3058, 8, 126, 1, 126, 1, 126, 1, 126, 3, 126, 3063, 8, 126, + 1, 126, 1, 126, 1, 126, 3, 126, 3068, 8, 126, 1, 126, 3, 126, 3071, 8, + 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, + 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, + 130, 1, 130, 1, 130, 1, 131, 1, 131, 3, 131, 3095, 8, 131, 1, 131, 1, 131, + 1, 131, 1, 131, 1, 131, 3, 131, 3102, 8, 131, 1, 131, 1, 131, 1, 131, 3, + 131, 3107, 8, 131, 1, 131, 1, 131, 1, 131, 3, 131, 3112, 8, 131, 1, 131, + 1, 131, 1, 131, 4, 131, 3117, 8, 131, 11, 131, 12, 131, 3118, 1, 132, 1, + 132, 1, 132, 1, 132, 1, 132, 3, 132, 3126, 8, 132, 1, 132, 1, 132, 1, 132, + 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, + 3139, 8, 133, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134, 3145, 8, 134, 1, + 134, 1, 134, 1, 134, 3, 134, 3150, 8, 134, 1, 134, 1, 134, 1, 135, 1, 135, + 1, 135, 1, 135, 3, 135, 3158, 8, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, + 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, + 137, 3, 137, 3174, 8, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 3, 138, + 3181, 8, 138, 1, 138, 1, 138, 1, 138, 3, 138, 3186, 8, 138, 1, 138, 4, + 138, 3189, 8, 138, 11, 138, 12, 138, 3190, 1, 138, 3, 138, 3194, 8, 138, + 1, 138, 1, 138, 1, 138, 1, 138, 3, 138, 3200, 8, 138, 1, 138, 1, 138, 1, + 138, 1, 138, 3, 138, 3206, 8, 138, 1, 139, 1, 139, 1, 139, 3, 139, 3211, + 8, 139, 1, 139, 1, 139, 1, 139, 3, 139, 3216, 8, 139, 1, 139, 4, 139, 3219, + 8, 139, 11, 139, 12, 139, 3220, 1, 139, 3, 139, 3224, 8, 139, 1, 139, 1, + 139, 1, 139, 1, 139, 3, 139, 3230, 8, 139, 1, 139, 1, 139, 1, 139, 1, 139, + 3, 139, 3236, 8, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, + 140, 1, 140, 1, 140, 3, 140, 3247, 8, 140, 1, 140, 3, 140, 3250, 8, 140, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, + 3260, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 3266, 8, 141, 4, + 141, 3268, 8, 141, 11, 141, 12, 141, 3269, 1, 141, 1, 141, 3, 141, 3274, + 8, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, + 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 143, + 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, + 1, 143, 3, 143, 3303, 8, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, + 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 3316, 8, 144, 1, 144, + 1, 144, 1, 144, 1, 144, 3, 144, 3322, 8, 144, 1, 145, 1, 145, 1, 145, 1, + 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 3332, 8, 145, 1, 145, 3, 145, + 3335, 8, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, + 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 3351, 8, 147, + 1, 147, 1, 147, 1, 147, 3, 147, 3356, 8, 147, 1, 147, 1, 147, 1, 147, 1, + 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, + 147, 1, 147, 3, 147, 3372, 8, 147, 1, 147, 3, 147, 3375, 8, 147, 1, 147, + 3, 147, 3378, 8, 147, 1, 147, 1, 147, 1, 147, 3, 147, 3383, 8, 147, 1, + 147, 3, 147, 3386, 8, 147, 1, 147, 1, 147, 1, 147, 3, 147, 3391, 8, 147, + 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 3400, 8, + 147, 1, 147, 3, 147, 3403, 8, 147, 1, 147, 3, 147, 3406, 8, 147, 1, 147, + 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 3413, 8, 147, 1, 148, 1, 148, 1, + 148, 1, 148, 1, 148, 1, 148, 3, 148, 3421, 8, 148, 1, 148, 1, 148, 3, 148, + 3425, 8, 148, 3, 148, 3427, 8, 148, 3, 148, 3429, 8, 148, 1, 149, 1, 149, + 1, 149, 1, 149, 3, 149, 3435, 8, 149, 1, 149, 1, 149, 3, 149, 3439, 8, + 149, 1, 149, 1, 149, 1, 149, 3, 149, 3444, 8, 149, 1, 149, 3, 149, 3447, + 8, 149, 3, 149, 3449, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, + 150, 1, 150, 1, 150, 1, 150, 1, 150, 3, 150, 3461, 8, 150, 1, 150, 3, 150, + 3464, 8, 150, 3, 150, 3466, 8, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, + 151, 1, 151, 1, 151, 1, 151, 1, 151, 3, 151, 3477, 8, 151, 1, 151, 1, 151, + 3, 151, 3481, 8, 151, 1, 151, 1, 151, 3, 151, 3485, 8, 151, 1, 151, 4, + 151, 3488, 8, 151, 11, 151, 12, 151, 3489, 1, 151, 1, 151, 1, 151, 1, 151, + 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, + 3, 152, 3505, 8, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3512, + 8, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, + 3521, 8, 152, 1, 152, 1, 152, 1, 152, 1, 152, 5, 152, 3527, 8, 152, 10, + 152, 12, 152, 3530, 9, 152, 3, 152, 3532, 8, 152, 1, 152, 1, 152, 1, 152, + 3, 152, 3537, 8, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3542, 8, 152, 1, + 152, 1, 152, 1, 152, 1, 152, 4, 152, 3548, 8, 152, 11, 152, 12, 152, 3549, + 1, 152, 1, 152, 4, 152, 3554, 8, 152, 11, 152, 12, 152, 3555, 1, 152, 1, + 152, 3, 152, 3560, 8, 152, 1, 152, 1, 152, 5, 152, 3564, 8, 152, 10, 152, + 12, 152, 3567, 9, 152, 5, 152, 3569, 8, 152, 10, 152, 12, 152, 3572, 9, + 152, 1, 152, 3, 152, 3575, 8, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, + 3, 152, 3582, 8, 152, 1, 152, 1, 152, 1, 152, 1, 152, 5, 152, 3588, 8, + 152, 10, 152, 12, 152, 3591, 9, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, + 152, 3, 152, 3598, 8, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, + 1, 152, 3, 152, 3607, 8, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3612, 8, + 152, 1, 152, 1, 152, 3, 152, 3616, 8, 152, 1, 152, 3, 152, 3619, 8, 152, + 4, 152, 3621, 8, 152, 11, 152, 12, 152, 3622, 1, 152, 1, 152, 5, 152, 3627, + 8, 152, 10, 152, 12, 152, 3630, 9, 152, 5, 152, 3632, 8, 152, 10, 152, + 12, 152, 3635, 9, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, + 3642, 8, 152, 1, 152, 1, 152, 1, 152, 1, 152, 5, 152, 3648, 8, 152, 10, + 152, 12, 152, 3651, 9, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3656, 8, 152, + 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3662, 8, 152, 1, 152, 3, 152, 3665, + 8, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3670, 8, 152, 1, 152, 3, 152, 3673, + 8, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3680, 8, 152, 3, + 152, 3682, 8, 152, 1, 152, 3, 152, 3685, 8, 152, 1, 152, 1, 152, 1, 152, + 1, 152, 3, 152, 3691, 8, 152, 1, 152, 3, 152, 3694, 8, 152, 1, 152, 1, + 152, 1, 152, 3, 152, 3699, 8, 152, 1, 152, 3, 152, 3702, 8, 152, 1, 152, + 1, 152, 1, 152, 3, 152, 3707, 8, 152, 1, 152, 3, 152, 3710, 8, 152, 1, + 152, 1, 152, 1, 152, 3, 152, 3715, 8, 152, 1, 152, 3, 152, 3718, 8, 152, + 1, 152, 1, 152, 1, 152, 3, 152, 3723, 8, 152, 1, 153, 3, 153, 3726, 8, + 153, 1, 153, 3, 153, 3729, 8, 153, 1, 153, 3, 153, 3732, 8, 153, 1, 153, + 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 3739, 8, 153, 4, 153, 3741, 8, + 153, 11, 153, 12, 153, 3742, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, + 154, 3750, 8, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 3, 155, 3757, + 8, 155, 1, 155, 1, 155, 1, 155, 1, 155, 3, 155, 3763, 8, 155, 1, 155, 1, + 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, + 155, 3, 155, 3776, 8, 155, 1, 155, 1, 155, 3, 155, 3780, 8, 155, 1, 155, + 1, 155, 1, 155, 3, 155, 3785, 8, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, + 155, 1, 155, 1, 155, 1, 155, 3, 155, 3795, 8, 155, 1, 155, 1, 155, 1, 155, + 1, 155, 1, 155, 1, 155, 1, 155, 3, 155, 3804, 8, 155, 1, 155, 1, 155, 3, + 155, 3808, 8, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, + 1, 156, 1, 156, 1, 156, 3, 156, 3820, 8, 156, 1, 156, 1, 156, 1, 156, 1, + 156, 3, 156, 3826, 8, 156, 1, 156, 1, 156, 1, 156, 4, 156, 3831, 8, 156, + 11, 156, 12, 156, 3832, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, + 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, + 1, 156, 1, 156, 1, 156, 3, 156, 3853, 8, 156, 1, 156, 1, 156, 3, 156, 3857, + 8, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 3, 157, 3865, 8, + 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 3, 157, 3874, + 8, 157, 1, 157, 1, 157, 1, 157, 1, 157, 3, 157, 3880, 8, 157, 1, 157, 1, + 157, 1, 157, 1, 157, 3, 157, 3886, 8, 157, 1, 157, 1, 157, 1, 157, 1, 157, + 1, 157, 1, 157, 4, 157, 3894, 8, 157, 11, 157, 12, 157, 3895, 1, 157, 1, + 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 3906, 8, 158, + 1, 158, 1, 158, 3, 158, 3910, 8, 158, 1, 158, 3, 158, 3913, 8, 158, 1, + 158, 1, 158, 3, 158, 3917, 8, 158, 1, 158, 1, 158, 1, 158, 3, 158, 3922, + 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 3928, 8, 158, 1, 158, 3, + 158, 3931, 8, 158, 1, 158, 1, 158, 3, 158, 3935, 8, 158, 1, 158, 1, 158, + 1, 158, 1, 158, 1, 158, 1, 158, 4, 158, 3943, 8, 158, 11, 158, 12, 158, + 3944, 1, 158, 3, 158, 3948, 8, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, + 159, 1, 159, 3, 159, 3956, 8, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, + 1, 159, 3, 159, 3964, 8, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 3, + 159, 3971, 8, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 4, 159, 3978, + 8, 159, 11, 159, 12, 159, 3979, 3, 159, 3982, 8, 159, 1, 159, 1, 159, 1, + 159, 3, 159, 3987, 8, 159, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 3993, + 8, 159, 1, 159, 4, 159, 3996, 8, 159, 11, 159, 12, 159, 3997, 3, 159, 4000, + 8, 159, 1, 159, 3, 159, 4003, 8, 159, 1, 159, 1, 159, 1, 159, 3, 159, 4008, + 8, 159, 1, 159, 3, 159, 4011, 8, 159, 1, 159, 1, 159, 1, 159, 3, 159, 4016, + 8, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, + 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 3, 160, 4031, 8, 160, 1, 160, 1, + 160, 1, 160, 1, 160, 1, 160, 3, 160, 4038, 8, 160, 1, 160, 1, 160, 1, 160, + 1, 160, 1, 160, 4, 160, 4045, 8, 160, 11, 160, 12, 160, 4046, 3, 160, 4049, + 8, 160, 1, 160, 1, 160, 1, 160, 3, 160, 4054, 8, 160, 1, 160, 1, 160, 1, + 160, 1, 160, 3, 160, 4060, 8, 160, 1, 160, 4, 160, 4063, 8, 160, 11, 160, + 12, 160, 4064, 3, 160, 4067, 8, 160, 1, 160, 3, 160, 4070, 8, 160, 1, 160, + 1, 160, 1, 160, 3, 160, 4075, 8, 160, 1, 160, 3, 160, 4078, 8, 160, 1, + 160, 1, 160, 1, 160, 3, 160, 4083, 8, 160, 1, 160, 1, 160, 1, 161, 1, 161, + 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 3, 161, 4096, 8, + 161, 1, 161, 1, 161, 1, 161, 3, 161, 4101, 8, 161, 1, 162, 1, 162, 1, 162, + 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 4110, 8, 162, 1, 162, 1, 162, 1, + 162, 3, 162, 4115, 8, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 4121, + 8, 162, 1, 162, 1, 162, 3, 162, 4125, 8, 162, 1, 162, 1, 162, 3, 162, 4129, + 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, + 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 4146, 8, + 163, 3, 163, 4148, 8, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, + 1, 164, 1, 164, 3, 164, 4158, 8, 164, 1, 164, 1, 164, 1, 164, 3, 164, 4163, + 8, 164, 3, 164, 4165, 8, 164, 1, 164, 1, 164, 3, 164, 4169, 8, 164, 1, + 165, 1, 165, 1, 165, 1, 165, 3, 165, 4175, 8, 165, 1, 165, 1, 165, 1, 165, + 1, 165, 1, 165, 1, 165, 3, 165, 4183, 8, 165, 1, 165, 5, 165, 4186, 8, + 165, 10, 165, 12, 165, 4189, 9, 165, 3, 165, 4191, 8, 165, 1, 165, 1, 165, + 1, 165, 1, 165, 5, 165, 4197, 8, 165, 10, 165, 12, 165, 4200, 9, 165, 3, + 165, 4202, 8, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4207, 8, 165, 1, 165, + 1, 165, 1, 165, 3, 165, 4212, 8, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4217, + 8, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4222, 8, 165, 1, 165, 1, 165, 1, + 165, 3, 165, 4227, 8, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4232, 8, 165, + 1, 165, 1, 165, 3, 165, 4236, 8, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4241, + 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, + 1, 166, 3, 166, 4252, 8, 166, 1, 166, 5, 166, 4255, 8, 166, 10, 166, 12, + 166, 4258, 9, 166, 3, 166, 4260, 8, 166, 1, 166, 3, 166, 4263, 8, 166, + 1, 166, 1, 166, 1, 166, 3, 166, 4268, 8, 166, 1, 166, 3, 166, 4271, 8, + 166, 1, 166, 1, 166, 1, 166, 3, 166, 4276, 8, 166, 1, 166, 3, 166, 4279, + 8, 166, 1, 166, 1, 166, 1, 166, 3, 166, 4284, 8, 166, 1, 166, 3, 166, 4287, + 8, 166, 1, 166, 1, 166, 1, 166, 3, 166, 4292, 8, 166, 1, 166, 3, 166, 4295, + 8, 166, 1, 166, 1, 166, 1, 166, 3, 166, 4300, 8, 166, 1, 166, 3, 166, 4303, + 8, 166, 1, 166, 1, 166, 1, 166, 3, 166, 4308, 8, 166, 1, 166, 1, 166, 1, + 166, 1, 166, 3, 166, 4314, 8, 166, 1, 166, 1, 166, 1, 166, 3, 166, 4319, + 8, 166, 1, 166, 3, 166, 4322, 8, 166, 1, 166, 1, 166, 1, 166, 3, 166, 4327, + 8, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 4334, 8, 166, 3, + 166, 4336, 8, 166, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 4342, 8, 167, + 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 4351, 8, + 167, 1, 167, 1, 167, 1, 167, 3, 167, 4356, 8, 167, 3, 167, 4358, 8, 167, + 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, + 1, 168, 3, 168, 4370, 8, 168, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 4376, + 8, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, + 5, 169, 4386, 8, 169, 10, 169, 12, 169, 4389, 9, 169, 3, 169, 4391, 8, + 169, 1, 169, 1, 169, 1, 169, 3, 169, 4396, 8, 169, 3, 169, 4398, 8, 169, + 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, + 4408, 8, 170, 1, 170, 1, 170, 1, 170, 3, 170, 4413, 8, 170, 3, 170, 4415, + 8, 170, 1, 170, 1, 170, 3, 170, 4419, 8, 170, 1, 171, 1, 171, 1, 171, 1, + 171, 3, 171, 4425, 8, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, + 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, + 1, 171, 3, 171, 4443, 8, 171, 3, 171, 4445, 8, 171, 1, 172, 1, 172, 1, + 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, + 173, 1, 173, 3, 173, 4460, 8, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, + 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, + 1, 173, 1, 173, 3, 173, 4478, 8, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, + 173, 1, 173, 3, 173, 4486, 8, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, + 1, 174, 1, 174, 1, 174, 3, 174, 4496, 8, 174, 1, 175, 1, 175, 1, 175, 1, + 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, + 175, 1, 175, 3, 175, 4512, 8, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, + 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, + 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 4533, 8, 177, 1, 178, 1, + 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 4544, + 8, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 4550, 8, 178, 1, 179, 1, + 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 3, 179, 4559, 8, 179, 1, 179, + 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 3, 179, 4568, 8, 179, 1, + 179, 1, 179, 1, 179, 1, 179, 3, 179, 4574, 8, 179, 1, 180, 1, 180, 1, 180, + 1, 180, 1, 180, 1, 180, 1, 180, 3, 180, 4583, 8, 180, 1, 180, 1, 180, 1, + 180, 3, 180, 4588, 8, 180, 1, 180, 3, 180, 4591, 8, 180, 1, 180, 1, 180, + 1, 180, 3, 180, 4596, 8, 180, 1, 180, 3, 180, 4599, 8, 180, 1, 180, 1, + 180, 1, 180, 3, 180, 4604, 8, 180, 1, 180, 3, 180, 4607, 8, 180, 1, 180, + 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 3, 180, 4615, 8, 180, 1, 180, 1, + 180, 1, 180, 1, 180, 3, 180, 4621, 8, 180, 4, 180, 4623, 8, 180, 11, 180, + 12, 180, 4624, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 3, 180, 4632, 8, + 180, 1, 180, 1, 180, 1, 180, 1, 180, 3, 180, 4638, 8, 180, 4, 180, 4640, + 8, 180, 11, 180, 12, 180, 4641, 1, 180, 3, 180, 4645, 8, 180, 3, 180, 4647, + 8, 180, 1, 180, 3, 180, 4650, 8, 180, 1, 180, 1, 180, 1, 180, 3, 180, 4655, + 8, 180, 1, 180, 3, 180, 4658, 8, 180, 1, 180, 1, 180, 1, 180, 3, 180, 4663, + 8, 180, 1, 180, 3, 180, 4666, 8, 180, 1, 180, 1, 180, 1, 180, 3, 180, 4671, + 8, 180, 1, 180, 3, 180, 4674, 8, 180, 1, 180, 1, 180, 1, 180, 3, 180, 4679, + 8, 180, 1, 180, 3, 180, 4682, 8, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, + 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, + 181, 4697, 8, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, + 1, 181, 1, 181, 3, 181, 4708, 8, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, + 182, 1, 182, 1, 182, 1, 182, 1, 182, 3, 182, 4719, 8, 182, 1, 182, 1, 182, + 1, 182, 5, 182, 4724, 8, 182, 10, 182, 12, 182, 4727, 9, 182, 3, 182, 4729, + 8, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 3, 182, 4737, 8, + 182, 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 4743, 8, 183, 1, 183, 1, 183, + 1, 184, 1, 184, 1, 184, 5, 184, 4750, 8, 184, 10, 184, 12, 184, 4753, 9, + 184, 1, 184, 1, 184, 1, 184, 1, 184, 3, 184, 4759, 8, 184, 1, 184, 1, 184, + 1, 184, 1, 184, 1, 184, 5, 184, 4766, 8, 184, 10, 184, 12, 184, 4769, 9, + 184, 1, 185, 1, 185, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 3, 187, 4778, + 8, 187, 1, 187, 1, 187, 1, 187, 3, 187, 4783, 8, 187, 1, 187, 1, 187, 1, + 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, + 188, 3, 188, 4797, 8, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, + 1, 189, 1, 189, 1, 189, 3, 189, 4808, 8, 189, 1, 189, 1, 189, 1, 189, 5, + 189, 4813, 8, 189, 10, 189, 12, 189, 4816, 9, 189, 3, 189, 4818, 8, 189, + 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 4826, 8, 189, 1, + 190, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, 4833, 8, 190, 1, 191, 1, 191, + 1, 191, 1, 191, 1, 191, 3, 191, 4840, 8, 191, 1, 191, 1, 191, 3, 191, 4844, + 8, 191, 1, 191, 1, 191, 1, 191, 3, 191, 4849, 8, 191, 1, 191, 3, 191, 4852, + 8, 191, 1, 191, 1, 191, 1, 191, 3, 191, 4857, 8, 191, 1, 191, 3, 191, 4860, + 8, 191, 1, 191, 1, 191, 1, 191, 3, 191, 4865, 8, 191, 1, 191, 3, 191, 4868, + 8, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 3, 191, + 4877, 8, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 3, 192, 4884, 8, + 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, + 193, 1, 193, 1, 193, 1, 193, 1, 193, 3, 193, 4899, 8, 193, 1, 193, 3, 193, + 4902, 8, 193, 1, 193, 1, 193, 1, 193, 3, 193, 4907, 8, 193, 1, 194, 1, + 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 3, 194, 4918, + 8, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 3, 194, + 4927, 8, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, + 194, 1, 194, 3, 194, 4938, 8, 194, 1, 194, 1, 194, 1, 194, 1, 194, 5, 194, + 4944, 8, 194, 10, 194, 12, 194, 4947, 9, 194, 1, 195, 1, 195, 1, 195, 1, + 195, 1, 195, 3, 195, 4954, 8, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, + 1, 196, 3, 196, 4962, 8, 196, 1, 196, 1, 196, 1, 196, 3, 196, 4967, 8, + 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, + 197, 3, 197, 4978, 8, 197, 1, 197, 3, 197, 4981, 8, 197, 1, 197, 1, 197, + 3, 197, 4985, 8, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, + 198, 4993, 8, 198, 1, 198, 1, 198, 3, 198, 4997, 8, 198, 1, 198, 1, 198, + 3, 198, 5001, 8, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, + 198, 5009, 8, 198, 1, 198, 4, 198, 5012, 8, 198, 11, 198, 12, 198, 5013, + 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 5022, 8, 198, 1, + 198, 1, 198, 1, 198, 3, 198, 5027, 8, 198, 1, 198, 1, 198, 5, 198, 5031, + 8, 198, 10, 198, 12, 198, 5034, 9, 198, 4, 198, 5036, 8, 198, 11, 198, + 12, 198, 5037, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, + 3, 198, 5047, 8, 198, 1, 198, 3, 198, 5050, 8, 198, 1, 198, 1, 198, 1, + 198, 3, 198, 5055, 8, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, + 5062, 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 5068, 8, 199, 3, + 199, 5070, 8, 199, 1, 199, 1, 199, 1, 199, 3, 199, 5075, 8, 199, 1, 199, + 1, 199, 1, 199, 1, 199, 3, 199, 5081, 8, 199, 1, 199, 1, 199, 1, 199, 1, + 199, 3, 199, 5087, 8, 199, 1, 199, 1, 199, 1, 199, 3, 199, 5092, 8, 199, + 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 5098, 8, 199, 1, 200, 1, 200, 1, + 200, 1, 200, 1, 200, 3, 200, 5105, 8, 200, 1, 200, 1, 200, 1, 200, 3, 200, + 5110, 8, 200, 1, 200, 1, 200, 1, 200, 3, 200, 5115, 8, 200, 1, 200, 1, + 200, 1, 200, 3, 200, 5120, 8, 200, 1, 200, 3, 200, 5123, 8, 200, 1, 200, + 1, 200, 3, 200, 5127, 8, 200, 1, 200, 3, 200, 5130, 8, 200, 1, 200, 1, + 200, 3, 200, 5134, 8, 200, 1, 200, 1, 200, 3, 200, 5138, 8, 200, 1, 200, + 3, 200, 5141, 8, 200, 1, 200, 1, 200, 3, 200, 5145, 8, 200, 1, 200, 1, + 200, 1, 200, 3, 200, 5150, 8, 200, 1, 200, 1, 200, 3, 200, 5154, 8, 200, + 1, 200, 1, 200, 3, 200, 5158, 8, 200, 1, 201, 1, 201, 1, 201, 1, 201, 1, + 201, 1, 201, 1, 201, 1, 201, 3, 201, 5168, 8, 201, 1, 201, 1, 201, 1, 201, + 1, 201, 3, 201, 5174, 8, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 3, + 201, 5181, 8, 201, 1, 201, 3, 201, 5184, 8, 201, 1, 201, 1, 201, 1, 201, + 1, 201, 3, 201, 5190, 8, 201, 1, 201, 1, 201, 1, 201, 1, 201, 3, 201, 5196, + 8, 201, 1, 201, 1, 201, 1, 201, 5, 201, 5201, 8, 201, 10, 201, 12, 201, + 5204, 9, 201, 1, 201, 1, 201, 1, 201, 3, 201, 5209, 8, 201, 3, 201, 5211, + 8, 201, 1, 201, 1, 201, 1, 201, 3, 201, 5216, 8, 201, 1, 201, 1, 201, 1, + 201, 1, 201, 3, 201, 5222, 8, 201, 1, 201, 1, 201, 1, 201, 1, 201, 3, 201, + 5228, 8, 201, 1, 201, 1, 201, 1, 201, 5, 201, 5233, 8, 201, 10, 201, 12, + 201, 5236, 9, 201, 1, 201, 3, 201, 5239, 8, 201, 1, 201, 1, 201, 3, 201, + 5243, 8, 201, 1, 201, 3, 201, 5246, 8, 201, 1, 201, 1, 201, 1, 201, 1, + 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 3, + 201, 5260, 8, 201, 1, 201, 1, 201, 1, 201, 3, 201, 5265, 8, 201, 1, 201, + 1, 201, 3, 201, 5269, 8, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, + 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 3, 201, 5282, 8, 201, 1, 201, + 3, 201, 5285, 8, 201, 3, 201, 5287, 8, 201, 1, 201, 1, 201, 1, 201, 1, + 201, 1, 201, 1, 201, 3, 201, 5295, 8, 201, 1, 202, 1, 202, 1, 202, 1, 202, + 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 5305, 8, 202, 1, 202, 1, 202, 1, + 202, 1, 202, 3, 202, 5311, 8, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, + 3, 202, 5318, 8, 202, 1, 202, 3, 202, 5321, 8, 202, 1, 202, 1, 202, 1, + 202, 1, 202, 3, 202, 5327, 8, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, + 5333, 8, 202, 1, 202, 1, 202, 1, 202, 5, 202, 5338, 8, 202, 10, 202, 12, + 202, 5341, 9, 202, 1, 202, 1, 202, 1, 202, 3, 202, 5346, 8, 202, 3, 202, + 5348, 8, 202, 1, 202, 1, 202, 1, 202, 3, 202, 5353, 8, 202, 1, 202, 1, + 202, 1, 202, 1, 202, 3, 202, 5359, 8, 202, 1, 202, 1, 202, 1, 202, 1, 202, + 3, 202, 5365, 8, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 5371, 8, + 202, 1, 202, 1, 202, 1, 202, 5, 202, 5376, 8, 202, 10, 202, 12, 202, 5379, + 9, 202, 1, 202, 3, 202, 5382, 8, 202, 1, 202, 1, 202, 3, 202, 5386, 8, + 202, 1, 202, 3, 202, 5389, 8, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, + 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 5403, 8, + 202, 1, 202, 1, 202, 1, 202, 3, 202, 5408, 8, 202, 1, 202, 1, 202, 3, 202, + 5412, 8, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, + 202, 1, 202, 1, 202, 1, 202, 3, 202, 5425, 8, 202, 1, 202, 3, 202, 5428, + 8, 202, 3, 202, 5430, 8, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, + 202, 3, 202, 5438, 8, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, + 1, 203, 1, 203, 1, 203, 3, 203, 5449, 8, 203, 1, 203, 1, 203, 1, 203, 1, + 203, 1, 203, 5, 203, 5456, 8, 203, 10, 203, 12, 203, 5459, 9, 203, 1, 203, + 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 3, 203, 5467, 8, 203, 1, 204, 1, + 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 5478, + 8, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 5, 204, 5485, 8, 204, 10, + 204, 12, 204, 5488, 9, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, + 204, 3, 204, 5496, 8, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, + 1, 205, 1, 205, 1, 205, 1, 205, 3, 205, 5508, 8, 205, 1, 205, 1, 205, 3, + 205, 5512, 8, 205, 1, 205, 1, 205, 1, 205, 4, 205, 5517, 8, 205, 11, 205, + 12, 205, 5518, 3, 205, 5521, 8, 205, 1, 205, 1, 205, 1, 205, 3, 205, 5526, + 8, 205, 1, 205, 1, 205, 3, 205, 5530, 8, 205, 1, 205, 1, 205, 1, 205, 4, + 205, 5535, 8, 205, 11, 205, 12, 205, 5536, 3, 205, 5539, 8, 205, 1, 205, + 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, + 1, 205, 1, 205, 3, 205, 5553, 8, 205, 1, 205, 1, 205, 1, 205, 3, 205, 5558, + 8, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, + 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, + 1, 205, 1, 205, 1, 205, 3, 205, 5580, 8, 205, 1, 205, 1, 205, 1, 205, 1, + 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, + 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 3, 205, 5602, + 8, 205, 1, 205, 1, 205, 1, 205, 3, 205, 5607, 8, 205, 1, 206, 1, 206, 1, + 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 3, + 206, 5620, 8, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 3, 207, + 5628, 8, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, + 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 3, + 209, 5646, 8, 209, 1, 209, 3, 209, 5649, 8, 209, 1, 209, 1, 209, 1, 209, + 1, 209, 5, 209, 5655, 8, 209, 10, 209, 12, 209, 5658, 9, 209, 1, 209, 1, + 209, 3, 209, 5662, 8, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, + 1, 211, 1, 211, 1, 211, 3, 211, 5673, 8, 211, 1, 211, 1, 211, 1, 211, 1, + 211, 1, 211, 3, 211, 5680, 8, 211, 1, 211, 1, 211, 1, 211, 3, 211, 5685, + 8, 211, 1, 211, 1, 211, 3, 211, 5689, 8, 211, 4, 211, 5691, 8, 211, 11, + 211, 12, 211, 5692, 1, 211, 3, 211, 5696, 8, 211, 1, 212, 1, 212, 1, 212, + 1, 212, 1, 212, 3, 212, 5703, 8, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, + 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, + 212, 1, 212, 1, 212, 3, 212, 5721, 8, 212, 3, 212, 5723, 8, 212, 1, 213, + 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, + 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, + 5743, 8, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 3, 214, 5750, 8, + 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 3, 214, 5757, 8, 214, 1, 214, + 1, 214, 1, 214, 3, 214, 5762, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 5767, + 8, 214, 1, 214, 1, 214, 1, 214, 1, 214, 3, 214, 5773, 8, 214, 1, 214, 1, + 214, 1, 214, 3, 214, 5778, 8, 214, 3, 214, 5780, 8, 214, 1, 215, 1, 215, + 1, 215, 1, 215, 1, 215, 3, 215, 5787, 8, 215, 1, 215, 1, 215, 1, 215, 1, + 215, 3, 215, 5793, 8, 215, 1, 215, 1, 215, 1, 215, 1, 215, 3, 215, 5799, + 8, 215, 1, 215, 3, 215, 5802, 8, 215, 1, 215, 1, 215, 1, 215, 1, 215, 3, + 215, 5808, 8, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 4, 215, + 5816, 8, 215, 11, 215, 12, 215, 5817, 1, 215, 3, 215, 5821, 8, 215, 1, + 215, 1, 215, 1, 215, 1, 215, 1, 215, 3, 215, 5828, 8, 215, 1, 215, 3, 215, + 5831, 8, 215, 1, 215, 1, 215, 1, 215, 4, 215, 5836, 8, 215, 11, 215, 12, + 215, 5837, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5846, + 8, 216, 1, 216, 1, 216, 3, 216, 5850, 8, 216, 1, 216, 1, 216, 1, 216, 1, + 216, 3, 216, 5856, 8, 216, 1, 216, 1, 216, 1, 216, 5, 216, 5861, 8, 216, + 10, 216, 12, 216, 5864, 9, 216, 3, 216, 5866, 8, 216, 1, 216, 1, 216, 1, + 216, 1, 216, 1, 216, 3, 216, 5873, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, + 3, 216, 5879, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5886, + 8, 216, 1, 216, 3, 216, 5889, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, + 216, 5895, 8, 216, 1, 216, 1, 216, 1, 216, 5, 216, 5900, 8, 216, 10, 216, + 12, 216, 5903, 9, 216, 3, 216, 5905, 8, 216, 1, 216, 1, 216, 1, 216, 1, + 216, 1, 216, 1, 216, 3, 216, 5913, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, + 3, 216, 5919, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5926, + 8, 216, 1, 216, 3, 216, 5929, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, + 216, 5935, 8, 216, 1, 216, 1, 216, 1, 216, 5, 216, 5940, 8, 216, 10, 216, + 12, 216, 5943, 9, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, + 5950, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5958, + 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5964, 8, 216, 1, 216, 1, + 216, 1, 216, 5, 216, 5969, 8, 216, 10, 216, 12, 216, 5972, 9, 216, 1, 216, + 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5981, 8, 216, 1, + 216, 1, 216, 1, 216, 3, 216, 5986, 8, 216, 1, 217, 1, 217, 1, 217, 1, 217, + 1, 217, 1, 217, 1, 217, 1, 217, 3, 217, 5996, 8, 217, 1, 217, 1, 217, 1, + 217, 1, 217, 3, 217, 6002, 8, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, + 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 3, 217, 6014, 8, 217, 3, 217, 6016, + 8, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 6023, 8, 218, 1, + 218, 1, 218, 1, 218, 1, 218, 3, 218, 6029, 8, 218, 1, 218, 1, 218, 1, 218, + 1, 218, 3, 218, 6035, 8, 218, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 6041, + 8, 218, 1, 218, 1, 218, 1, 218, 4, 218, 6046, 8, 218, 11, 218, 12, 218, + 6047, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 3, 219, 6055, 8, 219, 1, + 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 3, 219, 6063, 8, 219, 1, 219, + 1, 219, 1, 219, 1, 219, 3, 219, 6069, 8, 219, 1, 219, 1, 219, 1, 219, 1, + 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 4, + 219, 6083, 8, 219, 11, 219, 12, 219, 6084, 1, 219, 3, 219, 6088, 8, 219, + 1, 219, 1, 219, 1, 219, 3, 219, 6093, 8, 219, 3, 219, 6095, 8, 219, 1, + 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, + 220, 3, 220, 6107, 8, 220, 1, 220, 1, 220, 1, 220, 1, 220, 3, 220, 6113, + 8, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, + 1, 220, 1, 220, 1, 220, 1, 220, 4, 220, 6127, 8, 220, 11, 220, 12, 220, + 6128, 1, 220, 3, 220, 6132, 8, 220, 1, 220, 1, 220, 1, 220, 3, 220, 6137, + 8, 220, 1, 220, 3, 220, 6140, 8, 220, 1, 220, 1, 220, 1, 220, 3, 220, 6145, + 8, 220, 3, 220, 6147, 8, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, + 221, 1, 221, 3, 221, 6156, 8, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, + 3, 221, 6163, 8, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, + 222, 1, 222, 1, 222, 1, 222, 3, 222, 6175, 8, 222, 1, 222, 1, 222, 1, 222, + 1, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, + 1, 223, 1, 223, 3, 223, 6191, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, + 223, 5, 223, 6198, 8, 223, 10, 223, 12, 223, 6201, 9, 223, 1, 223, 1, 223, + 1, 224, 1, 224, 1, 224, 1, 224, 3, 224, 6209, 8, 224, 1, 224, 3, 224, 6212, + 8, 224, 1, 224, 1, 224, 1, 224, 3, 224, 6217, 8, 224, 1, 225, 1, 225, 1, + 225, 1, 225, 1, 225, 3, 225, 6224, 8, 225, 3, 225, 6226, 8, 225, 1, 225, + 1, 225, 1, 225, 1, 225, 3, 225, 6232, 8, 225, 3, 225, 6234, 8, 225, 1, + 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 3, 225, 6242, 8, 225, 3, 225, + 6244, 8, 225, 1, 225, 1, 225, 1, 225, 1, 225, 3, 225, 6250, 8, 225, 3, + 225, 6252, 8, 225, 1, 225, 1, 225, 1, 225, 1, 225, 3, 225, 6258, 8, 225, + 3, 225, 6260, 8, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 3, 225, 6267, + 8, 225, 1, 225, 3, 225, 6270, 8, 225, 3, 225, 6272, 8, 225, 1, 225, 3, + 225, 6275, 8, 225, 1, 225, 1, 225, 3, 225, 6279, 8, 225, 3, 225, 6281, + 8, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, + 3, 225, 6291, 8, 225, 1, 226, 1, 226, 1, 226, 1, 226, 3, 226, 6297, 8, + 226, 1, 226, 1, 226, 3, 226, 6301, 8, 226, 1, 227, 1, 227, 1, 227, 1, 227, + 1, 227, 1, 227, 3, 227, 6309, 8, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, + 227, 3, 227, 6316, 8, 227, 1, 227, 1, 227, 1, 227, 1, 227, 3, 227, 6322, + 8, 227, 3, 227, 6324, 8, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, + 229, 1, 229, 1, 229, 1, 229, 3, 229, 6335, 8, 229, 1, 229, 1, 229, 1, 229, + 3, 229, 6340, 8, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3, 229, 6346, 8, + 229, 4, 229, 6348, 8, 229, 11, 229, 12, 229, 6349, 1, 229, 1, 229, 1, 230, + 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 3, 230, 6360, 8, 230, 1, 231, 1, + 231, 1, 231, 1, 231, 1, 231, 1, 231, 3, 231, 6368, 8, 231, 1, 231, 1, 231, + 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 3, 231, + 6380, 8, 231, 1, 232, 3, 232, 6383, 8, 232, 1, 232, 1, 232, 1, 232, 1, + 232, 1, 232, 1, 232, 3, 232, 6391, 8, 232, 3, 232, 6393, 8, 232, 1, 232, + 3, 232, 6396, 8, 232, 1, 232, 1, 232, 3, 232, 6400, 8, 232, 1, 232, 3, + 232, 6403, 8, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 4, 232, 6410, + 8, 232, 11, 232, 12, 232, 6411, 1, 232, 3, 232, 6415, 8, 232, 1, 232, 3, + 232, 6418, 8, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, 233, 3, 233, + 6426, 8, 233, 1, 233, 1, 233, 4, 233, 6430, 8, 233, 11, 233, 12, 233, 6431, + 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 3, 233, 6439, 8, 233, 1, 233, 1, + 233, 3, 233, 6443, 8, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, + 1, 233, 1, 233, 1, 233, 3, 233, 6454, 8, 233, 1, 233, 1, 233, 4, 233, 6458, + 8, 233, 11, 233, 12, 233, 6459, 3, 233, 6462, 8, 233, 1, 234, 1, 234, 1, + 234, 1, 234, 1, 234, 5, 234, 6469, 8, 234, 10, 234, 12, 234, 6472, 9, 234, + 1, 234, 3, 234, 6475, 8, 234, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 3, + 235, 6482, 8, 235, 1, 235, 1, 235, 1, 235, 3, 235, 6487, 8, 235, 1, 236, + 3, 236, 6490, 8, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 3, + 236, 6498, 8, 236, 1, 236, 1, 236, 3, 236, 6502, 8, 236, 1, 236, 3, 236, + 6505, 8, 236, 1, 236, 1, 236, 3, 236, 6509, 8, 236, 1, 236, 3, 236, 6512, + 8, 236, 1, 236, 3, 236, 6515, 8, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, + 236, 3, 236, 6522, 8, 236, 1, 236, 1, 236, 3, 236, 6526, 8, 236, 3, 236, + 6528, 8, 236, 3, 236, 6530, 8, 236, 1, 236, 3, 236, 6533, 8, 236, 1, 236, + 3, 236, 6536, 8, 236, 1, 236, 3, 236, 6539, 8, 236, 1, 237, 1, 237, 1, + 237, 3, 237, 6544, 8, 237, 1, 238, 3, 238, 6547, 8, 238, 1, 238, 1, 238, + 1, 238, 1, 238, 1, 238, 1, 238, 3, 238, 6555, 8, 238, 3, 238, 6557, 8, + 238, 1, 238, 3, 238, 6560, 8, 238, 1, 238, 1, 238, 3, 238, 6564, 8, 238, + 1, 238, 3, 238, 6567, 8, 238, 1, 238, 1, 238, 1, 238, 1, 238, 3, 238, 6573, + 8, 238, 1, 238, 3, 238, 6576, 8, 238, 1, 238, 1, 238, 3, 238, 6580, 8, + 238, 1, 238, 3, 238, 6583, 8, 238, 1, 238, 3, 238, 6586, 8, 238, 1, 239, + 1, 239, 1, 239, 1, 239, 3, 239, 6592, 8, 239, 1, 240, 3, 240, 6595, 8, + 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 3, 240, 6602, 8, 240, 1, 240, + 1, 240, 1, 240, 1, 240, 3, 240, 6608, 8, 240, 5, 240, 6610, 8, 240, 10, + 240, 12, 240, 6613, 9, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, + 240, 1, 240, 3, 240, 6622, 8, 240, 1, 240, 3, 240, 6625, 8, 240, 1, 241, + 3, 241, 6628, 8, 241, 1, 241, 1, 241, 1, 242, 1, 242, 3, 242, 6634, 8, + 242, 1, 242, 3, 242, 6637, 8, 242, 1, 242, 3, 242, 6640, 8, 242, 1, 242, + 3, 242, 6643, 8, 242, 1, 243, 1, 243, 3, 243, 6647, 8, 243, 1, 244, 3, + 244, 6650, 8, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 3, 244, + 6658, 8, 244, 3, 244, 6660, 8, 244, 1, 244, 1, 244, 3, 244, 6664, 8, 244, + 1, 244, 3, 244, 6667, 8, 244, 1, 244, 1, 244, 1, 244, 1, 244, 5, 244, 6673, + 8, 244, 10, 244, 12, 244, 6676, 9, 244, 1, 244, 3, 244, 6679, 8, 244, 1, + 244, 1, 244, 3, 244, 6683, 8, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, + 3, 244, 6690, 8, 244, 1, 244, 1, 244, 3, 244, 6694, 8, 244, 3, 244, 6696, + 8, 244, 3, 244, 6698, 8, 244, 1, 244, 3, 244, 6701, 8, 244, 1, 244, 3, + 244, 6704, 8, 244, 1, 244, 3, 244, 6707, 8, 244, 1, 245, 1, 245, 1, 245, + 1, 245, 5, 245, 6713, 8, 245, 10, 245, 12, 245, 6716, 9, 245, 1, 245, 1, + 245, 1, 245, 3, 245, 6721, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245, + 6727, 8, 245, 3, 245, 6729, 8, 245, 1, 246, 1, 246, 3, 246, 6733, 8, 246, + 1, 246, 3, 246, 6736, 8, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, + 247, 3, 247, 6744, 8, 247, 1, 247, 1, 247, 3, 247, 6748, 8, 247, 1, 247, + 1, 247, 1, 247, 5, 247, 6753, 8, 247, 10, 247, 12, 247, 6756, 9, 247, 3, + 247, 6758, 8, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 5, 247, 6765, + 8, 247, 10, 247, 12, 247, 6768, 9, 247, 3, 247, 6770, 8, 247, 1, 247, 1, + 247, 3, 247, 6774, 8, 247, 1, 247, 1, 247, 1, 247, 1, 247, 5, 247, 6780, + 8, 247, 10, 247, 12, 247, 6783, 9, 247, 3, 247, 6785, 8, 247, 1, 248, 1, + 248, 3, 248, 6789, 8, 248, 1, 248, 3, 248, 6792, 8, 248, 1, 248, 1, 248, + 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, + 1, 248, 3, 248, 6806, 8, 248, 1, 248, 1, 248, 3, 248, 6810, 8, 248, 1, + 248, 3, 248, 6813, 8, 248, 1, 248, 1, 248, 3, 248, 6817, 8, 248, 1, 248, + 3, 248, 6820, 8, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, + 249, 1, 249, 1, 249, 1, 249, 3, 249, 6832, 8, 249, 1, 249, 3, 249, 6835, + 8, 249, 1, 249, 1, 249, 3, 249, 6839, 8, 249, 1, 249, 3, 249, 6842, 8, + 249, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 5, + 251, 6852, 8, 251, 10, 251, 12, 251, 6855, 9, 251, 1, 251, 1, 251, 1, 252, + 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, + 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 5, 252, + 6877, 8, 252, 10, 252, 12, 252, 6880, 9, 252, 1, 252, 1, 252, 1, 252, 1, + 252, 1, 252, 1, 252, 3, 252, 6888, 8, 252, 1, 253, 3, 253, 6891, 8, 253, + 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, + 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 3, 254, 6907, 8, 254, 1, 255, 1, + 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 5, 256, 6916, 8, 256, 10, + 256, 12, 256, 6919, 9, 256, 1, 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, + 257, 1, 257, 1, 257, 1, 257, 3, 257, 6930, 8, 257, 1, 258, 1, 258, 1, 258, + 1, 258, 3, 258, 6936, 8, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, + 258, 1, 258, 3, 258, 6945, 8, 258, 1, 258, 1, 258, 1, 258, 3, 258, 6950, + 8, 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 5, 259, 6957, 8, 259, 10, + 259, 12, 259, 6960, 9, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, + 260, 1, 260, 1, 260, 1, 260, 3, 260, 6971, 8, 260, 1, 260, 3, 260, 6974, + 8, 260, 1, 261, 1, 261, 1, 261, 1, 261, 3, 261, 6980, 8, 261, 1, 261, 3, + 261, 6983, 8, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 5, 262, 6990, + 8, 262, 10, 262, 12, 262, 6993, 9, 262, 1, 262, 1, 262, 1, 263, 1, 263, + 1, 263, 1, 263, 1, 263, 1, 263, 3, 263, 7003, 8, 263, 1, 264, 1, 264, 1, + 264, 1, 264, 1, 264, 5, 264, 7010, 8, 264, 10, 264, 12, 264, 7013, 9, 264, + 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, + 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, + 1, 265, 1, 265, 1, 265, 3, 265, 7036, 8, 265, 3, 265, 7038, 8, 265, 1, + 266, 1, 266, 1, 266, 1, 266, 3, 266, 7044, 8, 266, 1, 266, 3, 266, 7047, + 8, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 3, 266, 7054, 8, 266, 3, + 266, 7056, 8, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 5, 267, 7063, + 8, 267, 10, 267, 12, 267, 7066, 9, 267, 1, 267, 1, 267, 1, 268, 1, 268, + 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, + 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, + 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 3, 268, 7095, 8, 268, 1, 268, 3, + 268, 7098, 8, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, + 3, 268, 7107, 8, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, + 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 3, 268, 7122, 8, 268, + 1, 268, 1, 268, 1, 268, 1, 268, 3, 268, 7128, 8, 268, 3, 268, 7130, 8, + 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 5, 269, 7137, 8, 269, 10, + 269, 12, 269, 7140, 9, 269, 1, 269, 1, 269, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 3, 270, 7157, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 7163, + 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, + 7172, 8, 270, 1, 270, 3, 270, 7175, 8, 270, 3, 270, 7177, 8, 270, 1, 271, + 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 7185, 8, 271, 1, 271, 1, + 271, 1, 271, 1, 271, 3, 271, 7191, 8, 271, 5, 271, 7193, 8, 271, 10, 271, + 12, 271, 7196, 9, 271, 1, 271, 1, 271, 1, 272, 1, 272, 1, 272, 1, 272, + 1, 272, 1, 272, 1, 272, 1, 272, 3, 272, 7208, 8, 272, 1, 272, 1, 272, 3, + 272, 7212, 8, 272, 1, 272, 3, 272, 7215, 8, 272, 1, 273, 1, 273, 1, 273, + 1, 273, 1, 273, 5, 273, 7222, 8, 273, 10, 273, 12, 273, 7225, 9, 273, 1, + 273, 1, 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, + 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 3, 274, 7242, 8, 274, 1, 274, + 1, 274, 1, 274, 1, 274, 3, 274, 7248, 8, 274, 3, 274, 7250, 8, 274, 1, + 275, 1, 275, 3, 275, 7254, 8, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, + 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 3, 275, 7266, 8, 275, 1, 275, 3, + 275, 7269, 8, 275, 1, 275, 1, 275, 3, 275, 7273, 8, 275, 1, 275, 3, 275, + 7276, 8, 275, 1, 276, 1, 276, 3, 276, 7280, 8, 276, 1, 276, 1, 276, 1, + 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, + 276, 1, 276, 1, 276, 3, 276, 7296, 8, 276, 3, 276, 7298, 8, 276, 3, 276, + 7300, 8, 276, 1, 276, 3, 276, 7303, 8, 276, 1, 276, 3, 276, 7306, 8, 276, + 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 5, 277, 7313, 8, 277, 10, 277, + 12, 277, 7316, 9, 277, 1, 277, 1, 277, 1, 278, 1, 278, 1, 278, 1, 278, + 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, + 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, + 3, 278, 7342, 8, 278, 1, 278, 3, 278, 7345, 8, 278, 1, 278, 1, 278, 1, + 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, + 278, 3, 278, 7359, 8, 278, 1, 279, 1, 279, 1, 279, 3, 279, 7364, 8, 279, + 1, 279, 3, 279, 7367, 8, 279, 1, 279, 1, 279, 1, 279, 1, 279, 3, 279, 7373, + 8, 279, 1, 279, 3, 279, 7376, 8, 279, 1, 279, 1, 279, 1, 279, 5, 279, 7381, + 8, 279, 10, 279, 12, 279, 7384, 9, 279, 1, 279, 3, 279, 7387, 8, 279, 3, + 279, 7389, 8, 279, 1, 279, 1, 279, 1, 279, 1, 279, 5, 279, 7395, 8, 279, + 10, 279, 12, 279, 7398, 9, 279, 3, 279, 7400, 8, 279, 1, 279, 1, 279, 3, + 279, 7404, 8, 279, 1, 279, 1, 279, 1, 279, 5, 279, 7409, 8, 279, 10, 279, + 12, 279, 7412, 9, 279, 3, 279, 7414, 8, 279, 1, 280, 1, 280, 1, 280, 1, + 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, 3, 281, 7426, 8, 281, + 1, 282, 1, 282, 1, 282, 3, 282, 7431, 8, 282, 1, 282, 3, 282, 7434, 8, + 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 5, + 282, 7444, 8, 282, 10, 282, 12, 282, 7447, 9, 282, 3, 282, 7449, 8, 282, + 1, 282, 1, 282, 1, 282, 1, 282, 3, 282, 7455, 8, 282, 1, 282, 1, 282, 1, + 282, 5, 282, 7460, 8, 282, 10, 282, 12, 282, 7463, 9, 282, 1, 282, 1, 282, + 3, 282, 7467, 8, 282, 1, 282, 1, 282, 1, 282, 3, 282, 7472, 8, 282, 1, + 282, 1, 282, 4, 282, 7476, 8, 282, 11, 282, 12, 282, 7477, 1, 283, 1, 283, + 3, 283, 7482, 8, 283, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 3, 285, 7489, + 8, 285, 1, 285, 3, 285, 7492, 8, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, + 285, 1, 285, 3, 285, 7500, 8, 285, 1, 285, 1, 285, 1, 285, 1, 285, 5, 285, + 7506, 8, 285, 10, 285, 12, 285, 7509, 9, 285, 3, 285, 7511, 8, 285, 1, + 285, 1, 285, 1, 285, 1, 285, 5, 285, 7517, 8, 285, 10, 285, 12, 285, 7520, + 9, 285, 1, 285, 1, 285, 4, 285, 7524, 8, 285, 11, 285, 12, 285, 7525, 1, + 286, 1, 286, 1, 287, 1, 287, 1, 287, 3, 287, 7533, 8, 287, 1, 287, 3, 287, + 7536, 8, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 5, 287, 7544, + 8, 287, 10, 287, 12, 287, 7547, 9, 287, 1, 287, 1, 287, 1, 287, 1, 287, + 3, 287, 7553, 8, 287, 1, 287, 1, 287, 1, 287, 3, 287, 7558, 8, 287, 1, + 287, 3, 287, 7561, 8, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 5, 288, 7569, 8, 288, 10, 288, 12, 288, 7572, 9, 288, 3, 288, 7574, 8, + 288, 1, 288, 3, 288, 7577, 8, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 3, 288, 7586, 8, 288, 3, 288, 7588, 8, 288, 1, 289, 1, + 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 5, 289, 7597, 8, 289, 10, + 289, 12, 289, 7600, 9, 289, 3, 289, 7602, 8, 289, 1, 289, 3, 289, 7605, + 8, 289, 1, 289, 1, 289, 1, 289, 5, 289, 7610, 8, 289, 10, 289, 12, 289, + 7613, 9, 289, 1, 289, 1, 289, 3, 289, 7617, 8, 289, 1, 289, 1, 289, 3, + 289, 7621, 8, 289, 3, 289, 7623, 8, 289, 1, 290, 1, 290, 1, 290, 1, 290, + 1, 290, 1, 290, 5, 290, 7631, 8, 290, 10, 290, 12, 290, 7634, 9, 290, 3, + 290, 7636, 8, 290, 1, 290, 3, 290, 7639, 8, 290, 1, 290, 1, 290, 1, 290, + 5, 290, 7644, 8, 290, 10, 290, 12, 290, 7647, 9, 290, 1, 290, 1, 290, 1, + 290, 3, 290, 7652, 8, 290, 1, 290, 1, 290, 3, 290, 7656, 8, 290, 1, 291, + 1, 291, 1, 291, 1, 291, 3, 291, 7662, 8, 291, 1, 292, 1, 292, 3, 292, 7666, + 8, 292, 1, 292, 1, 292, 1, 292, 3, 292, 7671, 8, 292, 1, 292, 1, 292, 3, + 292, 7675, 8, 292, 1, 292, 1, 292, 3, 292, 7679, 8, 292, 1, 292, 3, 292, + 7682, 8, 292, 1, 293, 1, 293, 1, 293, 3, 293, 7687, 8, 293, 1, 294, 1, + 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, + 294, 1, 294, 3, 294, 7701, 8, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, + 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, + 3, 295, 7717, 8, 295, 1, 295, 1, 295, 3, 295, 7721, 8, 295, 1, 295, 1, + 295, 1, 295, 1, 295, 3, 295, 7727, 8, 295, 3, 295, 7729, 8, 295, 1, 295, + 3, 295, 7732, 8, 295, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, + 296, 1, 296, 5, 296, 7742, 8, 296, 10, 296, 12, 296, 7745, 9, 296, 1, 296, + 1, 296, 3, 296, 7749, 8, 296, 1, 296, 3, 296, 7752, 8, 296, 1, 297, 1, + 297, 1, 297, 1, 297, 5, 297, 7758, 8, 297, 10, 297, 12, 297, 7761, 9, 297, + 1, 298, 1, 298, 3, 298, 7765, 8, 298, 1, 298, 1, 298, 1, 298, 3, 298, 7770, + 8, 298, 1, 298, 1, 298, 1, 298, 1, 298, 3, 298, 7776, 8, 298, 1, 298, 1, + 298, 1, 298, 3, 298, 7781, 8, 298, 1, 298, 1, 298, 3, 298, 7785, 8, 298, + 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, + 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, + 1, 298, 1, 298, 1, 298, 1, 298, 3, 298, 7809, 8, 298, 1, 299, 1, 299, 1, + 299, 1, 299, 1, 299, 1, 299, 3, 299, 7817, 8, 299, 1, 299, 5, 299, 7820, + 8, 299, 10, 299, 12, 299, 7823, 9, 299, 1, 299, 3, 299, 7826, 8, 299, 1, + 299, 1, 299, 1, 299, 3, 299, 7831, 8, 299, 1, 299, 5, 299, 7834, 8, 299, + 10, 299, 12, 299, 7837, 9, 299, 1, 299, 1, 299, 1, 299, 1, 299, 3, 299, + 7843, 8, 299, 1, 299, 1, 299, 1, 299, 3, 299, 7848, 8, 299, 1, 299, 3, + 299, 7851, 8, 299, 1, 300, 1, 300, 1, 300, 3, 300, 7856, 8, 300, 1, 300, + 3, 300, 7859, 8, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, + 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 3, 300, 7873, 8, 300, 1, 300, + 1, 300, 1, 300, 1, 300, 1, 300, 3, 300, 7880, 8, 300, 1, 300, 1, 300, 3, + 300, 7884, 8, 300, 3, 300, 7886, 8, 300, 1, 301, 1, 301, 1, 301, 1, 301, + 1, 301, 5, 301, 7893, 8, 301, 10, 301, 12, 301, 7896, 9, 301, 1, 301, 1, + 301, 1, 301, 1, 301, 1, 301, 5, 301, 7903, 8, 301, 10, 301, 12, 301, 7906, + 9, 301, 3, 301, 7908, 8, 301, 1, 302, 1, 302, 3, 302, 7912, 8, 302, 1, + 302, 1, 302, 1, 302, 1, 302, 1, 302, 3, 302, 7919, 8, 302, 1, 302, 1, 302, + 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, + 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 3, 302, + 7940, 8, 302, 1, 302, 1, 302, 1, 302, 3, 302, 7945, 8, 302, 5, 302, 7947, + 8, 302, 10, 302, 12, 302, 7950, 9, 302, 1, 302, 1, 302, 1, 302, 1, 302, + 1, 302, 1, 302, 3, 302, 7958, 8, 302, 1, 302, 1, 302, 1, 302, 1, 302, 3, + 302, 7964, 8, 302, 3, 302, 7966, 8, 302, 1, 303, 1, 303, 1, 303, 1, 303, + 1, 303, 5, 303, 7973, 8, 303, 10, 303, 12, 303, 7976, 9, 303, 1, 303, 1, + 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, + 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, + 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, + 304, 1, 304, 3, 304, 8008, 8, 304, 1, 304, 1, 304, 1, 304, 1, 304, 3, 304, + 8014, 8, 304, 3, 304, 8016, 8, 304, 1, 305, 1, 305, 1, 305, 3, 305, 8021, + 8, 305, 1, 305, 3, 305, 8024, 8, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, + 305, 1, 305, 3, 305, 8032, 8, 305, 1, 305, 1, 305, 1, 305, 1, 305, 5, 305, + 8038, 8, 305, 10, 305, 12, 305, 8041, 9, 305, 3, 305, 8043, 8, 305, 1, + 305, 1, 305, 1, 305, 1, 305, 1, 305, 3, 305, 8050, 8, 305, 1, 305, 3, 305, + 8053, 8, 305, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, + 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, + 307, 3, 307, 8072, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 5, 307, + 8079, 8, 307, 10, 307, 12, 307, 8082, 9, 307, 1, 307, 1, 307, 1, 307, 1, + 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 8092, 8, 307, 1, 307, 1, 307, + 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, + 3, 307, 8105, 8, 307, 1, 307, 1, 307, 5, 307, 8109, 8, 307, 10, 307, 12, + 307, 8112, 9, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 8119, + 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 8127, 8, + 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 8133, 8, 307, 1, 307, 3, 307, + 8136, 8, 307, 1, 308, 3, 308, 8139, 8, 308, 1, 308, 3, 308, 8142, 8, 308, + 1, 308, 1, 308, 1, 308, 1, 308, 3, 308, 8148, 8, 308, 1, 308, 1, 308, 3, + 308, 8152, 8, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 3, 309, + 8160, 8, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, + 310, 1, 310, 1, 310, 3, 310, 8172, 8, 310, 1, 310, 1, 310, 1, 310, 1, 310, + 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 3, 310, 8184, 8, 310, 1, + 310, 1, 310, 3, 310, 8188, 8, 310, 1, 310, 3, 310, 8191, 8, 310, 1, 311, + 1, 311, 1, 311, 1, 311, 1, 311, 5, 311, 8198, 8, 311, 10, 311, 12, 311, + 8201, 9, 311, 1, 311, 1, 311, 1, 311, 3, 311, 8206, 8, 311, 1, 311, 1, + 311, 1, 311, 1, 311, 1, 311, 1, 311, 5, 311, 8214, 8, 311, 10, 311, 12, + 311, 8217, 9, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 3, 311, + 8225, 8, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, + 312, 3, 312, 8235, 8, 312, 1, 312, 1, 312, 1, 312, 1, 312, 3, 312, 8241, + 8, 312, 1, 312, 1, 312, 1, 312, 1, 312, 3, 312, 8247, 8, 312, 1, 312, 1, + 312, 1, 312, 1, 312, 1, 312, 3, 312, 8254, 8, 312, 1, 312, 1, 312, 1, 312, + 1, 312, 3, 312, 8260, 8, 312, 1, 312, 1, 312, 3, 312, 8264, 8, 312, 1, + 312, 1, 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 3, + 313, 8275, 8, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, + 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 3, 313, 8290, 8, 313, 3, + 313, 8292, 8, 313, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, + 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, + 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, + 3, 315, 8319, 8, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, + 316, 1, 316, 1, 316, 3, 316, 8330, 8, 316, 1, 316, 1, 316, 1, 316, 1, 316, + 1, 316, 1, 316, 3, 316, 8338, 8, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, + 317, 1, 317, 1, 317, 1, 317, 5, 317, 8348, 8, 317, 10, 317, 12, 317, 8351, + 9, 317, 5, 317, 8353, 8, 317, 10, 317, 12, 317, 8356, 9, 317, 1, 317, 3, + 317, 8359, 8, 317, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, + 3, 318, 8368, 8, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, + 320, 1, 320, 3, 320, 8378, 8, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, + 3, 321, 8385, 8, 321, 1, 321, 1, 321, 1, 321, 3, 321, 8390, 8, 321, 1, + 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, + 321, 1, 321, 1, 321, 1, 321, 1, 321, 3, 321, 8406, 8, 321, 1, 321, 3, 321, + 8409, 8, 321, 1, 321, 3, 321, 8412, 8, 321, 1, 321, 1, 321, 1, 321, 3, + 321, 8417, 8, 321, 1, 321, 3, 321, 8420, 8, 321, 1, 321, 1, 321, 1, 321, + 3, 321, 8425, 8, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, + 321, 3, 321, 8434, 8, 321, 1, 321, 3, 321, 8437, 8, 321, 1, 321, 3, 321, + 8440, 8, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 3, 321, 8447, 8, + 321, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 3, + 323, 8457, 8, 323, 1, 324, 1, 324, 1, 325, 1, 325, 1, 326, 1, 326, 1, 327, + 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, + 1, 327, 1, 327, 3, 327, 8477, 8, 327, 1, 328, 1, 328, 1, 328, 1, 328, 3, + 328, 8483, 8, 328, 1, 329, 1, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, + 1, 331, 1, 331, 1, 332, 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, 334, + 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 8508, 8, + 334, 3, 334, 8510, 8, 334, 1, 335, 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, + 1, 337, 1, 337, 1, 338, 1, 338, 1, 339, 1, 339, 1, 340, 1, 340, 1, 340, + 1, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, + 3, 341, 8536, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 8542, 8, + 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, + 341, 3, 341, 8553, 8, 341, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, + 3, 342, 8561, 8, 342, 1, 342, 3, 342, 8564, 8, 342, 1, 343, 1, 343, 1, + 343, 1, 344, 1, 344, 1, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, + 345, 1, 345, 1, 345, 1, 345, 3, 345, 8581, 8, 345, 1, 346, 1, 346, 1, 346, + 1, 346, 1, 346, 1, 346, 3, 346, 8589, 8, 346, 1, 347, 1, 347, 1, 347, 1, + 347, 1, 347, 3, 347, 8596, 8, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, + 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, + 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 3, 348, 8619, 8, + 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 1, + 350, 1, 350, 1, 350, 3, 350, 8632, 8, 350, 1, 351, 1, 351, 1, 351, 1, 351, + 3, 351, 8638, 8, 351, 1, 351, 1, 351, 1, 351, 5, 351, 8643, 8, 351, 10, + 351, 12, 351, 8646, 9, 351, 1, 351, 1, 351, 1, 351, 5, 351, 8651, 8, 351, + 10, 351, 12, 351, 8654, 9, 351, 3, 351, 8656, 8, 351, 1, 351, 3, 351, 8659, + 8, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 3, 353, + 8668, 8, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 354, 1, 354, 1, 354, 1, + 354, 3, 354, 8678, 8, 354, 1, 354, 1, 354, 1, 354, 5, 354, 8683, 8, 354, + 10, 354, 12, 354, 8686, 9, 354, 1, 354, 3, 354, 8689, 8, 354, 1, 355, 1, + 355, 3, 355, 8693, 8, 355, 1, 356, 1, 356, 1, 356, 1, 356, 3, 356, 8699, + 8, 356, 1, 356, 1, 356, 1, 356, 5, 356, 8704, 8, 356, 10, 356, 12, 356, + 8707, 9, 356, 1, 356, 3, 356, 8710, 8, 356, 1, 357, 1, 357, 1, 357, 1, + 357, 3, 357, 8716, 8, 357, 1, 357, 1, 357, 1, 357, 5, 357, 8721, 8, 357, + 10, 357, 12, 357, 8724, 9, 357, 1, 357, 1, 357, 1, 357, 1, 357, 3, 357, + 8730, 8, 357, 1, 357, 3, 357, 8733, 8, 357, 1, 358, 1, 358, 1, 358, 1, + 358, 3, 358, 8739, 8, 358, 1, 358, 1, 358, 1, 358, 5, 358, 8744, 8, 358, + 10, 358, 12, 358, 8747, 9, 358, 1, 358, 3, 358, 8750, 8, 358, 1, 359, 1, + 359, 1, 359, 3, 359, 8755, 8, 359, 1, 359, 1, 359, 1, 359, 3, 359, 8760, + 8, 359, 1, 359, 4, 359, 8763, 8, 359, 11, 359, 12, 359, 8764, 1, 359, 1, + 359, 1, 360, 1, 360, 1, 360, 1, 360, 3, 360, 8773, 8, 360, 1, 360, 1, 360, + 1, 360, 5, 360, 8778, 8, 360, 10, 360, 12, 360, 8781, 9, 360, 1, 360, 3, + 360, 8784, 8, 360, 1, 361, 1, 361, 1, 361, 1, 361, 3, 361, 8790, 8, 361, + 1, 361, 1, 361, 1, 361, 5, 361, 8795, 8, 361, 10, 361, 12, 361, 8798, 9, + 361, 1, 361, 3, 361, 8801, 8, 361, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, + 1, 362, 3, 362, 8809, 8, 362, 3, 362, 8811, 8, 362, 1, 362, 1, 362, 1, + 362, 1, 362, 1, 362, 1, 362, 3, 362, 8819, 8, 362, 1, 363, 1, 363, 1, 363, + 1, 363, 3, 363, 8825, 8, 363, 1, 363, 1, 363, 1, 364, 1, 364, 3, 364, 8831, + 8, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 366, + 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 3, 366, 8848, 8, + 366, 1, 366, 1, 366, 3, 366, 8852, 8, 366, 1, 366, 1, 366, 1, 366, 1, 367, + 1, 367, 1, 367, 3, 367, 8860, 8, 367, 1, 367, 1, 367, 1, 367, 3, 367, 8865, + 8, 367, 1, 367, 1, 367, 1, 367, 1, 367, 5, 367, 8871, 8, 367, 10, 367, + 12, 367, 8874, 9, 367, 1, 367, 1, 367, 1, 367, 3, 367, 8879, 8, 367, 1, + 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 5, 367, 8888, 8, 367, + 10, 367, 12, 367, 8891, 9, 367, 1, 367, 1, 367, 3, 367, 8895, 8, 367, 1, + 368, 1, 368, 1, 368, 1, 368, 1, 368, 3, 368, 8902, 8, 368, 1, 369, 1, 369, + 3, 369, 8906, 8, 369, 1, 369, 1, 369, 3, 369, 8910, 8, 369, 1, 369, 1, + 369, 3, 369, 8914, 8, 369, 1, 369, 3, 369, 8917, 8, 369, 1, 369, 1, 369, + 3, 369, 8921, 8, 369, 1, 369, 1, 369, 1, 369, 1, 369, 3, 369, 8927, 8, + 369, 1, 369, 1, 369, 3, 369, 8931, 8, 369, 3, 369, 8933, 8, 369, 1, 370, + 1, 370, 1, 370, 1, 370, 1, 370, 3, 370, 8940, 8, 370, 1, 370, 1, 370, 1, + 370, 5, 370, 8945, 8, 370, 10, 370, 12, 370, 8948, 9, 370, 3, 370, 8950, + 8, 370, 1, 370, 3, 370, 8953, 8, 370, 1, 370, 1, 370, 1, 370, 5, 370, 8958, + 8, 370, 10, 370, 12, 370, 8961, 9, 370, 1, 370, 1, 370, 3, 370, 8965, 8, + 370, 1, 370, 4, 370, 8968, 8, 370, 11, 370, 12, 370, 8969, 1, 370, 1, 370, + 3, 370, 8974, 8, 370, 1, 370, 1, 370, 1, 370, 1, 370, 3, 370, 8980, 8, + 370, 4, 370, 8982, 8, 370, 11, 370, 12, 370, 8983, 3, 370, 8986, 8, 370, + 1, 370, 1, 370, 1, 370, 3, 370, 8991, 8, 370, 1, 370, 4, 370, 8994, 8, + 370, 11, 370, 12, 370, 8995, 4, 370, 8998, 8, 370, 11, 370, 12, 370, 8999, + 1, 370, 1, 370, 1, 370, 3, 370, 9005, 8, 370, 1, 370, 1, 370, 1, 370, 1, + 370, 3, 370, 9011, 8, 370, 4, 370, 9013, 8, 370, 11, 370, 12, 370, 9014, + 4, 370, 9017, 8, 370, 11, 370, 12, 370, 9018, 3, 370, 9021, 8, 370, 1, + 370, 1, 370, 3, 370, 9025, 8, 370, 1, 370, 1, 370, 3, 370, 9029, 8, 370, + 1, 370, 1, 370, 3, 370, 9033, 8, 370, 1, 370, 1, 370, 3, 370, 9037, 8, + 370, 1, 370, 1, 370, 1, 370, 1, 370, 3, 370, 9043, 8, 370, 1, 370, 3, 370, + 9046, 8, 370, 1, 370, 1, 370, 1, 370, 1, 370, 3, 370, 9052, 8, 370, 1, + 370, 1, 370, 3, 370, 9056, 8, 370, 1, 370, 1, 370, 3, 370, 9060, 8, 370, + 1, 370, 1, 370, 1, 370, 1, 370, 3, 370, 9066, 8, 370, 1, 370, 1, 370, 1, + 370, 1, 370, 3, 370, 9072, 8, 370, 3, 370, 9074, 8, 370, 1, 370, 3, 370, + 9077, 8, 370, 1, 370, 1, 370, 3, 370, 9081, 8, 370, 1, 370, 1, 370, 3, + 370, 9085, 8, 370, 1, 370, 1, 370, 3, 370, 9089, 8, 370, 1, 370, 1, 370, + 1, 370, 1, 370, 3, 370, 9095, 8, 370, 1, 370, 3, 370, 9098, 8, 370, 1, + 370, 1, 370, 1, 370, 1, 370, 3, 370, 9104, 8, 370, 1, 370, 1, 370, 1, 370, + 1, 370, 3, 370, 9110, 8, 370, 1, 370, 3, 370, 9113, 8, 370, 1, 370, 1, + 370, 1, 370, 1, 370, 3, 370, 9119, 8, 370, 1, 370, 3, 370, 9122, 8, 370, + 1, 370, 1, 370, 1, 370, 1, 370, 3, 370, 9128, 8, 370, 1, 370, 3, 370, 9131, + 8, 370, 1, 370, 1, 370, 3, 370, 9135, 8, 370, 1, 370, 1, 370, 3, 370, 9139, + 8, 370, 1, 370, 1, 370, 3, 370, 9143, 8, 370, 1, 370, 1, 370, 1, 370, 3, + 370, 9148, 8, 370, 1, 370, 3, 370, 9151, 8, 370, 1, 370, 1, 370, 3, 370, + 9155, 8, 370, 1, 370, 1, 370, 3, 370, 9159, 8, 370, 1, 370, 1, 370, 1, + 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, + 370, 1, 370, 1, 370, 1, 370, 3, 370, 9176, 8, 370, 5, 370, 9178, 8, 370, + 10, 370, 12, 370, 9181, 9, 370, 3, 370, 9183, 8, 370, 1, 371, 1, 371, 1, + 371, 1, 371, 1, 371, 3, 371, 9190, 8, 371, 1, 371, 4, 371, 9193, 8, 371, + 11, 371, 12, 371, 9194, 1, 371, 1, 371, 3, 371, 9199, 8, 371, 1, 371, 1, + 371, 1, 371, 1, 371, 3, 371, 9205, 8, 371, 4, 371, 9207, 8, 371, 11, 371, + 12, 371, 9208, 3, 371, 9211, 8, 371, 1, 371, 1, 371, 1, 371, 3, 371, 9216, + 8, 371, 1, 371, 4, 371, 9219, 8, 371, 11, 371, 12, 371, 9220, 4, 371, 9223, + 8, 371, 11, 371, 12, 371, 9224, 1, 371, 1, 371, 1, 371, 3, 371, 9230, 8, + 371, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 9236, 8, 371, 4, 371, 9238, + 8, 371, 11, 371, 12, 371, 9239, 4, 371, 9242, 8, 371, 11, 371, 12, 371, + 9243, 3, 371, 9246, 8, 371, 1, 371, 1, 371, 3, 371, 9250, 8, 371, 1, 371, + 1, 371, 3, 371, 9254, 8, 371, 1, 371, 1, 371, 3, 371, 9258, 8, 371, 1, + 371, 1, 371, 3, 371, 9262, 8, 371, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, + 9268, 8, 371, 1, 371, 3, 371, 9271, 8, 371, 1, 371, 1, 371, 1, 371, 1, + 371, 3, 371, 9277, 8, 371, 1, 371, 1, 371, 3, 371, 9281, 8, 371, 1, 371, + 1, 371, 3, 371, 9285, 8, 371, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 9291, + 8, 371, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 9297, 8, 371, 3, 371, 9299, + 8, 371, 1, 371, 3, 371, 9302, 8, 371, 1, 371, 1, 371, 3, 371, 9306, 8, + 371, 1, 371, 1, 371, 3, 371, 9310, 8, 371, 1, 371, 1, 371, 3, 371, 9314, + 8, 371, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 9320, 8, 371, 1, 371, 3, + 371, 9323, 8, 371, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 9329, 8, 371, + 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 9335, 8, 371, 1, 371, 3, 371, 9338, + 8, 371, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 9344, 8, 371, 1, 371, 3, + 371, 9347, 8, 371, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 9353, 8, 371, + 1, 371, 3, 371, 9356, 8, 371, 1, 371, 1, 371, 3, 371, 9360, 8, 371, 1, + 371, 1, 371, 3, 371, 9364, 8, 371, 1, 371, 1, 371, 3, 371, 9368, 8, 371, + 1, 371, 1, 371, 1, 371, 3, 371, 9373, 8, 371, 1, 371, 3, 371, 9376, 8, + 371, 1, 371, 1, 371, 3, 371, 9380, 8, 371, 1, 371, 1, 371, 3, 371, 9384, + 8, 371, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 9390, 8, 371, 1, 371, 3, + 371, 9393, 8, 371, 1, 371, 1, 371, 3, 371, 9397, 8, 371, 1, 371, 1, 371, + 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, + 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 9414, 8, 371, 5, 371, 9416, 8, + 371, 10, 371, 12, 371, 9419, 9, 371, 3, 371, 9421, 8, 371, 1, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, + 1, 372, 3, 372, 9435, 8, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 9441, + 8, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 9449, 8, + 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 4, 372, 9456, 8, 372, 11, + 372, 12, 372, 9457, 1, 372, 3, 372, 9461, 8, 372, 1, 373, 1, 373, 1, 373, + 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, + 1, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, + 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, + 1, 375, 3, 375, 9494, 8, 375, 1, 376, 1, 376, 3, 376, 9498, 8, 376, 1, + 376, 1, 376, 3, 376, 9502, 8, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, + 3, 377, 9509, 8, 377, 1, 378, 1, 378, 1, 378, 1, 378, 1, 379, 1, 379, 1, + 379, 3, 379, 9518, 8, 379, 1, 380, 1, 380, 1, 380, 1, 380, 5, 380, 9524, + 8, 380, 10, 380, 12, 380, 9527, 9, 380, 3, 380, 9529, 8, 380, 1, 380, 3, + 380, 9532, 8, 380, 1, 381, 1, 381, 3, 381, 9536, 8, 381, 1, 381, 1, 381, + 3, 381, 9540, 8, 381, 1, 381, 3, 381, 9543, 8, 381, 1, 381, 1, 381, 1, + 381, 1, 381, 5, 381, 9549, 8, 381, 10, 381, 12, 381, 9552, 9, 381, 1, 381, + 1, 381, 1, 381, 1, 381, 1, 381, 3, 381, 9559, 8, 381, 1, 381, 1, 381, 3, + 381, 9563, 8, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 3, 381, 9570, + 8, 381, 3, 381, 9572, 8, 381, 1, 382, 1, 382, 1, 382, 5, 382, 9577, 8, + 382, 10, 382, 12, 382, 9580, 9, 382, 1, 382, 1, 382, 1, 382, 5, 382, 9585, + 8, 382, 10, 382, 12, 382, 9588, 9, 382, 3, 382, 9590, 8, 382, 1, 383, 1, + 383, 1, 383, 1, 383, 1, 384, 1, 384, 1, 385, 1, 385, 1, 385, 3, 385, 9601, + 8, 385, 1, 385, 1, 385, 1, 385, 3, 385, 9606, 8, 385, 1, 386, 1, 386, 3, + 386, 9610, 8, 386, 1, 386, 1, 386, 1, 386, 1, 386, 3, 386, 9616, 8, 386, + 3, 386, 9618, 8, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 3, 386, 9625, + 8, 386, 3, 386, 9627, 8, 386, 3, 386, 9629, 8, 386, 1, 387, 1, 387, 3, + 387, 9633, 8, 387, 1, 387, 1, 387, 1, 387, 3, 387, 9638, 8, 387, 1, 387, + 1, 387, 1, 387, 1, 387, 1, 387, 3, 387, 9645, 8, 387, 3, 387, 9647, 8, + 387, 1, 387, 1, 387, 1, 387, 1, 387, 3, 387, 9653, 8, 387, 1, 387, 3, 387, + 9656, 8, 387, 1, 387, 1, 387, 1, 387, 1, 387, 5, 387, 9662, 8, 387, 10, + 387, 12, 387, 9665, 9, 387, 1, 387, 1, 387, 1, 387, 3, 387, 9670, 8, 387, + 1, 387, 1, 387, 3, 387, 9674, 8, 387, 1, 387, 3, 387, 9677, 8, 387, 1, + 387, 1, 387, 1, 387, 1, 387, 1, 387, 3, 387, 9684, 8, 387, 1, 387, 3, 387, + 9687, 8, 387, 1, 387, 1, 387, 1, 387, 1, 387, 3, 387, 9693, 8, 387, 1, + 388, 1, 388, 3, 388, 9697, 8, 388, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, + 3, 389, 9704, 8, 389, 1, 389, 1, 389, 1, 389, 3, 389, 9709, 8, 389, 1, + 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 3, 389, 9717, 8, 389, 1, 390, + 1, 390, 1, 390, 3, 390, 9722, 8, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, + 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 3, 390, 9734, 8, 390, 3, 390, + 9736, 8, 390, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, + 391, 1, 391, 3, 391, 9747, 8, 391, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, + 3, 392, 9754, 8, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 5, + 392, 9762, 8, 392, 10, 392, 12, 392, 9765, 9, 392, 1, 393, 1, 393, 1, 393, + 1, 393, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, + 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 3, 394, + 9787, 8, 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, + 395, 1, 395, 1, 395, 1, 395, 3, 395, 9800, 8, 395, 1, 396, 1, 396, 1, 396, + 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, + 1, 396, 1, 396, 3, 396, 9816, 8, 396, 1, 396, 1, 396, 1, 396, 3, 396, 9821, + 8, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 3, 396, 9828, 8, 396, 1, + 396, 3, 396, 9831, 8, 396, 4, 396, 9833, 8, 396, 11, 396, 12, 396, 9834, + 3, 396, 9837, 8, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, + 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 3, + 397, 9854, 8, 397, 1, 398, 1, 398, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, + 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 3, 399, 9869, 8, 399, 1, + 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 3, 400, 9877, 8, 400, 1, 400, + 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 3, 400, 9886, 8, 400, 1, + 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 3, 400, 9894, 8, 400, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, 9902, 8, 401, 1, 401, 1, + 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, + 401, 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, 9919, 8, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 3, 401, 9932, 8, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, + 401, 1, 401, 1, 401, 1, 401, 3, 401, 9944, 8, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 3, 401, 9968, 8, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 3, + 401, 9975, 8, 401, 1, 401, 1, 401, 3, 401, 9979, 8, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, 9989, 8, 401, 1, + 401, 1, 401, 3, 401, 9993, 8, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 3, 401, 10010, 8, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, 10049, 8, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, 10056, 8, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, 10064, 8, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, + 10076, 8, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, 10098, 8, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, 10107, 8, 401, 3, 401, + 10109, 8, 401, 1, 402, 1, 402, 1, 402, 1, 402, 3, 402, 10115, 8, 402, 1, + 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, + 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 3, + 402, 10135, 8, 402, 3, 402, 10137, 8, 402, 3, 402, 10139, 8, 402, 1, 402, + 3, 402, 10142, 8, 402, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 3, 403, + 10149, 8, 403, 1, 403, 1, 403, 1, 403, 1, 403, 3, 403, 10155, 8, 403, 1, + 403, 1, 403, 1, 403, 3, 403, 10160, 8, 403, 3, 403, 10162, 8, 403, 1, 403, + 1, 403, 1, 403, 1, 403, 3, 403, 10168, 8, 403, 1, 403, 1, 403, 1, 403, + 1, 403, 1, 403, 1, 403, 3, 403, 10176, 8, 403, 3, 403, 10178, 8, 403, 1, + 403, 1, 403, 3, 403, 10182, 8, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, + 403, 1, 403, 1, 403, 1, 403, 3, 403, 10192, 8, 403, 1, 403, 1, 403, 3, + 403, 10196, 8, 403, 1, 403, 1, 403, 1, 403, 1, 403, 3, 403, 10202, 8, 403, + 3, 403, 10204, 8, 403, 1, 404, 1, 404, 3, 404, 10208, 8, 404, 1, 405, 1, + 405, 1, 405, 1, 406, 1, 406, 3, 406, 10215, 8, 406, 1, 407, 1, 407, 1, + 407, 3, 407, 10220, 8, 407, 1, 408, 1, 408, 1, 408, 3, 408, 10225, 8, 408, + 1, 409, 1, 409, 3, 409, 10229, 8, 409, 1, 410, 1, 410, 1, 411, 1, 411, + 1, 411, 1, 411, 1, 411, 3, 411, 10238, 8, 411, 1, 411, 1, 411, 1, 411, + 1, 411, 3, 411, 10244, 8, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, + 5, 411, 10251, 8, 411, 10, 411, 12, 411, 10254, 9, 411, 3, 411, 10256, + 8, 411, 3, 411, 10258, 8, 411, 1, 412, 1, 412, 1, 412, 1, 412, 1, 412, + 3, 412, 10265, 8, 412, 1, 412, 3, 412, 10268, 8, 412, 1, 412, 1, 412, 3, + 412, 10272, 8, 412, 1, 413, 1, 413, 1, 414, 1, 414, 1, 414, 1, 414, 3, + 414, 10280, 8, 414, 1, 414, 3, 414, 10283, 8, 414, 1, 414, 1, 414, 1, 414, + 1, 414, 5, 414, 10289, 8, 414, 10, 414, 12, 414, 10292, 9, 414, 3, 414, + 10294, 8, 414, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, + 1, 415, 1, 415, 1, 415, 3, 415, 10306, 8, 415, 1, 416, 1, 416, 1, 416, + 1, 416, 1, 416, 3, 416, 10313, 8, 416, 1, 416, 1, 416, 3, 416, 10317, 8, + 416, 1, 416, 3, 416, 10320, 8, 416, 1, 416, 1, 416, 1, 416, 1, 416, 5, + 416, 10326, 8, 416, 10, 416, 12, 416, 10329, 9, 416, 3, 416, 10331, 8, + 416, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 3, + 417, 10341, 8, 417, 1, 418, 1, 418, 1, 418, 1, 418, 3, 418, 10347, 8, 418, + 1, 418, 1, 418, 3, 418, 10351, 8, 418, 1, 418, 3, 418, 10354, 8, 418, 1, + 418, 1, 418, 1, 418, 1, 418, 5, 418, 10360, 8, 418, 10, 418, 12, 418, 10363, + 9, 418, 3, 418, 10365, 8, 418, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, + 1, 419, 1, 419, 1, 419, 1, 419, 3, 419, 10376, 8, 419, 3, 419, 10378, 8, + 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 5, 419, 10385, 8, 419, 10, + 419, 12, 419, 10388, 9, 419, 3, 419, 10390, 8, 419, 1, 420, 1, 420, 1, + 420, 1, 420, 1, 420, 3, 420, 10397, 8, 420, 1, 420, 1, 420, 1, 420, 3, + 420, 10402, 8, 420, 1, 420, 1, 420, 3, 420, 10406, 8, 420, 1, 420, 1, 420, + 1, 420, 3, 420, 10411, 8, 420, 1, 421, 1, 421, 1, 422, 1, 422, 1, 422, + 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 5, 422, 10425, + 8, 422, 10, 422, 12, 422, 10428, 9, 422, 3, 422, 10430, 8, 422, 1, 423, + 1, 423, 1, 423, 1, 423, 1, 423, 3, 423, 10437, 8, 423, 1, 423, 1, 423, + 3, 423, 10441, 8, 423, 1, 424, 1, 424, 1, 424, 3, 424, 10446, 8, 424, 1, + 425, 1, 425, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 3, 426, 10455, 8, + 426, 1, 426, 1, 426, 3, 426, 10459, 8, 426, 1, 426, 1, 426, 1, 426, 1, + 426, 5, 426, 10465, 8, 426, 10, 426, 12, 426, 10468, 9, 426, 3, 426, 10470, + 8, 426, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 3, 427, + 10479, 8, 427, 1, 427, 3, 427, 10482, 8, 427, 1, 427, 1, 427, 3, 427, 10486, + 8, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 3, 428, + 10495, 8, 428, 3, 428, 10497, 8, 428, 1, 428, 1, 428, 1, 428, 3, 428, 10502, + 8, 428, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 3, 429, 10510, + 8, 429, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 3, 430, 10517, 8, 430, + 1, 430, 1, 430, 3, 430, 10521, 8, 430, 1, 431, 1, 431, 1, 431, 1, 431, + 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, + 1, 431, 1, 431, 1, 431, 3, 431, 10539, 8, 431, 1, 432, 1, 432, 1, 432, + 1, 432, 1, 433, 1, 433, 3, 433, 10547, 8, 433, 1, 433, 1, 433, 1, 433, + 3, 433, 10552, 8, 433, 1, 434, 1, 434, 1, 434, 1, 434, 3, 434, 10558, 8, + 434, 1, 434, 5, 434, 10561, 8, 434, 10, 434, 12, 434, 10564, 9, 434, 1, + 434, 1, 434, 1, 435, 1, 435, 1, 435, 1, 435, 3, 435, 10572, 8, 435, 1, + 435, 3, 435, 10575, 8, 435, 1, 435, 3, 435, 10578, 8, 435, 1, 435, 1, 435, + 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 3, 435, 10589, + 8, 435, 1, 436, 1, 436, 1, 436, 3, 436, 10594, 8, 436, 1, 436, 1, 436, + 1, 436, 1, 437, 1, 437, 1, 437, 1, 437, 1, 438, 1, 438, 3, 438, 10605, + 8, 438, 1, 438, 5, 438, 10608, 8, 438, 10, 438, 12, 438, 10611, 9, 438, + 1, 439, 1, 439, 1, 439, 3, 439, 10616, 8, 439, 1, 440, 1, 440, 1, 440, + 1, 440, 1, 440, 3, 440, 10623, 8, 440, 3, 440, 10625, 8, 440, 1, 440, 5, + 440, 10628, 8, 440, 10, 440, 12, 440, 10631, 9, 440, 1, 440, 3, 440, 10634, + 8, 440, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, + 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 3, 441, 10649, 8, 441, 1, 441, + 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 3, 441, 10659, + 8, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, + 1, 441, 3, 441, 10670, 8, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, + 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, + 1, 441, 1, 441, 1, 441, 3, 441, 10689, 8, 441, 1, 442, 1, 442, 1, 442, + 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, + 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 3, 442, 10710, + 8, 442, 3, 442, 10712, 8, 442, 3, 442, 10714, 8, 442, 1, 443, 1, 443, 1, + 443, 1, 443, 1, 443, 1, 443, 3, 443, 10722, 8, 443, 1, 444, 1, 444, 3, + 444, 10726, 8, 444, 1, 444, 1, 444, 1, 444, 1, 444, 3, 444, 10732, 8, 444, + 1, 444, 3, 444, 10735, 8, 444, 1, 444, 1, 444, 1, 444, 3, 444, 10740, 8, + 444, 1, 444, 1, 444, 3, 444, 10744, 8, 444, 1, 445, 1, 445, 1, 445, 3, + 445, 10749, 8, 445, 1, 445, 3, 445, 10752, 8, 445, 1, 445, 3, 445, 10755, + 8, 445, 1, 445, 1, 445, 1, 445, 3, 445, 10760, 8, 445, 3, 445, 10762, 8, + 445, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 3, + 446, 10772, 8, 446, 1, 447, 1, 447, 3, 447, 10776, 8, 447, 1, 447, 1, 447, + 1, 447, 3, 447, 10781, 8, 447, 1, 447, 3, 447, 10784, 8, 447, 1, 447, 1, + 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, + 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 5, 447, 10803, 8, + 447, 10, 447, 12, 447, 10806, 9, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, + 447, 1, 447, 1, 447, 1, 447, 3, 447, 10816, 8, 447, 1, 447, 3, 447, 10819, + 8, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 449, 1, 449, 1, 449, 1, 449, + 3, 449, 10829, 8, 449, 1, 449, 3, 449, 10832, 8, 449, 1, 449, 3, 449, 10835, + 8, 449, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 5, 450, + 10844, 8, 450, 10, 450, 12, 450, 10847, 9, 450, 1, 450, 1, 450, 1, 450, + 3, 450, 10852, 8, 450, 1, 451, 1, 451, 1, 451, 1, 451, 3, 451, 10858, 8, + 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 452, 1, 452, 1, 452, 1, 452, 1, + 452, 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 10873, 8, 452, 1, 453, 1, + 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 3, 453, 10884, + 8, 453, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 5, 454, 10891, 8, 454, + 10, 454, 12, 454, 10894, 9, 454, 1, 454, 1, 454, 1, 455, 1, 455, 1, 455, + 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, + 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, + 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, + 1, 455, 3, 455, 10929, 8, 455, 1, 455, 1, 455, 1, 455, 1, 455, 3, 455, + 10935, 8, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, + 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 3, 455, 10949, 8, 455, 1, 455, + 1, 455, 1, 455, 3, 455, 10954, 8, 455, 5, 455, 10956, 8, 455, 10, 455, + 12, 455, 10959, 9, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, + 1, 455, 1, 455, 1, 455, 3, 455, 10970, 8, 455, 1, 455, 3, 455, 10973, 8, + 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 3, 455, 10982, + 8, 455, 3, 455, 10984, 8, 455, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, + 1, 456, 1, 456, 1, 456, 3, 456, 10994, 8, 456, 3, 456, 10996, 8, 456, 3, + 456, 10998, 8, 456, 1, 456, 3, 456, 11001, 8, 456, 1, 456, 3, 456, 11004, + 8, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, + 1, 456, 3, 456, 11015, 8, 456, 3, 456, 11017, 8, 456, 3, 456, 11019, 8, + 456, 1, 456, 3, 456, 11022, 8, 456, 1, 457, 5, 457, 11025, 8, 457, 10, + 457, 12, 457, 11028, 9, 457, 1, 457, 1, 457, 1, 457, 1, 458, 1, 458, 1, + 458, 1, 458, 1, 458, 3, 458, 11038, 8, 458, 1, 459, 1, 459, 1, 459, 1, + 459, 1, 459, 1, 459, 1, 459, 3, 459, 11047, 8, 459, 1, 459, 3, 459, 11050, + 8, 459, 1, 459, 3, 459, 11053, 8, 459, 1, 459, 1, 459, 1, 459, 1, 459, + 1, 459, 5, 459, 11060, 8, 459, 10, 459, 12, 459, 11063, 9, 459, 3, 459, + 11065, 8, 459, 1, 459, 3, 459, 11068, 8, 459, 1, 460, 1, 460, 1, 460, 1, + 460, 1, 460, 3, 460, 11075, 8, 460, 1, 460, 3, 460, 11078, 8, 460, 1, 460, + 1, 460, 1, 460, 1, 460, 1, 460, 3, 460, 11085, 8, 460, 1, 460, 1, 460, + 1, 460, 1, 460, 3, 460, 11091, 8, 460, 1, 460, 1, 460, 1, 460, 1, 460, + 3, 460, 11097, 8, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, + 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 3, 460, 11112, + 8, 460, 1, 460, 3, 460, 11115, 8, 460, 1, 460, 1, 460, 1, 460, 1, 460, + 1, 460, 3, 460, 11122, 8, 460, 1, 460, 1, 460, 1, 460, 1, 460, 5, 460, + 11128, 8, 460, 10, 460, 12, 460, 11131, 9, 460, 1, 460, 1, 460, 1, 460, + 1, 460, 3, 460, 11137, 8, 460, 1, 461, 1, 461, 1, 462, 1, 462, 3, 462, + 11143, 8, 462, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, + 1, 463, 1, 463, 3, 463, 11154, 8, 463, 1, 463, 1, 463, 1, 463, 1, 463, + 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 3, 463, + 11168, 8, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, + 1, 463, 5, 463, 11178, 8, 463, 10, 463, 12, 463, 11181, 9, 463, 1, 464, + 1, 464, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 466, 1, 466, 1, 466, + 1, 466, 3, 466, 11194, 8, 466, 1, 467, 1, 467, 1, 467, 4, 467, 11199, 8, + 467, 11, 467, 12, 467, 11200, 1, 467, 1, 467, 3, 467, 11205, 8, 467, 1, + 467, 1, 467, 1, 467, 1, 467, 4, 467, 11211, 8, 467, 11, 467, 12, 467, 11212, + 1, 467, 1, 467, 3, 467, 11217, 8, 467, 1, 467, 1, 467, 3, 467, 11221, 8, + 467, 1, 468, 1, 468, 1, 468, 1, 468, 3, 468, 11227, 8, 468, 1, 469, 1, + 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 3, 469, 11237, 8, + 469, 1, 470, 1, 470, 1, 471, 1, 471, 1, 471, 1, 471, 5, 471, 11245, 8, + 471, 10, 471, 12, 471, 11248, 9, 471, 1, 472, 1, 472, 1, 472, 1, 472, 1, + 472, 3, 472, 11255, 8, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, + 473, 1, 473, 1, 473, 1, 473, 1, 473, 3, 473, 11267, 8, 473, 1, 473, 1, + 473, 1, 473, 1, 473, 3, 473, 11273, 8, 473, 1, 473, 1, 473, 3, 473, 11277, + 8, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, + 3, 473, 11287, 8, 473, 1, 474, 1, 474, 3, 474, 11291, 8, 474, 1, 474, 1, + 474, 3, 474, 11295, 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, + 474, 1, 474, 1, 474, 3, 474, 11305, 8, 474, 1, 475, 1, 475, 5, 475, 11309, + 8, 475, 10, 475, 12, 475, 11312, 9, 475, 1, 475, 1, 475, 1, 475, 1, 475, + 1, 475, 3, 475, 11319, 8, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, + 1, 475, 5, 475, 11327, 8, 475, 10, 475, 12, 475, 11330, 9, 475, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 5, 476, 11355, 8, 476, 10, 476, 12, 476, + 11358, 9, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 5, 476, 11367, 8, 476, 10, 476, 12, 476, 11370, 9, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 3, 476, 11376, 8, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 5, 476, 11382, 8, 476, 10, 476, 12, 476, 11385, 9, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 3, 476, 11391, 8, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 3, 476, 11397, 8, 476, 1, 477, 1, 477, 3, 477, 11401, 8, 477, 1, 477, 5, + 477, 11404, 8, 477, 10, 477, 12, 477, 11407, 9, 477, 1, 477, 1, 477, 1, + 477, 1, 477, 1, 477, 3, 477, 11414, 8, 477, 1, 477, 3, 477, 11417, 8, 477, + 3, 477, 11419, 8, 477, 1, 478, 1, 478, 3, 478, 11423, 8, 478, 1, 478, 1, + 478, 3, 478, 11427, 8, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 3, + 478, 11434, 8, 478, 1, 479, 1, 479, 3, 479, 11438, 8, 479, 1, 479, 3, 479, + 11441, 8, 479, 1, 479, 1, 479, 1, 479, 3, 479, 11446, 8, 479, 1, 479, 3, + 479, 11449, 8, 479, 1, 479, 1, 479, 3, 479, 11453, 8, 479, 1, 479, 3, 479, + 11456, 8, 479, 1, 479, 3, 479, 11459, 8, 479, 1, 480, 1, 480, 1, 480, 3, + 480, 11464, 8, 480, 1, 480, 1, 480, 1, 480, 5, 480, 11469, 8, 480, 10, + 480, 12, 480, 11472, 9, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, + 480, 5, 480, 11480, 8, 480, 10, 480, 12, 480, 11483, 9, 480, 1, 480, 1, + 480, 3, 480, 11487, 8, 480, 1, 481, 1, 481, 1, 481, 1, 482, 1, 482, 1, + 482, 1, 483, 1, 483, 1, 483, 3, 483, 11498, 8, 483, 1, 483, 1, 483, 3, + 483, 11502, 8, 483, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 1, + 484, 3, 484, 11511, 8, 484, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 3, + 485, 11518, 8, 485, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 5, 486, 11525, + 8, 486, 10, 486, 12, 486, 11528, 9, 486, 1, 487, 1, 487, 1, 487, 1, 487, + 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 3, 487, 11540, 8, 487, + 3, 487, 11542, 8, 487, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, + 1, 488, 1, 488, 3, 488, 11552, 8, 488, 1, 488, 3, 488, 11555, 8, 488, 1, + 488, 5, 488, 11558, 8, 488, 10, 488, 12, 488, 11561, 9, 488, 1, 488, 1, + 488, 1, 488, 1, 488, 1, 488, 1, 488, 3, 488, 11569, 8, 488, 3, 488, 11571, + 8, 488, 3, 488, 11573, 8, 488, 1, 488, 1, 488, 1, 488, 3, 488, 11578, 8, + 488, 3, 488, 11580, 8, 488, 1, 488, 1, 488, 1, 488, 1, 488, 5, 488, 11586, + 8, 488, 10, 488, 12, 488, 11589, 9, 488, 1, 488, 1, 488, 3, 488, 11593, + 8, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 3, 488, 11601, + 8, 488, 1, 488, 5, 488, 11604, 8, 488, 10, 488, 12, 488, 11607, 9, 488, + 1, 488, 1, 488, 1, 488, 3, 488, 11612, 8, 488, 3, 488, 11614, 8, 488, 1, + 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, + 488, 3, 488, 11626, 8, 488, 5, 488, 11628, 8, 488, 10, 488, 12, 488, 11631, + 9, 488, 3, 488, 11633, 8, 488, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, + 1, 489, 1, 489, 1, 489, 3, 489, 11643, 8, 489, 3, 489, 11645, 8, 489, 1, + 490, 1, 490, 1, 490, 3, 490, 11650, 8, 490, 1, 491, 3, 491, 11653, 8, 491, + 1, 491, 1, 491, 1, 491, 5, 491, 11658, 8, 491, 10, 491, 12, 491, 11661, + 9, 491, 1, 491, 3, 491, 11664, 8, 491, 1, 491, 1, 491, 3, 491, 11668, 8, + 491, 1, 492, 1, 492, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 5, 493, 11677, + 8, 493, 10, 493, 12, 493, 11680, 9, 493, 1, 493, 1, 493, 1, 494, 1, 494, + 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, + 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, + 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 5, 494, 11711, + 8, 494, 10, 494, 12, 494, 11714, 9, 494, 1, 494, 1, 494, 1, 494, 1, 494, + 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, + 3, 494, 11729, 8, 494, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 3, 495, + 11736, 8, 495, 3, 495, 11738, 8, 495, 1, 496, 1, 496, 1, 496, 5, 496, 11743, + 8, 496, 10, 496, 12, 496, 11746, 9, 496, 1, 497, 1, 497, 1, 497, 1, 497, + 5, 497, 11752, 8, 497, 10, 497, 12, 497, 11755, 9, 497, 1, 497, 1, 497, + 1, 498, 1, 498, 1, 498, 3, 498, 11762, 8, 498, 1, 498, 1, 498, 1, 498, + 1, 498, 3, 498, 11768, 8, 498, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, + 3, 499, 11775, 8, 499, 1, 499, 1, 499, 1, 499, 1, 499, 3, 499, 11781, 8, + 499, 1, 499, 3, 499, 11784, 8, 499, 3, 499, 11786, 8, 499, 1, 500, 1, 500, + 1, 500, 1, 500, 1, 500, 1, 500, 3, 500, 11794, 8, 500, 3, 500, 11796, 8, + 500, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 3, 501, 11803, 8, 501, 1, + 501, 1, 501, 3, 501, 11807, 8, 501, 1, 502, 1, 502, 1, 502, 5, 502, 11812, + 8, 502, 10, 502, 12, 502, 11815, 9, 502, 1, 503, 1, 503, 5, 503, 11819, + 8, 503, 10, 503, 12, 503, 11822, 9, 503, 1, 504, 1, 504, 1, 504, 1, 504, + 1, 504, 1, 504, 3, 504, 11830, 8, 504, 1, 504, 1, 504, 1, 504, 3, 504, + 11835, 8, 504, 1, 504, 1, 504, 3, 504, 11839, 8, 504, 1, 504, 1, 504, 1, + 504, 1, 504, 1, 504, 3, 504, 11846, 8, 504, 3, 504, 11848, 8, 504, 1, 504, + 1, 504, 3, 504, 11852, 8, 504, 1, 504, 1, 504, 1, 504, 3, 504, 11857, 8, + 504, 3, 504, 11859, 8, 504, 1, 504, 1, 504, 1, 504, 3, 504, 11864, 8, 504, + 3, 504, 11866, 8, 504, 1, 504, 1, 504, 3, 504, 11870, 8, 504, 1, 504, 1, + 504, 1, 504, 1, 504, 1, 504, 3, 504, 11877, 8, 504, 3, 504, 11879, 8, 504, + 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 11886, 8, 504, 1, 504, + 1, 504, 1, 504, 1, 504, 3, 504, 11892, 8, 504, 1, 505, 1, 505, 1, 505, + 1, 505, 1, 505, 1, 505, 1, 505, 3, 505, 11901, 8, 505, 1, 505, 1, 505, + 1, 505, 1, 505, 1, 505, 1, 505, 3, 505, 11909, 8, 505, 1, 505, 3, 505, + 11912, 8, 505, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 3, 506, 11919, 8, + 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 3, 506, 11927, 8, + 506, 1, 506, 3, 506, 11930, 8, 506, 1, 507, 1, 507, 1, 507, 5, 507, 11935, + 8, 507, 10, 507, 12, 507, 11938, 9, 507, 1, 508, 1, 508, 1, 508, 3, 508, + 11943, 8, 508, 1, 509, 1, 509, 1, 509, 5, 509, 11948, 8, 509, 10, 509, + 12, 509, 11951, 9, 509, 1, 510, 1, 510, 1, 510, 3, 510, 11956, 8, 510, + 1, 511, 1, 511, 3, 511, 11960, 8, 511, 1, 512, 1, 512, 1, 512, 1, 512, + 1, 512, 1, 512, 1, 512, 1, 512, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, + 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 514, 1, 514, 1, 514, 1, 514, + 1, 514, 3, 514, 11985, 8, 514, 1, 515, 3, 515, 11988, 8, 515, 1, 515, 1, + 515, 3, 515, 11992, 8, 515, 3, 515, 11994, 8, 515, 1, 515, 3, 515, 11997, + 8, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 516, 1, 516, 1, 516, + 1, 516, 1, 517, 1, 517, 1, 517, 1, 517, 1, 518, 1, 518, 1, 518, 1, 518, + 1, 519, 1, 519, 1, 519, 1, 519, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, + 1, 520, 1, 520, 1, 520, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, + 1, 521, 1, 521, 1, 521, 1, 521, 1, 522, 1, 522, 1, 522, 5, 522, 12041, + 8, 522, 10, 522, 12, 522, 12044, 9, 522, 1, 523, 1, 523, 1, 523, 1, 523, + 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, + 1, 523, 1, 523, 1, 523, 5, 523, 12062, 8, 523, 10, 523, 12, 523, 12065, + 9, 523, 1, 523, 3, 523, 12068, 8, 523, 1, 523, 1, 523, 3, 523, 12072, 8, + 523, 1, 524, 1, 524, 1, 524, 1, 524, 1, 525, 1, 525, 1, 525, 1, 525, 1, + 525, 1, 525, 5, 525, 12084, 8, 525, 10, 525, 12, 525, 12087, 9, 525, 1, + 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 3, 525, 12096, 8, + 525, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 3, 526, 12105, + 8, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 3, 526, 12112, 8, 526, + 1, 527, 1, 527, 1, 527, 3, 527, 12117, 8, 527, 1, 527, 1, 527, 1, 527, + 1, 527, 1, 527, 1, 527, 1, 527, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, + 1, 528, 1, 528, 1, 528, 1, 528, 5, 528, 12135, 8, 528, 10, 528, 12, 528, + 12138, 9, 528, 1, 528, 1, 528, 1, 528, 3, 528, 12143, 8, 528, 1, 528, 1, + 528, 1, 528, 1, 528, 1, 528, 3, 528, 12150, 8, 528, 1, 528, 1, 528, 3, + 528, 12154, 8, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, + 528, 1, 528, 1, 528, 1, 528, 1, 528, 5, 528, 12167, 8, 528, 10, 528, 12, + 528, 12170, 9, 528, 1, 528, 1, 528, 1, 528, 3, 528, 12175, 8, 528, 1, 528, + 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, + 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 3, 528, 12194, + 8, 528, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 5, 529, + 12203, 8, 529, 10, 529, 12, 529, 12206, 9, 529, 1, 529, 1, 529, 1, 529, + 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 3, 529, 12218, + 8, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, + 1, 529, 3, 529, 12229, 8, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, + 5, 529, 12236, 8, 529, 10, 529, 12, 529, 12239, 9, 529, 1, 529, 1, 529, + 1, 529, 3, 529, 12244, 8, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, + 3, 529, 12251, 8, 529, 1, 529, 1, 529, 3, 529, 12255, 8, 529, 1, 530, 1, + 530, 1, 530, 1, 530, 1, 531, 1, 531, 1, 531, 1, 531, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 12328, 8, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 12334, 8, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 12433, 8, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 3, 532, 12445, 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 3, 532, 12454, 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 3, 532, 12463, 8, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 12494, + 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 12500, 8, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 12552, 8, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 5, 532, 12563, + 8, 532, 10, 532, 12, 532, 12566, 9, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 5, 532, 12579, + 8, 532, 10, 532, 12, 532, 12582, 9, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 3, 532, 12600, 8, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 3, 532, 12643, 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 3, 532, 12697, 8, 532, 3, 532, 12699, 8, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 12715, 8, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 3, 532, 12758, 8, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 5, 532, 12779, + 8, 532, 10, 532, 12, 532, 12782, 9, 532, 3, 532, 12784, 8, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 5, 532, 12793, 8, 532, + 10, 532, 12, 532, 12796, 9, 532, 3, 532, 12798, 8, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 3, 532, 12847, 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 5, 532, 12853, 8, + 532, 10, 532, 12, 532, 12856, 9, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 3, 532, 12866, 8, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 3, 532, 12927, 8, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, + 532, 12977, 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 3, 532, 13007, 8, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, + 532, 13137, 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13216, + 8, 532, 1, 532, 1, 532, 3, 532, 13220, 8, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13241, + 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 3, 532, 13260, 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 5, 532, 13269, 8, 532, 10, 532, 12, 532, 13272, 9, 532, 3, 532, + 13274, 8, 532, 1, 532, 3, 532, 13277, 8, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 3, 532, 13283, 8, 532, 1, 532, 3, 532, 13286, 8, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 3, 532, 13301, 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13383, 8, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13410, 8, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13420, + 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13471, 8, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13479, 8, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13498, + 8, 532, 3, 532, 13500, 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13514, + 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, + 13523, 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 3, 532, 13542, 8, 532, 3, 532, 13544, 8, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 3, 532, 13559, 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13572, 8, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13578, 8, 532, 1, 532, 1, + 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13586, 8, 532, 3, 532, 13588, + 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13594, 8, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 13602, 8, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 3, 532, 13608, 8, 532, 1, 532, 3, 532, 13611, 8, + 532, 1, 533, 1, 533, 1, 533, 1, 533, 3, 533, 13617, 8, 533, 1, 534, 1, + 534, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 3, 535, 13628, + 8, 535, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 3, 536, + 13637, 8, 536, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, + 3, 537, 13646, 8, 537, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, + 1, 538, 1, 538, 1, 538, 1, 538, 3, 538, 13658, 8, 538, 1, 538, 1, 538, + 1, 538, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 540, + 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 3, 540, 13676, 8, 540, 1, 540, + 1, 540, 1, 540, 1, 541, 1, 541, 1, 541, 1, 541, 1, 541, 1, 542, 1, 542, + 1, 542, 1, 542, 1, 542, 1, 542, 3, 542, 13692, 8, 542, 1, 542, 1, 542, + 1, 542, 1, 543, 1, 543, 1, 543, 1, 543, 1, 543, 1, 544, 1, 544, 1, 544, + 1, 544, 1, 544, 1, 544, 3, 544, 13708, 8, 544, 1, 544, 1, 544, 1, 544, + 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 546, 1, 546, 1, 546, 1, 546, + 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, + 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, + 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 3, 546, + 13748, 8, 546, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, + 1, 547, 1, 547, 1, 547, 3, 547, 13760, 8, 547, 1, 548, 1, 548, 1, 548, + 1, 548, 1, 548, 1, 548, 3, 548, 13768, 8, 548, 1, 548, 1, 548, 1, 548, + 1, 548, 1, 548, 1, 548, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 550, + 1, 550, 1, 550, 1, 550, 1, 550, 1, 551, 3, 551, 13787, 8, 551, 1, 551, + 1, 551, 1, 552, 3, 552, 13792, 8, 552, 1, 552, 1, 552, 1, 553, 1, 553, + 1, 554, 1, 554, 1, 554, 1, 554, 3, 554, 13802, 8, 554, 1, 554, 5, 554, + 13805, 8, 554, 10, 554, 12, 554, 13808, 9, 554, 1, 554, 1, 554, 1, 555, + 1, 555, 1, 555, 1, 555, 1, 556, 4, 556, 13817, 8, 556, 11, 556, 12, 556, + 13818, 1, 557, 1, 557, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, + 5, 558, 13829, 8, 558, 10, 558, 12, 558, 13832, 9, 558, 1, 558, 1, 558, + 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 3, 558, 13843, + 8, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, + 3, 558, 13853, 8, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, + 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, + 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, + 3, 558, 13879, 8, 558, 1, 559, 1, 559, 3, 559, 13883, 8, 559, 1, 560, 1, + 560, 1, 560, 1, 560, 5, 560, 13889, 8, 560, 10, 560, 12, 560, 13892, 9, + 560, 1, 560, 1, 560, 1, 561, 1, 561, 3, 561, 13898, 8, 561, 1, 562, 1, + 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 5, 562, 13909, + 8, 562, 10, 562, 12, 562, 13912, 9, 562, 1, 563, 1, 563, 1, 563, 5, 563, + 13917, 8, 563, 10, 563, 12, 563, 13920, 9, 563, 1, 564, 1, 564, 1, 564, + 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 3, 564, 13932, + 8, 564, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 3, 565, 13939, 8, 565, + 1, 565, 1, 565, 1, 565, 1, 565, 3, 565, 13945, 8, 565, 1, 565, 1, 565, + 3, 565, 13949, 8, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, + 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, + 3, 565, 13966, 8, 565, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, + 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 3, 566, 13981, + 8, 566, 3, 566, 13983, 8, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, + 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 3, 566, 13996, 8, 566, + 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, + 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 3, 566, + 14015, 8, 566, 1, 566, 1, 566, 3, 566, 14019, 8, 566, 1, 567, 3, 567, 14022, + 8, 567, 1, 567, 1, 567, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 3, 568, + 14031, 8, 568, 1, 568, 3, 568, 14034, 8, 568, 1, 568, 3, 568, 14037, 8, + 568, 1, 568, 1, 568, 1, 569, 1, 569, 1, 569, 1, 570, 1, 570, 1, 570, 1, + 570, 1, 570, 1, 570, 3, 570, 14050, 8, 570, 1, 571, 1, 571, 3, 571, 14054, + 8, 571, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 3, 572, 14062, + 8, 572, 1, 573, 1, 573, 1, 573, 1, 573, 3, 573, 14068, 8, 573, 1, 574, + 1, 574, 1, 574, 1, 574, 5, 574, 14074, 8, 574, 10, 574, 12, 574, 14077, + 9, 574, 1, 574, 1, 574, 1, 574, 1, 574, 3, 574, 14083, 8, 574, 1, 574, + 1, 574, 1, 574, 1, 574, 3, 574, 14089, 8, 574, 1, 574, 1, 574, 1, 574, + 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, + 1, 574, 3, 574, 14104, 8, 574, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, + 1, 575, 1, 575, 3, 575, 14113, 8, 575, 1, 575, 1, 575, 1, 576, 1, 576, + 3, 576, 14119, 8, 576, 1, 577, 1, 577, 1, 577, 1, 577, 3, 577, 14125, 8, + 577, 1, 577, 3, 577, 14128, 8, 577, 1, 577, 1, 577, 3, 577, 14132, 8, 577, + 1, 577, 1, 577, 1, 577, 5, 577, 14137, 8, 577, 10, 577, 12, 577, 14140, + 9, 577, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 3, 578, 14147, 8, 578, + 1, 578, 3, 578, 14150, 8, 578, 1, 578, 1, 578, 1, 578, 1, 578, 3, 578, + 14156, 8, 578, 1, 578, 1, 578, 1, 578, 1, 578, 3, 578, 14162, 8, 578, 3, + 578, 14164, 8, 578, 1, 578, 1, 578, 1, 578, 1, 578, 3, 578, 14170, 8, 578, + 1, 578, 3, 578, 14173, 8, 578, 3, 578, 14175, 8, 578, 1, 578, 1, 578, 1, + 578, 1, 578, 3, 578, 14181, 8, 578, 3, 578, 14183, 8, 578, 1, 578, 1, 578, + 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, + 1, 579, 3, 579, 14197, 8, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, + 3, 579, 14204, 8, 579, 1, 579, 1, 579, 1, 580, 1, 580, 1, 580, 1, 580, + 1, 580, 3, 580, 14213, 8, 580, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, + 3, 581, 14220, 8, 581, 1, 582, 1, 582, 4, 582, 14224, 8, 582, 11, 582, + 12, 582, 14225, 1, 582, 1, 582, 3, 582, 14230, 8, 582, 3, 582, 14232, 8, + 582, 1, 583, 1, 583, 1, 583, 1, 584, 1, 584, 1, 584, 1, 584, 1, 585, 1, + 585, 1, 585, 3, 585, 14244, 8, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, + 585, 3, 585, 14251, 8, 585, 1, 585, 1, 585, 3, 585, 14255, 8, 585, 1, 586, + 1, 586, 1, 586, 3, 586, 14260, 8, 586, 1, 586, 1, 586, 1, 587, 1, 587, + 1, 587, 3, 587, 14267, 8, 587, 1, 587, 1, 587, 1, 588, 3, 588, 14272, 8, + 588, 1, 588, 1, 588, 3, 588, 14276, 8, 588, 1, 588, 1, 588, 1, 588, 3, + 588, 14281, 8, 588, 1, 589, 3, 589, 14284, 8, 589, 1, 589, 1, 589, 3, 589, + 14288, 8, 589, 1, 589, 1, 589, 3, 589, 14292, 8, 589, 1, 589, 1, 589, 1, + 589, 3, 589, 14297, 8, 589, 1, 590, 1, 590, 3, 590, 14301, 8, 590, 1, 591, + 1, 591, 1, 591, 1, 591, 3, 591, 14307, 8, 591, 1, 591, 1, 591, 1, 591, + 1, 591, 1, 591, 3, 591, 14314, 8, 591, 1, 591, 1, 591, 1, 591, 3, 591, + 14319, 8, 591, 3, 591, 14321, 8, 591, 1, 592, 1, 592, 1, 592, 5, 592, 14326, + 8, 592, 10, 592, 12, 592, 14329, 9, 592, 1, 593, 1, 593, 3, 593, 14333, + 8, 593, 1, 594, 1, 594, 1, 594, 5, 594, 14338, 8, 594, 10, 594, 12, 594, + 14341, 9, 594, 1, 595, 3, 595, 14344, 8, 595, 1, 595, 5, 595, 14347, 8, + 595, 10, 595, 12, 595, 14350, 9, 595, 1, 595, 1, 595, 1, 596, 1, 596, 1, + 596, 5, 596, 14357, 8, 596, 10, 596, 12, 596, 14360, 9, 596, 1, 597, 1, + 597, 3, 597, 14364, 8, 597, 1, 598, 1, 598, 1, 599, 1, 599, 1, 600, 3, + 600, 14371, 8, 600, 1, 600, 1, 600, 1, 601, 1, 601, 1, 601, 1, 601, 1, + 601, 3, 601, 14380, 8, 601, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, + 602, 1, 602, 1, 602, 1, 602, 1, 602, 3, 602, 14392, 8, 602, 1, 603, 1, + 603, 1, 603, 3, 603, 14397, 8, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, + 603, 1, 603, 1, 603, 1, 603, 1, 603, 3, 603, 14408, 8, 603, 1, 603, 1, + 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 3, 603, 14418, 8, + 603, 3, 603, 14420, 8, 603, 1, 603, 1, 603, 1, 603, 1, 603, 3, 603, 14426, + 8, 603, 3, 603, 14428, 8, 603, 1, 603, 1, 603, 1, 603, 3, 603, 14433, 8, + 603, 3, 603, 14435, 8, 603, 1, 603, 3, 603, 14438, 8, 603, 1, 604, 1, 604, + 3, 604, 14442, 8, 604, 1, 605, 1, 605, 3, 605, 14446, 8, 605, 1, 606, 1, + 606, 1, 606, 1, 606, 3, 606, 14452, 8, 606, 1, 606, 1, 606, 1, 606, 1, + 606, 1, 606, 1, 606, 1, 606, 3, 606, 14461, 8, 606, 1, 606, 3, 606, 14464, + 8, 606, 3, 606, 14466, 8, 606, 1, 607, 3, 607, 14469, 8, 607, 1, 607, 1, + 607, 1, 607, 1, 607, 3, 607, 14475, 8, 607, 1, 607, 1, 607, 3, 607, 14479, + 8, 607, 1, 607, 3, 607, 14482, 8, 607, 1, 608, 1, 608, 1, 608, 1, 608, + 1, 608, 1, 608, 1, 608, 3, 608, 14491, 8, 608, 1, 609, 1, 609, 1, 609, + 1, 609, 1, 609, 1, 609, 1, 609, 3, 609, 14500, 8, 609, 1, 610, 1, 610, + 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 3, 610, + 14512, 8, 610, 1, 610, 3, 610, 14515, 8, 610, 1, 611, 1, 611, 1, 611, 1, + 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, + 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, + 611, 1, 611, 3, 611, 14540, 8, 611, 1, 611, 1, 611, 3, 611, 14544, 8, 611, + 1, 611, 1, 611, 3, 611, 14548, 8, 611, 1, 612, 1, 612, 1, 612, 3, 612, + 14553, 8, 612, 1, 612, 1, 612, 3, 612, 14557, 8, 612, 1, 612, 1, 612, 3, + 612, 14561, 8, 612, 1, 612, 1, 612, 3, 612, 14565, 8, 612, 1, 613, 1, 613, + 1, 613, 1, 613, 1, 613, 3, 613, 14572, 8, 613, 1, 613, 1, 613, 3, 613, + 14576, 8, 613, 1, 614, 1, 614, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, + 1, 615, 1, 615, 3, 615, 14587, 8, 615, 1, 616, 1, 616, 1, 617, 1, 617, + 3, 617, 14593, 8, 617, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, + 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, + 3, 618, 14610, 8, 618, 1, 619, 1, 619, 1, 620, 1, 620, 3, 620, 14616, 8, + 620, 1, 620, 0, 3, 94, 926, 950, 621, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, + 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, + 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, + 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, + 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, + 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, + 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, + 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, + 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, + 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, + 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, + 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, + 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, + 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, + 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, + 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, + 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, + 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, + 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, + 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, + 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, + 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, 658, 660, + 662, 664, 666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, 688, 690, + 692, 694, 696, 698, 700, 702, 704, 706, 708, 710, 712, 714, 716, 718, 720, + 722, 724, 726, 728, 730, 732, 734, 736, 738, 740, 742, 744, 746, 748, 750, + 752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776, 778, 780, + 782, 784, 786, 788, 790, 792, 794, 796, 798, 800, 802, 804, 806, 808, 810, + 812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834, 836, 838, 840, + 842, 844, 846, 848, 850, 852, 854, 856, 858, 860, 862, 864, 866, 868, 870, + 872, 874, 876, 878, 880, 882, 884, 886, 888, 890, 892, 894, 896, 898, 900, + 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922, 924, 926, 928, 930, + 932, 934, 936, 938, 940, 942, 944, 946, 948, 950, 952, 954, 956, 958, 960, + 962, 964, 966, 968, 970, 972, 974, 976, 978, 980, 982, 984, 986, 988, 990, + 992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014, 1016, + 1018, 1020, 1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 1038, 1040, + 1042, 1044, 1046, 1048, 1050, 1052, 1054, 1056, 1058, 1060, 1062, 1064, + 1066, 1068, 1070, 1072, 1074, 1076, 1078, 1080, 1082, 1084, 1086, 1088, + 1090, 1092, 1094, 1096, 1098, 1100, 1102, 1104, 1106, 1108, 1110, 1112, + 1114, 1116, 1118, 1120, 1122, 1124, 1126, 1128, 1130, 1132, 1134, 1136, + 1138, 1140, 1142, 1144, 1146, 1148, 1150, 1152, 1154, 1156, 1158, 1160, + 1162, 1164, 1166, 1168, 1170, 1172, 1174, 1176, 1178, 1180, 1182, 1184, + 1186, 1188, 1190, 1192, 1194, 1196, 1198, 1200, 1202, 1204, 1206, 1208, + 1210, 1212, 1214, 1216, 1218, 1220, 1222, 1224, 1226, 1228, 1230, 1232, + 1234, 1236, 1238, 1240, 0, 177, 2, 0, 1180, 1180, 1182, 1182, 2, 0, 1180, + 1180, 1184, 1184, 2, 0, 252, 252, 996, 997, 3, 0, 1180, 1180, 1182, 1182, + 1184, 1184, 3, 0, 536, 536, 631, 631, 901, 901, 3, 0, 1176, 1176, 1180, + 1180, 1184, 1184, 3, 0, 332, 332, 852, 852, 1040, 1040, 1, 0, 1184, 1185, + 1, 0, 845, 849, 2, 0, 200, 200, 672, 672, 2, 0, 648, 648, 857, 857, 3, + 0, 219, 219, 648, 648, 857, 857, 2, 0, 297, 297, 547, 547, 3, 0, 219, 219, + 648, 648, 889, 889, 2, 0, 386, 386, 861, 861, 2, 0, 219, 219, 889, 889, + 3, 0, 621, 621, 730, 730, 868, 869, 2, 0, 656, 656, 662, 662, 2, 0, 62, + 62, 976, 976, 2, 0, 73, 73, 543, 543, 2, 0, 22, 22, 778, 778, 3, 0, 22, + 22, 609, 609, 776, 776, 2, 0, 35, 35, 199, 199, 2, 0, 11, 11, 282, 282, + 2, 0, 317, 317, 905, 905, 2, 0, 270, 270, 292, 292, 3, 0, 271, 271, 940, + 940, 957, 957, 2, 0, 271, 271, 293, 293, 3, 0, 22, 22, 702, 702, 1081, + 1081, 3, 0, 271, 271, 808, 808, 968, 968, 3, 0, 497, 497, 600, 600, 641, + 641, 2, 0, 1182, 1182, 1184, 1184, 2, 0, 492, 492, 570, 570, 3, 0, 26, + 26, 29, 29, 634, 634, 3, 0, 621, 621, 716, 716, 718, 718, 2, 0, 939, 939, + 955, 955, 2, 0, 37, 37, 678, 678, 2, 0, 11, 11, 900, 900, 2, 0, 523, 523, + 1076, 1076, 2, 0, 751, 751, 758, 758, 2, 0, 1182, 1182, 1184, 1185, 2, + 0, 596, 596, 1037, 1037, 2, 0, 577, 577, 932, 932, 2, 0, 270, 270, 783, + 783, 7, 0, 254, 254, 320, 320, 466, 466, 781, 781, 786, 786, 878, 878, + 1042, 1042, 3, 0, 648, 648, 857, 857, 980, 980, 2, 0, 257, 257, 410, 410, + 4, 0, 254, 254, 466, 466, 878, 878, 1042, 1042, 2, 0, 98, 98, 360, 360, + 2, 0, 466, 466, 1042, 1042, 2, 0, 254, 254, 1042, 1042, 3, 0, 387, 387, + 570, 570, 989, 989, 2, 0, 1036, 1036, 1182, 1182, 3, 0, 186, 186, 338, + 338, 913, 913, 2, 0, 245, 245, 1184, 1184, 2, 0, 245, 245, 1182, 1182, + 2, 0, 531, 531, 1184, 1184, 3, 0, 387, 387, 492, 492, 570, 570, 2, 0, 365, + 365, 380, 380, 3, 0, 427, 427, 540, 540, 573, 573, 2, 0, 511, 511, 830, + 830, 3, 0, 46, 46, 462, 462, 987, 987, 2, 0, 621, 621, 699, 699, 2, 0, + 390, 391, 393, 394, 2, 0, 1182, 1182, 1186, 1187, 4, 0, 158, 159, 621, + 621, 690, 690, 837, 837, 1, 0, 158, 159, 3, 0, 704, 704, 745, 745, 1055, + 1055, 2, 0, 35, 35, 801, 801, 2, 0, 739, 739, 741, 741, 3, 0, 254, 254, + 466, 466, 1042, 1042, 2, 0, 19, 19, 365, 365, 3, 0, 682, 682, 684, 684, + 770, 770, 2, 0, 708, 708, 843, 843, 2, 0, 57, 57, 260, 260, 3, 0, 621, + 621, 690, 690, 837, 837, 3, 0, 297, 297, 858, 858, 1067, 1067, 3, 0, 69, + 69, 270, 270, 980, 980, 2, 0, 133, 133, 610, 610, 3, 0, 99, 99, 621, 621, + 879, 879, 4, 0, 770, 770, 774, 774, 776, 776, 778, 778, 3, 0, 233, 233, + 432, 432, 582, 582, 2, 0, 406, 406, 531, 531, 2, 0, 381, 381, 656, 656, + 3, 0, 290, 290, 657, 657, 663, 663, 2, 0, 776, 776, 778, 778, 3, 0, 595, + 595, 819, 819, 917, 917, 3, 0, 23, 23, 271, 271, 367, 367, 2, 0, 821, 821, + 973, 973, 2, 0, 367, 367, 916, 916, 3, 0, 110, 110, 381, 381, 916, 916, + 3, 0, 140, 140, 621, 621, 1002, 1002, 2, 0, 582, 582, 871, 871, 1, 0, 343, + 344, 3, 0, 273, 273, 986, 986, 1046, 1046, 2, 0, 168, 168, 633, 633, 2, + 0, 461, 461, 618, 618, 2, 0, 626, 626, 919, 919, 2, 0, 374, 374, 615, 615, + 2, 0, 140, 140, 632, 632, 2, 0, 187, 187, 958, 958, 2, 0, 625, 625, 829, + 829, 2, 0, 529, 529, 630, 630, 2, 0, 15, 17, 1016, 1016, 2, 0, 537, 537, + 1049, 1049, 2, 0, 682, 682, 684, 684, 2, 0, 343, 343, 1185, 1185, 2, 0, + 244, 244, 297, 297, 2, 0, 327, 327, 942, 942, 5, 0, 15, 17, 259, 259, 262, + 262, 764, 766, 1015, 1016, 2, 0, 628, 628, 895, 895, 2, 0, 64, 64, 832, + 832, 2, 0, 219, 219, 536, 536, 1, 0, 1007, 1008, 4, 0, 32, 32, 312, 312, + 635, 635, 983, 983, 1, 0, 796, 798, 2, 0, 31, 32, 635, 635, 2, 0, 617, + 617, 796, 798, 4, 0, 86, 86, 636, 637, 892, 892, 1063, 1063, 4, 0, 33, + 34, 340, 340, 635, 635, 981, 981, 4, 0, 114, 114, 687, 687, 879, 879, 1184, + 1184, 2, 0, 151, 151, 620, 620, 2, 0, 183, 183, 277, 277, 3, 0, 837, 837, + 887, 887, 1009, 1009, 2, 0, 299, 299, 939, 939, 2, 0, 263, 263, 760, 760, + 2, 0, 56, 56, 171, 171, 2, 0, 465, 465, 883, 883, 2, 0, 376, 376, 865, + 865, 4, 0, 287, 287, 341, 341, 500, 500, 944, 944, 3, 0, 674, 674, 776, + 776, 866, 866, 2, 0, 4, 4, 790, 790, 4, 0, 472, 472, 744, 744, 996, 996, + 1088, 1088, 16, 0, 39, 40, 42, 45, 54, 55, 173, 173, 214, 214, 363, 363, + 368, 368, 449, 449, 611, 611, 613, 613, 647, 647, 698, 698, 756, 756, 792, + 792, 909, 911, 1085, 1085, 1, 0, 1212, 1214, 3, 0, 1200, 1200, 1215, 1216, + 1218, 1220, 1, 0, 1215, 1216, 3, 0, 22, 22, 46, 46, 923, 923, 2, 0, 22, + 22, 274, 274, 2, 0, 837, 837, 843, 843, 2, 0, 361, 361, 608, 608, 2, 0, + 3, 3, 1093, 1093, 2, 0, 69, 69, 704, 704, 2, 0, 417, 417, 679, 679, 3, + 0, 172, 172, 417, 417, 577, 577, 3, 0, 417, 417, 539, 539, 577, 577, 2, + 0, 255, 255, 467, 467, 3, 0, 643, 643, 1180, 1180, 1182, 1182, 3, 0, 381, + 381, 511, 511, 830, 830, 4, 0, 417, 417, 539, 539, 577, 577, 791, 791, + 2, 0, 203, 203, 683, 683, 2, 0, 182, 182, 379, 379, 2, 0, 880, 880, 882, + 882, 2, 0, 3, 3, 643, 643, 6, 0, 1126, 1126, 1129, 1129, 1137, 1138, 1140, + 1144, 1150, 1152, 1154, 1159, 2, 0, 1055, 1055, 1057, 1057, 1, 0, 752, + 753, 2, 0, 321, 321, 323, 323, 1, 0, 592, 593, 4, 0, 428, 428, 616, 616, + 771, 771, 906, 906, 3, 0, 256, 256, 762, 762, 844, 844, 7, 0, 83, 83, 550, + 550, 581, 581, 953, 954, 967, 967, 1058, 1058, 1060, 1060, 2, 0, 195, 195, + 197, 197, 2, 0, 362, 362, 508, 508, 2, 0, 505, 505, 509, 509, 2, 0, 205, + 205, 711, 711, 1, 0, 709, 710, 2, 0, 761, 761, 843, 843, 3, 0, 381, 381, + 656, 656, 776, 776, 2, 0, 433, 433, 840, 840, 1, 0, 788, 789, 4, 0, 95, + 95, 1059, 1059, 1166, 1167, 1179, 1179, 2, 0, 389, 389, 392, 392, 2, 0, + 1182, 1182, 1186, 1186, 150, 0, 1, 4, 6, 21, 23, 34, 36, 36, 38, 45, 47, + 55, 58, 67, 69, 83, 86, 89, 91, 91, 93, 101, 104, 105, 107, 108, 110, 110, + 112, 115, 118, 120, 122, 132, 134, 138, 140, 148, 150, 150, 154, 154, 156, + 163, 165, 170, 172, 178, 180, 180, 183, 185, 187, 191, 193, 198, 200, 202, + 204, 205, 208, 208, 211, 211, 214, 218, 220, 240, 243, 244, 246, 253, 255, + 256, 258, 259, 261, 272, 276, 277, 283, 285, 287, 288, 290, 298, 300, 301, + 303, 310, 312, 315, 317, 319, 321, 321, 323, 323, 325, 330, 332, 341, 344, + 358, 360, 364, 366, 372, 374, 377, 382, 385, 387, 388, 395, 395, 397, 407, + 409, 409, 411, 411, 413, 420, 422, 427, 429, 432, 436, 439, 441, 450, 452, + 455, 457, 462, 464, 465, 467, 469, 472, 473, 475, 483, 485, 497, 499, 503, + 505, 510, 512, 513, 518, 519, 522, 528, 530, 576, 578, 597, 599, 599, 601, + 609, 611, 615, 617, 619, 621, 626, 628, 641, 644, 654, 657, 658, 660, 661, + 663, 665, 668, 668, 672, 676, 680, 682, 684, 684, 686, 695, 697, 707, 709, + 719, 722, 729, 731, 731, 733, 738, 740, 740, 742, 747, 749, 758, 760, 762, + 764, 766, 768, 771, 773, 782, 784, 785, 787, 803, 805, 816, 819, 823, 825, + 826, 829, 829, 831, 832, 834, 837, 839, 840, 842, 850, 852, 854, 856, 856, + 858, 874, 876, 877, 879, 879, 883, 898, 901, 901, 903, 903, 905, 912, 914, + 922, 924, 928, 930, 944, 946, 978, 981, 981, 983, 991, 994, 999, 1002, + 1006, 1009, 1012, 1014, 1016, 1018, 1020, 1022, 1032, 1035, 1038, 1040, + 1041, 1044, 1046, 1048, 1048, 1050, 1055, 1057, 1060, 1062, 1064, 1066, + 1069, 1071, 1072, 1076, 1076, 1079, 1083, 1085, 1167, 1, 0, 1192, 1199, + 5, 0, 387, 387, 492, 492, 570, 570, 989, 989, 1214, 1214, 17075, 0, 1264, + 1, 0, 0, 0, 2, 1279, 1, 0, 0, 0, 4, 1285, 1, 0, 0, 0, 6, 1312, 1, 0, 0, + 0, 8, 1319, 1, 0, 0, 0, 10, 1487, 1, 0, 0, 0, 12, 1494, 1, 0, 0, 0, 14, + 1508, 1, 0, 0, 0, 16, 1510, 1, 0, 0, 0, 18, 1524, 1, 0, 0, 0, 20, 1528, + 1, 0, 0, 0, 22, 1542, 1, 0, 0, 0, 24, 1544, 1, 0, 0, 0, 26, 1551, 1, 0, + 0, 0, 28, 1561, 1, 0, 0, 0, 30, 1573, 1, 0, 0, 0, 32, 1575, 1, 0, 0, 0, + 34, 1577, 1, 0, 0, 0, 36, 1579, 1, 0, 0, 0, 38, 1610, 1, 0, 0, 0, 40, 1627, + 1, 0, 0, 0, 42, 1640, 1, 0, 0, 0, 44, 1690, 1, 0, 0, 0, 46, 1692, 1, 0, + 0, 0, 48, 1711, 1, 0, 0, 0, 50, 1713, 1, 0, 0, 0, 52, 1742, 1, 0, 0, 0, + 54, 1755, 1, 0, 0, 0, 56, 1776, 1, 0, 0, 0, 58, 1789, 1, 0, 0, 0, 60, 1794, + 1, 0, 0, 0, 62, 1798, 1, 0, 0, 0, 64, 1802, 1, 0, 0, 0, 66, 1813, 1, 0, + 0, 0, 68, 1818, 1, 0, 0, 0, 70, 1820, 1, 0, 0, 0, 72, 1825, 1, 0, 0, 0, + 74, 1827, 1, 0, 0, 0, 76, 1829, 1, 0, 0, 0, 78, 1832, 1, 0, 0, 0, 80, 1836, + 1, 0, 0, 0, 82, 1842, 1, 0, 0, 0, 84, 1844, 1, 0, 0, 0, 86, 1847, 1, 0, + 0, 0, 88, 1849, 1, 0, 0, 0, 90, 1852, 1, 0, 0, 0, 92, 1857, 1, 0, 0, 0, + 94, 1868, 1, 0, 0, 0, 96, 1877, 1, 0, 0, 0, 98, 1881, 1, 0, 0, 0, 100, + 1883, 1, 0, 0, 0, 102, 1889, 1, 0, 0, 0, 104, 1891, 1, 0, 0, 0, 106, 1893, + 1, 0, 0, 0, 108, 1896, 1, 0, 0, 0, 110, 1904, 1, 0, 0, 0, 112, 1906, 1, + 0, 0, 0, 114, 1908, 1, 0, 0, 0, 116, 1930, 1, 0, 0, 0, 118, 1949, 1, 0, + 0, 0, 120, 1957, 1, 0, 0, 0, 122, 1961, 1, 0, 0, 0, 124, 1969, 1, 0, 0, + 0, 126, 1984, 1, 0, 0, 0, 128, 1986, 1, 0, 0, 0, 130, 2030, 1, 0, 0, 0, + 132, 2039, 1, 0, 0, 0, 134, 2052, 1, 0, 0, 0, 136, 2054, 1, 0, 0, 0, 138, + 2056, 1, 0, 0, 0, 140, 2058, 1, 0, 0, 0, 142, 2062, 1, 0, 0, 0, 144, 2072, + 1, 0, 0, 0, 146, 2082, 1, 0, 0, 0, 148, 2126, 1, 0, 0, 0, 150, 2149, 1, + 0, 0, 0, 152, 2151, 1, 0, 0, 0, 154, 2153, 1, 0, 0, 0, 156, 2246, 1, 0, + 0, 0, 158, 2248, 1, 0, 0, 0, 160, 2253, 1, 0, 0, 0, 162, 2256, 1, 0, 0, + 0, 164, 2616, 1, 0, 0, 0, 166, 2618, 1, 0, 0, 0, 168, 2620, 1, 0, 0, 0, + 170, 2622, 1, 0, 0, 0, 172, 2676, 1, 0, 0, 0, 174, 2681, 1, 0, 0, 0, 176, + 2725, 1, 0, 0, 0, 178, 2748, 1, 0, 0, 0, 180, 2778, 1, 0, 0, 0, 182, 2782, + 1, 0, 0, 0, 184, 2788, 1, 0, 0, 0, 186, 2794, 1, 0, 0, 0, 188, 2798, 1, + 0, 0, 0, 190, 2802, 1, 0, 0, 0, 192, 2807, 1, 0, 0, 0, 194, 2821, 1, 0, + 0, 0, 196, 2827, 1, 0, 0, 0, 198, 2832, 1, 0, 0, 0, 200, 2838, 1, 0, 0, + 0, 202, 2854, 1, 0, 0, 0, 204, 2858, 1, 0, 0, 0, 206, 2864, 1, 0, 0, 0, + 208, 2870, 1, 0, 0, 0, 210, 2878, 1, 0, 0, 0, 212, 2884, 1, 0, 0, 0, 214, + 2899, 1, 0, 0, 0, 216, 2917, 1, 0, 0, 0, 218, 2924, 1, 0, 0, 0, 220, 2929, + 1, 0, 0, 0, 222, 2940, 1, 0, 0, 0, 224, 2945, 1, 0, 0, 0, 226, 2949, 1, + 0, 0, 0, 228, 2953, 1, 0, 0, 0, 230, 2958, 1, 0, 0, 0, 232, 2963, 1, 0, + 0, 0, 234, 2968, 1, 0, 0, 0, 236, 2982, 1, 0, 0, 0, 238, 2988, 1, 0, 0, + 0, 240, 2993, 1, 0, 0, 0, 242, 3001, 1, 0, 0, 0, 244, 3005, 1, 0, 0, 0, + 246, 3022, 1, 0, 0, 0, 248, 3030, 1, 0, 0, 0, 250, 3036, 1, 0, 0, 0, 252, + 3050, 1, 0, 0, 0, 254, 3072, 1, 0, 0, 0, 256, 3077, 1, 0, 0, 0, 258, 3083, + 1, 0, 0, 0, 260, 3088, 1, 0, 0, 0, 262, 3092, 1, 0, 0, 0, 264, 3120, 1, + 0, 0, 0, 266, 3131, 1, 0, 0, 0, 268, 3140, 1, 0, 0, 0, 270, 3153, 1, 0, + 0, 0, 272, 3161, 1, 0, 0, 0, 274, 3166, 1, 0, 0, 0, 276, 3177, 1, 0, 0, + 0, 278, 3207, 1, 0, 0, 0, 280, 3237, 1, 0, 0, 0, 282, 3251, 1, 0, 0, 0, + 284, 3275, 1, 0, 0, 0, 286, 3291, 1, 0, 0, 0, 288, 3304, 1, 0, 0, 0, 290, + 3323, 1, 0, 0, 0, 292, 3336, 1, 0, 0, 0, 294, 3345, 1, 0, 0, 0, 296, 3414, + 1, 0, 0, 0, 298, 3430, 1, 0, 0, 0, 300, 3450, 1, 0, 0, 0, 302, 3467, 1, + 0, 0, 0, 304, 3497, 1, 0, 0, 0, 306, 3740, 1, 0, 0, 0, 308, 3749, 1, 0, + 0, 0, 310, 3807, 1, 0, 0, 0, 312, 3856, 1, 0, 0, 0, 314, 3858, 1, 0, 0, + 0, 316, 3899, 1, 0, 0, 0, 318, 3949, 1, 0, 0, 0, 320, 4019, 1, 0, 0, 0, + 322, 4086, 1, 0, 0, 0, 324, 4102, 1, 0, 0, 0, 326, 4130, 1, 0, 0, 0, 328, + 4149, 1, 0, 0, 0, 330, 4170, 1, 0, 0, 0, 332, 4242, 1, 0, 0, 0, 334, 4337, + 1, 0, 0, 0, 336, 4359, 1, 0, 0, 0, 338, 4371, 1, 0, 0, 0, 340, 4399, 1, + 0, 0, 0, 342, 4420, 1, 0, 0, 0, 344, 4446, 1, 0, 0, 0, 346, 4455, 1, 0, + 0, 0, 348, 4487, 1, 0, 0, 0, 350, 4497, 1, 0, 0, 0, 352, 4513, 1, 0, 0, + 0, 354, 4525, 1, 0, 0, 0, 356, 4534, 1, 0, 0, 0, 358, 4551, 1, 0, 0, 0, + 360, 4575, 1, 0, 0, 0, 362, 4683, 1, 0, 0, 0, 364, 4709, 1, 0, 0, 0, 366, + 4738, 1, 0, 0, 0, 368, 4746, 1, 0, 0, 0, 370, 4770, 1, 0, 0, 0, 372, 4772, + 1, 0, 0, 0, 374, 4782, 1, 0, 0, 0, 376, 4786, 1, 0, 0, 0, 378, 4798, 1, + 0, 0, 0, 380, 4827, 1, 0, 0, 0, 382, 4834, 1, 0, 0, 0, 384, 4878, 1, 0, + 0, 0, 386, 4889, 1, 0, 0, 0, 388, 4908, 1, 0, 0, 0, 390, 4948, 1, 0, 0, + 0, 392, 4955, 1, 0, 0, 0, 394, 4968, 1, 0, 0, 0, 396, 4986, 1, 0, 0, 0, + 398, 5056, 1, 0, 0, 0, 400, 5099, 1, 0, 0, 0, 402, 5159, 1, 0, 0, 0, 404, + 5296, 1, 0, 0, 0, 406, 5439, 1, 0, 0, 0, 408, 5468, 1, 0, 0, 0, 410, 5497, + 1, 0, 0, 0, 412, 5608, 1, 0, 0, 0, 414, 5621, 1, 0, 0, 0, 416, 5629, 1, + 0, 0, 0, 418, 5637, 1, 0, 0, 0, 420, 5663, 1, 0, 0, 0, 422, 5667, 1, 0, + 0, 0, 424, 5697, 1, 0, 0, 0, 426, 5724, 1, 0, 0, 0, 428, 5744, 1, 0, 0, + 0, 430, 5781, 1, 0, 0, 0, 432, 5985, 1, 0, 0, 0, 434, 6015, 1, 0, 0, 0, + 436, 6017, 1, 0, 0, 0, 438, 6049, 1, 0, 0, 0, 440, 6096, 1, 0, 0, 0, 442, + 6148, 1, 0, 0, 0, 444, 6164, 1, 0, 0, 0, 446, 6182, 1, 0, 0, 0, 448, 6204, + 1, 0, 0, 0, 450, 6218, 1, 0, 0, 0, 452, 6292, 1, 0, 0, 0, 454, 6323, 1, + 0, 0, 0, 456, 6325, 1, 0, 0, 0, 458, 6329, 1, 0, 0, 0, 460, 6359, 1, 0, + 0, 0, 462, 6361, 1, 0, 0, 0, 464, 6382, 1, 0, 0, 0, 466, 6461, 1, 0, 0, + 0, 468, 6474, 1, 0, 0, 0, 470, 6476, 1, 0, 0, 0, 472, 6489, 1, 0, 0, 0, + 474, 6543, 1, 0, 0, 0, 476, 6546, 1, 0, 0, 0, 478, 6591, 1, 0, 0, 0, 480, + 6594, 1, 0, 0, 0, 482, 6627, 1, 0, 0, 0, 484, 6631, 1, 0, 0, 0, 486, 6646, + 1, 0, 0, 0, 488, 6649, 1, 0, 0, 0, 490, 6708, 1, 0, 0, 0, 492, 6732, 1, + 0, 0, 0, 494, 6737, 1, 0, 0, 0, 496, 6786, 1, 0, 0, 0, 498, 6821, 1, 0, + 0, 0, 500, 6843, 1, 0, 0, 0, 502, 6846, 1, 0, 0, 0, 504, 6887, 1, 0, 0, + 0, 506, 6890, 1, 0, 0, 0, 508, 6906, 1, 0, 0, 0, 510, 6908, 1, 0, 0, 0, + 512, 6910, 1, 0, 0, 0, 514, 6929, 1, 0, 0, 0, 516, 6931, 1, 0, 0, 0, 518, + 6951, 1, 0, 0, 0, 520, 6973, 1, 0, 0, 0, 522, 6975, 1, 0, 0, 0, 524, 6984, + 1, 0, 0, 0, 526, 7002, 1, 0, 0, 0, 528, 7004, 1, 0, 0, 0, 530, 7037, 1, + 0, 0, 0, 532, 7055, 1, 0, 0, 0, 534, 7057, 1, 0, 0, 0, 536, 7129, 1, 0, + 0, 0, 538, 7131, 1, 0, 0, 0, 540, 7176, 1, 0, 0, 0, 542, 7178, 1, 0, 0, + 0, 544, 7199, 1, 0, 0, 0, 546, 7216, 1, 0, 0, 0, 548, 7249, 1, 0, 0, 0, + 550, 7251, 1, 0, 0, 0, 552, 7277, 1, 0, 0, 0, 554, 7307, 1, 0, 0, 0, 556, + 7358, 1, 0, 0, 0, 558, 7366, 1, 0, 0, 0, 560, 7415, 1, 0, 0, 0, 562, 7425, + 1, 0, 0, 0, 564, 7433, 1, 0, 0, 0, 566, 7481, 1, 0, 0, 0, 568, 7483, 1, + 0, 0, 0, 570, 7491, 1, 0, 0, 0, 572, 7527, 1, 0, 0, 0, 574, 7535, 1, 0, + 0, 0, 576, 7562, 1, 0, 0, 0, 578, 7589, 1, 0, 0, 0, 580, 7624, 1, 0, 0, + 0, 582, 7661, 1, 0, 0, 0, 584, 7663, 1, 0, 0, 0, 586, 7686, 1, 0, 0, 0, + 588, 7700, 1, 0, 0, 0, 590, 7702, 1, 0, 0, 0, 592, 7733, 1, 0, 0, 0, 594, + 7753, 1, 0, 0, 0, 596, 7808, 1, 0, 0, 0, 598, 7810, 1, 0, 0, 0, 600, 7885, + 1, 0, 0, 0, 602, 7887, 1, 0, 0, 0, 604, 7965, 1, 0, 0, 0, 606, 7967, 1, + 0, 0, 0, 608, 8015, 1, 0, 0, 0, 610, 8023, 1, 0, 0, 0, 612, 8054, 1, 0, + 0, 0, 614, 8056, 1, 0, 0, 0, 616, 8141, 1, 0, 0, 0, 618, 8153, 1, 0, 0, + 0, 620, 8167, 1, 0, 0, 0, 622, 8224, 1, 0, 0, 0, 624, 8226, 1, 0, 0, 0, + 626, 8291, 1, 0, 0, 0, 628, 8293, 1, 0, 0, 0, 630, 8318, 1, 0, 0, 0, 632, + 8337, 1, 0, 0, 0, 634, 8339, 1, 0, 0, 0, 636, 8367, 1, 0, 0, 0, 638, 8369, + 1, 0, 0, 0, 640, 8377, 1, 0, 0, 0, 642, 8379, 1, 0, 0, 0, 644, 8448, 1, + 0, 0, 0, 646, 8456, 1, 0, 0, 0, 648, 8458, 1, 0, 0, 0, 650, 8460, 1, 0, + 0, 0, 652, 8462, 1, 0, 0, 0, 654, 8476, 1, 0, 0, 0, 656, 8482, 1, 0, 0, + 0, 658, 8484, 1, 0, 0, 0, 660, 8486, 1, 0, 0, 0, 662, 8491, 1, 0, 0, 0, + 664, 8493, 1, 0, 0, 0, 666, 8497, 1, 0, 0, 0, 668, 8509, 1, 0, 0, 0, 670, + 8511, 1, 0, 0, 0, 672, 8514, 1, 0, 0, 0, 674, 8517, 1, 0, 0, 0, 676, 8519, + 1, 0, 0, 0, 678, 8521, 1, 0, 0, 0, 680, 8523, 1, 0, 0, 0, 682, 8552, 1, + 0, 0, 0, 684, 8554, 1, 0, 0, 0, 686, 8565, 1, 0, 0, 0, 688, 8568, 1, 0, + 0, 0, 690, 8580, 1, 0, 0, 0, 692, 8588, 1, 0, 0, 0, 694, 8595, 1, 0, 0, + 0, 696, 8618, 1, 0, 0, 0, 698, 8620, 1, 0, 0, 0, 700, 8631, 1, 0, 0, 0, + 702, 8633, 1, 0, 0, 0, 704, 8660, 1, 0, 0, 0, 706, 8667, 1, 0, 0, 0, 708, + 8673, 1, 0, 0, 0, 710, 8692, 1, 0, 0, 0, 712, 8694, 1, 0, 0, 0, 714, 8711, + 1, 0, 0, 0, 716, 8734, 1, 0, 0, 0, 718, 8751, 1, 0, 0, 0, 720, 8768, 1, + 0, 0, 0, 722, 8785, 1, 0, 0, 0, 724, 8802, 1, 0, 0, 0, 726, 8820, 1, 0, + 0, 0, 728, 8830, 1, 0, 0, 0, 730, 8832, 1, 0, 0, 0, 732, 8839, 1, 0, 0, + 0, 734, 8894, 1, 0, 0, 0, 736, 8901, 1, 0, 0, 0, 738, 8932, 1, 0, 0, 0, + 740, 8934, 1, 0, 0, 0, 742, 9184, 1, 0, 0, 0, 744, 9422, 1, 0, 0, 0, 746, + 9462, 1, 0, 0, 0, 748, 9475, 1, 0, 0, 0, 750, 9489, 1, 0, 0, 0, 752, 9497, + 1, 0, 0, 0, 754, 9503, 1, 0, 0, 0, 756, 9510, 1, 0, 0, 0, 758, 9514, 1, + 0, 0, 0, 760, 9519, 1, 0, 0, 0, 762, 9571, 1, 0, 0, 0, 764, 9589, 1, 0, + 0, 0, 766, 9591, 1, 0, 0, 0, 768, 9595, 1, 0, 0, 0, 770, 9605, 1, 0, 0, + 0, 772, 9628, 1, 0, 0, 0, 774, 9692, 1, 0, 0, 0, 776, 9696, 1, 0, 0, 0, + 778, 9698, 1, 0, 0, 0, 780, 9735, 1, 0, 0, 0, 782, 9737, 1, 0, 0, 0, 784, + 9753, 1, 0, 0, 0, 786, 9766, 1, 0, 0, 0, 788, 9786, 1, 0, 0, 0, 790, 9799, + 1, 0, 0, 0, 792, 9836, 1, 0, 0, 0, 794, 9853, 1, 0, 0, 0, 796, 9855, 1, + 0, 0, 0, 798, 9868, 1, 0, 0, 0, 800, 9893, 1, 0, 0, 0, 802, 10108, 1, 0, + 0, 0, 804, 10141, 1, 0, 0, 0, 806, 10203, 1, 0, 0, 0, 808, 10205, 1, 0, + 0, 0, 810, 10209, 1, 0, 0, 0, 812, 10212, 1, 0, 0, 0, 814, 10216, 1, 0, + 0, 0, 816, 10221, 1, 0, 0, 0, 818, 10226, 1, 0, 0, 0, 820, 10230, 1, 0, + 0, 0, 822, 10232, 1, 0, 0, 0, 824, 10259, 1, 0, 0, 0, 826, 10273, 1, 0, + 0, 0, 828, 10275, 1, 0, 0, 0, 830, 10305, 1, 0, 0, 0, 832, 10307, 1, 0, + 0, 0, 834, 10340, 1, 0, 0, 0, 836, 10342, 1, 0, 0, 0, 838, 10366, 1, 0, + 0, 0, 840, 10391, 1, 0, 0, 0, 842, 10412, 1, 0, 0, 0, 844, 10414, 1, 0, + 0, 0, 846, 10431, 1, 0, 0, 0, 848, 10442, 1, 0, 0, 0, 850, 10447, 1, 0, + 0, 0, 852, 10449, 1, 0, 0, 0, 854, 10471, 1, 0, 0, 0, 856, 10487, 1, 0, + 0, 0, 858, 10503, 1, 0, 0, 0, 860, 10511, 1, 0, 0, 0, 862, 10522, 1, 0, + 0, 0, 864, 10540, 1, 0, 0, 0, 866, 10544, 1, 0, 0, 0, 868, 10553, 1, 0, + 0, 0, 870, 10588, 1, 0, 0, 0, 872, 10590, 1, 0, 0, 0, 874, 10598, 1, 0, + 0, 0, 876, 10602, 1, 0, 0, 0, 878, 10615, 1, 0, 0, 0, 880, 10617, 1, 0, + 0, 0, 882, 10688, 1, 0, 0, 0, 884, 10690, 1, 0, 0, 0, 886, 10715, 1, 0, + 0, 0, 888, 10725, 1, 0, 0, 0, 890, 10745, 1, 0, 0, 0, 892, 10763, 1, 0, + 0, 0, 894, 10775, 1, 0, 0, 0, 896, 10820, 1, 0, 0, 0, 898, 10828, 1, 0, + 0, 0, 900, 10836, 1, 0, 0, 0, 902, 10853, 1, 0, 0, 0, 904, 10863, 1, 0, + 0, 0, 906, 10874, 1, 0, 0, 0, 908, 10885, 1, 0, 0, 0, 910, 10983, 1, 0, + 0, 0, 912, 10985, 1, 0, 0, 0, 914, 11026, 1, 0, 0, 0, 916, 11037, 1, 0, + 0, 0, 918, 11039, 1, 0, 0, 0, 920, 11136, 1, 0, 0, 0, 922, 11138, 1, 0, + 0, 0, 924, 11142, 1, 0, 0, 0, 926, 11153, 1, 0, 0, 0, 928, 11182, 1, 0, + 0, 0, 930, 11184, 1, 0, 0, 0, 932, 11193, 1, 0, 0, 0, 934, 11220, 1, 0, + 0, 0, 936, 11226, 1, 0, 0, 0, 938, 11236, 1, 0, 0, 0, 940, 11238, 1, 0, + 0, 0, 942, 11240, 1, 0, 0, 0, 944, 11249, 1, 0, 0, 0, 946, 11286, 1, 0, + 0, 0, 948, 11304, 1, 0, 0, 0, 950, 11306, 1, 0, 0, 0, 952, 11396, 1, 0, + 0, 0, 954, 11418, 1, 0, 0, 0, 956, 11426, 1, 0, 0, 0, 958, 11435, 1, 0, + 0, 0, 960, 11460, 1, 0, 0, 0, 962, 11488, 1, 0, 0, 0, 964, 11491, 1, 0, + 0, 0, 966, 11494, 1, 0, 0, 0, 968, 11510, 1, 0, 0, 0, 970, 11517, 1, 0, + 0, 0, 972, 11519, 1, 0, 0, 0, 974, 11529, 1, 0, 0, 0, 976, 11632, 1, 0, + 0, 0, 978, 11634, 1, 0, 0, 0, 980, 11646, 1, 0, 0, 0, 982, 11667, 1, 0, + 0, 0, 984, 11669, 1, 0, 0, 0, 986, 11671, 1, 0, 0, 0, 988, 11728, 1, 0, + 0, 0, 990, 11730, 1, 0, 0, 0, 992, 11739, 1, 0, 0, 0, 994, 11747, 1, 0, + 0, 0, 996, 11767, 1, 0, 0, 0, 998, 11785, 1, 0, 0, 0, 1000, 11795, 1, 0, + 0, 0, 1002, 11806, 1, 0, 0, 0, 1004, 11808, 1, 0, 0, 0, 1006, 11816, 1, + 0, 0, 0, 1008, 11891, 1, 0, 0, 0, 1010, 11893, 1, 0, 0, 0, 1012, 11913, + 1, 0, 0, 0, 1014, 11931, 1, 0, 0, 0, 1016, 11939, 1, 0, 0, 0, 1018, 11944, + 1, 0, 0, 0, 1020, 11952, 1, 0, 0, 0, 1022, 11959, 1, 0, 0, 0, 1024, 11961, + 1, 0, 0, 0, 1026, 11969, 1, 0, 0, 0, 1028, 11984, 1, 0, 0, 0, 1030, 11993, + 1, 0, 0, 0, 1032, 12003, 1, 0, 0, 0, 1034, 12007, 1, 0, 0, 0, 1036, 12011, + 1, 0, 0, 0, 1038, 12015, 1, 0, 0, 0, 1040, 12019, 1, 0, 0, 0, 1042, 12027, + 1, 0, 0, 0, 1044, 12037, 1, 0, 0, 0, 1046, 12071, 1, 0, 0, 0, 1048, 12073, + 1, 0, 0, 0, 1050, 12095, 1, 0, 0, 0, 1052, 12111, 1, 0, 0, 0, 1054, 12116, + 1, 0, 0, 0, 1056, 12193, 1, 0, 0, 0, 1058, 12254, 1, 0, 0, 0, 1060, 12256, + 1, 0, 0, 0, 1062, 12260, 1, 0, 0, 0, 1064, 13610, 1, 0, 0, 0, 1066, 13616, + 1, 0, 0, 0, 1068, 13618, 1, 0, 0, 0, 1070, 13627, 1, 0, 0, 0, 1072, 13636, + 1, 0, 0, 0, 1074, 13645, 1, 0, 0, 0, 1076, 13657, 1, 0, 0, 0, 1078, 13662, + 1, 0, 0, 0, 1080, 13675, 1, 0, 0, 0, 1082, 13680, 1, 0, 0, 0, 1084, 13691, + 1, 0, 0, 0, 1086, 13696, 1, 0, 0, 0, 1088, 13707, 1, 0, 0, 0, 1090, 13712, + 1, 0, 0, 0, 1092, 13747, 1, 0, 0, 0, 1094, 13749, 1, 0, 0, 0, 1096, 13767, + 1, 0, 0, 0, 1098, 13775, 1, 0, 0, 0, 1100, 13780, 1, 0, 0, 0, 1102, 13786, + 1, 0, 0, 0, 1104, 13791, 1, 0, 0, 0, 1106, 13795, 1, 0, 0, 0, 1108, 13797, + 1, 0, 0, 0, 1110, 13811, 1, 0, 0, 0, 1112, 13816, 1, 0, 0, 0, 1114, 13820, + 1, 0, 0, 0, 1116, 13878, 1, 0, 0, 0, 1118, 13882, 1, 0, 0, 0, 1120, 13884, + 1, 0, 0, 0, 1122, 13897, 1, 0, 0, 0, 1124, 13899, 1, 0, 0, 0, 1126, 13913, + 1, 0, 0, 0, 1128, 13931, 1, 0, 0, 0, 1130, 13965, 1, 0, 0, 0, 1132, 14018, + 1, 0, 0, 0, 1134, 14021, 1, 0, 0, 0, 1136, 14025, 1, 0, 0, 0, 1138, 14040, + 1, 0, 0, 0, 1140, 14049, 1, 0, 0, 0, 1142, 14053, 1, 0, 0, 0, 1144, 14061, + 1, 0, 0, 0, 1146, 14067, 1, 0, 0, 0, 1148, 14103, 1, 0, 0, 0, 1150, 14105, + 1, 0, 0, 0, 1152, 14118, 1, 0, 0, 0, 1154, 14120, 1, 0, 0, 0, 1156, 14141, + 1, 0, 0, 0, 1158, 14203, 1, 0, 0, 0, 1160, 14212, 1, 0, 0, 0, 1162, 14219, + 1, 0, 0, 0, 1164, 14221, 1, 0, 0, 0, 1166, 14233, 1, 0, 0, 0, 1168, 14236, + 1, 0, 0, 0, 1170, 14250, 1, 0, 0, 0, 1172, 14259, 1, 0, 0, 0, 1174, 14266, + 1, 0, 0, 0, 1176, 14280, 1, 0, 0, 0, 1178, 14296, 1, 0, 0, 0, 1180, 14300, + 1, 0, 0, 0, 1182, 14320, 1, 0, 0, 0, 1184, 14322, 1, 0, 0, 0, 1186, 14330, + 1, 0, 0, 0, 1188, 14334, 1, 0, 0, 0, 1190, 14348, 1, 0, 0, 0, 1192, 14353, + 1, 0, 0, 0, 1194, 14363, 1, 0, 0, 0, 1196, 14365, 1, 0, 0, 0, 1198, 14367, + 1, 0, 0, 0, 1200, 14370, 1, 0, 0, 0, 1202, 14379, 1, 0, 0, 0, 1204, 14381, + 1, 0, 0, 0, 1206, 14393, 1, 0, 0, 0, 1208, 14441, 1, 0, 0, 0, 1210, 14445, + 1, 0, 0, 0, 1212, 14447, 1, 0, 0, 0, 1214, 14468, 1, 0, 0, 0, 1216, 14483, + 1, 0, 0, 0, 1218, 14499, 1, 0, 0, 0, 1220, 14501, 1, 0, 0, 0, 1222, 14547, + 1, 0, 0, 0, 1224, 14564, 1, 0, 0, 0, 1226, 14575, 1, 0, 0, 0, 1228, 14577, + 1, 0, 0, 0, 1230, 14586, 1, 0, 0, 0, 1232, 14588, 1, 0, 0, 0, 1234, 14592, + 1, 0, 0, 0, 1236, 14609, 1, 0, 0, 0, 1238, 14611, 1, 0, 0, 0, 1240, 14613, + 1, 0, 0, 0, 1242, 1244, 3, 808, 404, 0, 1243, 1242, 1, 0, 0, 0, 1244, 1247, + 1, 0, 0, 0, 1245, 1243, 1, 0, 0, 0, 1245, 1246, 1, 0, 0, 0, 1246, 1248, + 1, 0, 0, 0, 1247, 1245, 1, 0, 0, 0, 1248, 1265, 5, 0, 0, 1, 1249, 1256, + 3, 2, 1, 0, 1250, 1252, 3, 808, 404, 0, 1251, 1253, 3, 2, 1, 0, 1252, 1251, + 1, 0, 0, 0, 1252, 1253, 1, 0, 0, 0, 1253, 1255, 1, 0, 0, 0, 1254, 1250, + 1, 0, 0, 0, 1255, 1258, 1, 0, 0, 0, 1256, 1254, 1, 0, 0, 0, 1256, 1257, + 1, 0, 0, 0, 1257, 1260, 1, 0, 0, 0, 1258, 1256, 1, 0, 0, 0, 1259, 1261, + 3, 808, 404, 0, 1260, 1259, 1, 0, 0, 0, 1260, 1261, 1, 0, 0, 0, 1261, 1262, + 1, 0, 0, 0, 1262, 1263, 5, 0, 0, 1, 1263, 1265, 1, 0, 0, 0, 1264, 1245, + 1, 0, 0, 0, 1264, 1249, 1, 0, 0, 0, 1265, 1, 1, 0, 0, 0, 1266, 1268, 3, + 6, 3, 0, 1267, 1266, 1, 0, 0, 0, 1268, 1269, 1, 0, 0, 0, 1269, 1267, 1, + 0, 0, 0, 1269, 1270, 1, 0, 0, 0, 1270, 1280, 1, 0, 0, 0, 1271, 1280, 3, + 4, 2, 0, 1272, 1276, 3, 760, 380, 0, 1273, 1275, 3, 6, 3, 0, 1274, 1273, + 1, 0, 0, 0, 1275, 1278, 1, 0, 0, 0, 1276, 1274, 1, 0, 0, 0, 1276, 1277, + 1, 0, 0, 0, 1277, 1280, 1, 0, 0, 0, 1278, 1276, 1, 0, 0, 0, 1279, 1267, + 1, 0, 0, 0, 1279, 1271, 1, 0, 0, 0, 1279, 1272, 1, 0, 0, 0, 1280, 3, 1, + 0, 0, 0, 1281, 1286, 3, 574, 287, 0, 1282, 1286, 3, 558, 279, 0, 1283, + 1286, 3, 562, 281, 0, 1284, 1286, 3, 610, 305, 0, 1285, 1281, 1, 0, 0, + 0, 1285, 1282, 1, 0, 0, 0, 1285, 1283, 1, 0, 0, 0, 1285, 1284, 1, 0, 0, + 0, 1286, 5, 1, 0, 0, 0, 1287, 1289, 3, 8, 4, 0, 1288, 1290, 5, 1209, 0, + 0, 1289, 1288, 1, 0, 0, 0, 1289, 1290, 1, 0, 0, 0, 1290, 1313, 1, 0, 0, + 0, 1291, 1293, 3, 14, 7, 0, 1292, 1294, 5, 1209, 0, 0, 1293, 1292, 1, 0, + 0, 0, 1293, 1294, 1, 0, 0, 0, 1294, 1313, 1, 0, 0, 0, 1295, 1297, 3, 48, + 24, 0, 1296, 1298, 5, 1209, 0, 0, 1297, 1296, 1, 0, 0, 0, 1297, 1298, 1, + 0, 0, 0, 1298, 1313, 1, 0, 0, 0, 1299, 1301, 3, 10, 5, 0, 1300, 1302, 5, + 1209, 0, 0, 1301, 1300, 1, 0, 0, 0, 1301, 1302, 1, 0, 0, 0, 1302, 1313, + 1, 0, 0, 0, 1303, 1305, 3, 862, 431, 0, 1304, 1306, 5, 1209, 0, 0, 1305, + 1304, 1, 0, 0, 0, 1305, 1306, 1, 0, 0, 0, 1306, 1313, 1, 0, 0, 0, 1307, + 1309, 3, 12, 6, 0, 1308, 1310, 5, 1209, 0, 0, 1309, 1308, 1, 0, 0, 0, 1309, + 1310, 1, 0, 0, 0, 1310, 1313, 1, 0, 0, 0, 1311, 1313, 5, 1209, 0, 0, 1312, + 1287, 1, 0, 0, 0, 1312, 1291, 1, 0, 0, 0, 1312, 1295, 1, 0, 0, 0, 1312, + 1299, 1, 0, 0, 0, 1312, 1303, 1, 0, 0, 0, 1312, 1307, 1, 0, 0, 0, 1312, + 1311, 1, 0, 0, 0, 1313, 7, 1, 0, 0, 0, 1314, 1320, 3, 464, 232, 0, 1315, + 1320, 3, 472, 236, 0, 1316, 1320, 3, 476, 238, 0, 1317, 1320, 3, 482, 241, + 0, 1318, 1320, 3, 488, 244, 0, 1319, 1314, 1, 0, 0, 0, 1319, 1315, 1, 0, + 0, 0, 1319, 1316, 1, 0, 0, 0, 1319, 1317, 1, 0, 0, 0, 1319, 1318, 1, 0, + 0, 0, 1320, 9, 1, 0, 0, 0, 1321, 1488, 3, 50, 25, 0, 1322, 1488, 3, 60, + 30, 0, 1323, 1488, 3, 118, 59, 0, 1324, 1488, 3, 132, 66, 0, 1325, 1488, + 3, 144, 72, 0, 1326, 1488, 3, 146, 73, 0, 1327, 1488, 3, 142, 71, 0, 1328, + 1488, 3, 160, 80, 0, 1329, 1488, 3, 174, 87, 0, 1330, 1488, 3, 176, 88, + 0, 1331, 1488, 3, 286, 143, 0, 1332, 1488, 3, 290, 145, 0, 1333, 1488, + 3, 620, 310, 0, 1334, 1488, 3, 364, 182, 0, 1335, 1488, 3, 376, 188, 0, + 1336, 1488, 3, 642, 321, 0, 1337, 1488, 3, 312, 156, 0, 1338, 1488, 3, + 314, 157, 0, 1339, 1488, 3, 318, 159, 0, 1340, 1488, 3, 322, 161, 0, 1341, + 1488, 3, 326, 163, 0, 1342, 1488, 3, 516, 258, 0, 1343, 1488, 3, 334, 167, + 0, 1344, 1488, 3, 338, 169, 0, 1345, 1488, 3, 330, 165, 0, 1346, 1488, + 3, 346, 173, 0, 1347, 1488, 3, 342, 171, 0, 1348, 1488, 3, 350, 175, 0, + 1349, 1488, 3, 352, 176, 0, 1350, 1488, 3, 354, 177, 0, 1351, 1488, 3, + 356, 178, 0, 1352, 1488, 3, 362, 181, 0, 1353, 1488, 3, 392, 196, 0, 1354, + 1488, 3, 386, 193, 0, 1355, 1488, 3, 398, 199, 0, 1356, 1488, 3, 402, 201, + 0, 1357, 1488, 3, 406, 203, 0, 1358, 1488, 3, 410, 205, 0, 1359, 1488, + 3, 412, 206, 0, 1360, 1488, 3, 416, 208, 0, 1361, 1488, 3, 418, 209, 0, + 1362, 1488, 3, 424, 212, 0, 1363, 1488, 3, 426, 213, 0, 1364, 1488, 3, + 614, 307, 0, 1365, 1488, 3, 430, 215, 0, 1366, 1488, 3, 436, 218, 0, 1367, + 1488, 3, 438, 219, 0, 1368, 1488, 3, 52, 26, 0, 1369, 1488, 3, 54, 27, + 0, 1370, 1488, 3, 114, 57, 0, 1371, 1488, 3, 128, 64, 0, 1372, 1488, 3, + 178, 89, 0, 1373, 1488, 3, 284, 142, 0, 1374, 1488, 3, 544, 272, 0, 1375, + 1488, 3, 288, 144, 0, 1376, 1488, 3, 292, 146, 0, 1377, 1488, 3, 494, 247, + 0, 1378, 1488, 3, 378, 189, 0, 1379, 1488, 3, 380, 190, 0, 1380, 1488, + 3, 294, 147, 0, 1381, 1488, 3, 302, 151, 0, 1382, 1488, 3, 316, 158, 0, + 1383, 1488, 3, 320, 160, 0, 1384, 1488, 3, 324, 162, 0, 1385, 1488, 3, + 328, 164, 0, 1386, 1488, 3, 496, 248, 0, 1387, 1488, 3, 336, 168, 0, 1388, + 1488, 3, 340, 170, 0, 1389, 1488, 3, 332, 166, 0, 1390, 1488, 3, 348, 174, + 0, 1391, 1488, 3, 344, 172, 0, 1392, 1488, 3, 550, 275, 0, 1393, 1488, + 3, 170, 85, 0, 1394, 1488, 3, 304, 152, 0, 1395, 1488, 3, 444, 222, 0, + 1396, 1488, 3, 446, 223, 0, 1397, 1488, 3, 358, 179, 0, 1398, 1488, 3, + 360, 180, 0, 1399, 1488, 3, 382, 191, 0, 1400, 1488, 3, 384, 192, 0, 1401, + 1488, 3, 388, 194, 0, 1402, 1488, 3, 390, 195, 0, 1403, 1488, 3, 498, 249, + 0, 1404, 1488, 3, 394, 197, 0, 1405, 1488, 3, 396, 198, 0, 1406, 1488, + 3, 400, 200, 0, 1407, 1488, 3, 404, 202, 0, 1408, 1488, 3, 408, 204, 0, + 1409, 1488, 3, 414, 207, 0, 1410, 1488, 3, 422, 211, 0, 1411, 1488, 3, + 590, 295, 0, 1412, 1488, 3, 428, 214, 0, 1413, 1488, 3, 598, 299, 0, 1414, + 1488, 3, 724, 362, 0, 1415, 1488, 3, 432, 216, 0, 1416, 1488, 3, 434, 217, + 0, 1417, 1488, 3, 440, 220, 0, 1418, 1488, 3, 552, 276, 0, 1419, 1488, + 3, 442, 221, 0, 1420, 1488, 3, 276, 138, 0, 1421, 1488, 3, 56, 28, 0, 1422, + 1488, 3, 58, 29, 0, 1423, 1488, 3, 116, 58, 0, 1424, 1488, 3, 130, 65, + 0, 1425, 1488, 3, 158, 79, 0, 1426, 1488, 3, 172, 86, 0, 1427, 1488, 3, + 180, 90, 0, 1428, 1488, 3, 182, 91, 0, 1429, 1488, 3, 184, 92, 0, 1430, + 1488, 3, 186, 93, 0, 1431, 1488, 3, 188, 94, 0, 1432, 1488, 3, 190, 95, + 0, 1433, 1488, 3, 192, 96, 0, 1434, 1488, 3, 194, 97, 0, 1435, 1488, 3, + 196, 98, 0, 1436, 1488, 3, 198, 99, 0, 1437, 1488, 3, 240, 120, 0, 1438, + 1488, 3, 200, 100, 0, 1439, 1488, 3, 202, 101, 0, 1440, 1488, 3, 214, 107, + 0, 1441, 1488, 3, 216, 108, 0, 1442, 1488, 3, 204, 102, 0, 1443, 1488, + 3, 206, 103, 0, 1444, 1488, 3, 208, 104, 0, 1445, 1488, 3, 210, 105, 0, + 1446, 1488, 3, 212, 106, 0, 1447, 1488, 3, 218, 109, 0, 1448, 1488, 3, + 220, 110, 0, 1449, 1488, 3, 222, 111, 0, 1450, 1488, 3, 716, 358, 0, 1451, + 1488, 3, 702, 351, 0, 1452, 1488, 3, 224, 112, 0, 1453, 1488, 3, 226, 113, + 0, 1454, 1488, 3, 228, 114, 0, 1455, 1488, 3, 230, 115, 0, 1456, 1488, + 3, 232, 116, 0, 1457, 1488, 3, 708, 354, 0, 1458, 1488, 3, 234, 117, 0, + 1459, 1488, 3, 236, 118, 0, 1460, 1488, 3, 238, 119, 0, 1461, 1488, 3, + 242, 121, 0, 1462, 1488, 3, 244, 122, 0, 1463, 1488, 3, 246, 123, 0, 1464, + 1488, 3, 248, 124, 0, 1465, 1488, 3, 250, 125, 0, 1466, 1488, 3, 252, 126, + 0, 1467, 1488, 3, 254, 127, 0, 1468, 1488, 3, 256, 128, 0, 1469, 1488, + 3, 258, 129, 0, 1470, 1488, 3, 260, 130, 0, 1471, 1488, 3, 262, 131, 0, + 1472, 1488, 3, 718, 359, 0, 1473, 1488, 3, 264, 132, 0, 1474, 1488, 3, + 266, 133, 0, 1475, 1488, 3, 268, 134, 0, 1476, 1488, 3, 720, 360, 0, 1477, + 1488, 3, 710, 355, 0, 1478, 1488, 3, 726, 363, 0, 1479, 1488, 3, 270, 135, + 0, 1480, 1488, 3, 722, 361, 0, 1481, 1488, 3, 272, 136, 0, 1482, 1488, + 3, 274, 137, 0, 1483, 1488, 3, 278, 139, 0, 1484, 1488, 3, 280, 140, 0, + 1485, 1488, 3, 282, 141, 0, 1486, 1488, 3, 592, 296, 0, 1487, 1321, 1, + 0, 0, 0, 1487, 1322, 1, 0, 0, 0, 1487, 1323, 1, 0, 0, 0, 1487, 1324, 1, + 0, 0, 0, 1487, 1325, 1, 0, 0, 0, 1487, 1326, 1, 0, 0, 0, 1487, 1327, 1, + 0, 0, 0, 1487, 1328, 1, 0, 0, 0, 1487, 1329, 1, 0, 0, 0, 1487, 1330, 1, + 0, 0, 0, 1487, 1331, 1, 0, 0, 0, 1487, 1332, 1, 0, 0, 0, 1487, 1333, 1, + 0, 0, 0, 1487, 1334, 1, 0, 0, 0, 1487, 1335, 1, 0, 0, 0, 1487, 1336, 1, + 0, 0, 0, 1487, 1337, 1, 0, 0, 0, 1487, 1338, 1, 0, 0, 0, 1487, 1339, 1, + 0, 0, 0, 1487, 1340, 1, 0, 0, 0, 1487, 1341, 1, 0, 0, 0, 1487, 1342, 1, + 0, 0, 0, 1487, 1343, 1, 0, 0, 0, 1487, 1344, 1, 0, 0, 0, 1487, 1345, 1, + 0, 0, 0, 1487, 1346, 1, 0, 0, 0, 1487, 1347, 1, 0, 0, 0, 1487, 1348, 1, + 0, 0, 0, 1487, 1349, 1, 0, 0, 0, 1487, 1350, 1, 0, 0, 0, 1487, 1351, 1, + 0, 0, 0, 1487, 1352, 1, 0, 0, 0, 1487, 1353, 1, 0, 0, 0, 1487, 1354, 1, + 0, 0, 0, 1487, 1355, 1, 0, 0, 0, 1487, 1356, 1, 0, 0, 0, 1487, 1357, 1, + 0, 0, 0, 1487, 1358, 1, 0, 0, 0, 1487, 1359, 1, 0, 0, 0, 1487, 1360, 1, + 0, 0, 0, 1487, 1361, 1, 0, 0, 0, 1487, 1362, 1, 0, 0, 0, 1487, 1363, 1, + 0, 0, 0, 1487, 1364, 1, 0, 0, 0, 1487, 1365, 1, 0, 0, 0, 1487, 1366, 1, + 0, 0, 0, 1487, 1367, 1, 0, 0, 0, 1487, 1368, 1, 0, 0, 0, 1487, 1369, 1, + 0, 0, 0, 1487, 1370, 1, 0, 0, 0, 1487, 1371, 1, 0, 0, 0, 1487, 1372, 1, + 0, 0, 0, 1487, 1373, 1, 0, 0, 0, 1487, 1374, 1, 0, 0, 0, 1487, 1375, 1, + 0, 0, 0, 1487, 1376, 1, 0, 0, 0, 1487, 1377, 1, 0, 0, 0, 1487, 1378, 1, + 0, 0, 0, 1487, 1379, 1, 0, 0, 0, 1487, 1380, 1, 0, 0, 0, 1487, 1381, 1, + 0, 0, 0, 1487, 1382, 1, 0, 0, 0, 1487, 1383, 1, 0, 0, 0, 1487, 1384, 1, + 0, 0, 0, 1487, 1385, 1, 0, 0, 0, 1487, 1386, 1, 0, 0, 0, 1487, 1387, 1, + 0, 0, 0, 1487, 1388, 1, 0, 0, 0, 1487, 1389, 1, 0, 0, 0, 1487, 1390, 1, + 0, 0, 0, 1487, 1391, 1, 0, 0, 0, 1487, 1392, 1, 0, 0, 0, 1487, 1393, 1, + 0, 0, 0, 1487, 1394, 1, 0, 0, 0, 1487, 1395, 1, 0, 0, 0, 1487, 1396, 1, + 0, 0, 0, 1487, 1397, 1, 0, 0, 0, 1487, 1398, 1, 0, 0, 0, 1487, 1399, 1, + 0, 0, 0, 1487, 1400, 1, 0, 0, 0, 1487, 1401, 1, 0, 0, 0, 1487, 1402, 1, + 0, 0, 0, 1487, 1403, 1, 0, 0, 0, 1487, 1404, 1, 0, 0, 0, 1487, 1405, 1, + 0, 0, 0, 1487, 1406, 1, 0, 0, 0, 1487, 1407, 1, 0, 0, 0, 1487, 1408, 1, + 0, 0, 0, 1487, 1409, 1, 0, 0, 0, 1487, 1410, 1, 0, 0, 0, 1487, 1411, 1, + 0, 0, 0, 1487, 1412, 1, 0, 0, 0, 1487, 1413, 1, 0, 0, 0, 1487, 1414, 1, + 0, 0, 0, 1487, 1415, 1, 0, 0, 0, 1487, 1416, 1, 0, 0, 0, 1487, 1417, 1, + 0, 0, 0, 1487, 1418, 1, 0, 0, 0, 1487, 1419, 1, 0, 0, 0, 1487, 1420, 1, + 0, 0, 0, 1487, 1421, 1, 0, 0, 0, 1487, 1422, 1, 0, 0, 0, 1487, 1423, 1, + 0, 0, 0, 1487, 1424, 1, 0, 0, 0, 1487, 1425, 1, 0, 0, 0, 1487, 1426, 1, + 0, 0, 0, 1487, 1427, 1, 0, 0, 0, 1487, 1428, 1, 0, 0, 0, 1487, 1429, 1, + 0, 0, 0, 1487, 1430, 1, 0, 0, 0, 1487, 1431, 1, 0, 0, 0, 1487, 1432, 1, + 0, 0, 0, 1487, 1433, 1, 0, 0, 0, 1487, 1434, 1, 0, 0, 0, 1487, 1435, 1, + 0, 0, 0, 1487, 1436, 1, 0, 0, 0, 1487, 1437, 1, 0, 0, 0, 1487, 1438, 1, + 0, 0, 0, 1487, 1439, 1, 0, 0, 0, 1487, 1440, 1, 0, 0, 0, 1487, 1441, 1, + 0, 0, 0, 1487, 1442, 1, 0, 0, 0, 1487, 1443, 1, 0, 0, 0, 1487, 1444, 1, + 0, 0, 0, 1487, 1445, 1, 0, 0, 0, 1487, 1446, 1, 0, 0, 0, 1487, 1447, 1, + 0, 0, 0, 1487, 1448, 1, 0, 0, 0, 1487, 1449, 1, 0, 0, 0, 1487, 1450, 1, + 0, 0, 0, 1487, 1451, 1, 0, 0, 0, 1487, 1452, 1, 0, 0, 0, 1487, 1453, 1, + 0, 0, 0, 1487, 1454, 1, 0, 0, 0, 1487, 1455, 1, 0, 0, 0, 1487, 1456, 1, + 0, 0, 0, 1487, 1457, 1, 0, 0, 0, 1487, 1458, 1, 0, 0, 0, 1487, 1459, 1, + 0, 0, 0, 1487, 1460, 1, 0, 0, 0, 1487, 1461, 1, 0, 0, 0, 1487, 1462, 1, + 0, 0, 0, 1487, 1463, 1, 0, 0, 0, 1487, 1464, 1, 0, 0, 0, 1487, 1465, 1, + 0, 0, 0, 1487, 1466, 1, 0, 0, 0, 1487, 1467, 1, 0, 0, 0, 1487, 1468, 1, + 0, 0, 0, 1487, 1469, 1, 0, 0, 0, 1487, 1470, 1, 0, 0, 0, 1487, 1471, 1, + 0, 0, 0, 1487, 1472, 1, 0, 0, 0, 1487, 1473, 1, 0, 0, 0, 1487, 1474, 1, + 0, 0, 0, 1487, 1475, 1, 0, 0, 0, 1487, 1476, 1, 0, 0, 0, 1487, 1477, 1, + 0, 0, 0, 1487, 1478, 1, 0, 0, 0, 1487, 1479, 1, 0, 0, 0, 1487, 1480, 1, + 0, 0, 0, 1487, 1481, 1, 0, 0, 0, 1487, 1482, 1, 0, 0, 0, 1487, 1483, 1, + 0, 0, 0, 1487, 1484, 1, 0, 0, 0, 1487, 1485, 1, 0, 0, 0, 1487, 1486, 1, + 0, 0, 0, 1488, 11, 1, 0, 0, 0, 1489, 1495, 3, 740, 370, 0, 1490, 1495, + 3, 742, 371, 0, 1491, 1495, 3, 744, 372, 0, 1492, 1495, 3, 746, 373, 0, + 1493, 1495, 3, 748, 374, 0, 1494, 1489, 1, 0, 0, 0, 1494, 1490, 1, 0, 0, + 0, 1494, 1491, 1, 0, 0, 0, 1494, 1492, 1, 0, 0, 0, 1494, 1493, 1, 0, 0, + 0, 1495, 13, 1, 0, 0, 0, 1496, 1509, 3, 16, 8, 0, 1497, 1509, 3, 18, 9, + 0, 1498, 1509, 3, 20, 10, 0, 1499, 1509, 3, 22, 11, 0, 1500, 1509, 3, 26, + 13, 0, 1501, 1509, 3, 42, 21, 0, 1502, 1509, 3, 44, 22, 0, 1503, 1509, + 3, 24, 12, 0, 1504, 1509, 3, 28, 14, 0, 1505, 1509, 3, 36, 18, 0, 1506, + 1509, 3, 38, 19, 0, 1507, 1509, 3, 40, 20, 0, 1508, 1496, 1, 0, 0, 0, 1508, + 1497, 1, 0, 0, 0, 1508, 1498, 1, 0, 0, 0, 1508, 1499, 1, 0, 0, 0, 1508, + 1500, 1, 0, 0, 0, 1508, 1501, 1, 0, 0, 0, 1508, 1502, 1, 0, 0, 0, 1508, + 1503, 1, 0, 0, 0, 1508, 1504, 1, 0, 0, 0, 1508, 1505, 1, 0, 0, 0, 1508, + 1506, 1, 0, 0, 0, 1508, 1507, 1, 0, 0, 0, 1509, 15, 1, 0, 0, 0, 1510, 1512, + 5, 90, 0, 0, 1511, 1513, 5, 1209, 0, 0, 1512, 1511, 1, 0, 0, 0, 1512, 1513, + 1, 0, 0, 0, 1513, 1517, 1, 0, 0, 0, 1514, 1516, 3, 6, 3, 0, 1515, 1514, + 1, 0, 0, 0, 1516, 1519, 1, 0, 0, 0, 1517, 1515, 1, 0, 0, 0, 1517, 1518, + 1, 0, 0, 0, 1518, 1520, 1, 0, 0, 0, 1519, 1517, 1, 0, 0, 0, 1520, 1522, + 5, 299, 0, 0, 1521, 1523, 5, 1209, 0, 0, 1522, 1521, 1, 0, 0, 0, 1522, + 1523, 1, 0, 0, 0, 1523, 17, 1, 0, 0, 0, 1524, 1526, 5, 103, 0, 0, 1525, + 1527, 5, 1209, 0, 0, 1526, 1525, 1, 0, 0, 0, 1526, 1527, 1, 0, 0, 0, 1527, + 19, 1, 0, 0, 0, 1528, 1530, 5, 186, 0, 0, 1529, 1531, 5, 1209, 0, 0, 1530, + 1529, 1, 0, 0, 0, 1530, 1531, 1, 0, 0, 0, 1531, 21, 1, 0, 0, 0, 1532, 1533, + 5, 408, 0, 0, 1533, 1535, 3, 1230, 615, 0, 1534, 1536, 5, 1209, 0, 0, 1535, + 1534, 1, 0, 0, 0, 1535, 1536, 1, 0, 0, 0, 1536, 1543, 1, 0, 0, 0, 1537, + 1538, 3, 1230, 615, 0, 1538, 1540, 5, 1210, 0, 0, 1539, 1541, 5, 1209, + 0, 0, 1540, 1539, 1, 0, 0, 0, 1540, 1541, 1, 0, 0, 0, 1541, 1543, 1, 0, + 0, 0, 1542, 1532, 1, 0, 0, 0, 1542, 1537, 1, 0, 0, 0, 1543, 23, 1, 0, 0, + 0, 1544, 1546, 5, 824, 0, 0, 1545, 1547, 3, 926, 463, 0, 1546, 1545, 1, + 0, 0, 0, 1546, 1547, 1, 0, 0, 0, 1547, 1549, 1, 0, 0, 0, 1548, 1550, 5, + 1209, 0, 0, 1549, 1548, 1, 0, 0, 0, 1549, 1550, 1, 0, 0, 0, 1550, 25, 1, + 0, 0, 0, 1551, 1552, 5, 440, 0, 0, 1552, 1553, 3, 950, 475, 0, 1553, 1556, + 3, 6, 3, 0, 1554, 1555, 5, 289, 0, 0, 1555, 1557, 3, 6, 3, 0, 1556, 1554, + 1, 0, 0, 0, 1556, 1557, 1, 0, 0, 0, 1557, 1559, 1, 0, 0, 0, 1558, 1560, + 5, 1209, 0, 0, 1559, 1558, 1, 0, 0, 0, 1559, 1560, 1, 0, 0, 0, 1560, 27, + 1, 0, 0, 0, 1561, 1568, 5, 994, 0, 0, 1562, 1563, 3, 30, 15, 0, 1563, 1564, + 5, 1208, 0, 0, 1564, 1565, 3, 32, 16, 0, 1565, 1566, 5, 1208, 0, 0, 1566, + 1567, 3, 34, 17, 0, 1567, 1569, 1, 0, 0, 0, 1568, 1562, 1, 0, 0, 0, 1568, + 1569, 1, 0, 0, 0, 1569, 1571, 1, 0, 0, 0, 1570, 1572, 5, 1209, 0, 0, 1571, + 1570, 1, 0, 0, 0, 1571, 1572, 1, 0, 0, 0, 1572, 29, 1, 0, 0, 0, 1573, 1574, + 7, 0, 0, 0, 1574, 31, 1, 0, 0, 0, 1575, 1576, 7, 1, 0, 0, 1576, 33, 1, + 0, 0, 0, 1577, 1578, 7, 0, 0, 0, 1578, 35, 1, 0, 0, 0, 1579, 1580, 5, 90, + 0, 0, 1580, 1582, 5, 1019, 0, 0, 1581, 1583, 5, 1209, 0, 0, 1582, 1581, + 1, 0, 0, 0, 1582, 1583, 1, 0, 0, 0, 1583, 1585, 1, 0, 0, 0, 1584, 1586, + 3, 6, 3, 0, 1585, 1584, 1, 0, 0, 0, 1586, 1587, 1, 0, 0, 0, 1587, 1585, + 1, 0, 0, 0, 1587, 1588, 1, 0, 0, 0, 1588, 1589, 1, 0, 0, 0, 1589, 1590, + 5, 299, 0, 0, 1590, 1592, 5, 1019, 0, 0, 1591, 1593, 5, 1209, 0, 0, 1592, + 1591, 1, 0, 0, 0, 1592, 1593, 1, 0, 0, 0, 1593, 1594, 1, 0, 0, 0, 1594, + 1595, 5, 90, 0, 0, 1595, 1597, 5, 120, 0, 0, 1596, 1598, 5, 1209, 0, 0, + 1597, 1596, 1, 0, 0, 0, 1597, 1598, 1, 0, 0, 0, 1598, 1602, 1, 0, 0, 0, + 1599, 1601, 3, 6, 3, 0, 1600, 1599, 1, 0, 0, 0, 1601, 1604, 1, 0, 0, 0, + 1602, 1600, 1, 0, 0, 0, 1602, 1603, 1, 0, 0, 0, 1603, 1605, 1, 0, 0, 0, + 1604, 1602, 1, 0, 0, 0, 1605, 1606, 5, 299, 0, 0, 1606, 1608, 5, 120, 0, + 0, 1607, 1609, 5, 1209, 0, 0, 1608, 1607, 1, 0, 0, 0, 1608, 1609, 1, 0, + 0, 0, 1609, 37, 1, 0, 0, 0, 1610, 1612, 5, 1070, 0, 0, 1611, 1613, 3, 480, + 240, 0, 1612, 1611, 1, 0, 0, 0, 1612, 1613, 1, 0, 0, 0, 1613, 1615, 1, + 0, 0, 0, 1614, 1616, 5, 1208, 0, 0, 1615, 1614, 1, 0, 0, 0, 1615, 1616, + 1, 0, 0, 0, 1616, 1619, 1, 0, 0, 0, 1617, 1618, 7, 2, 0, 0, 1618, 1620, + 3, 486, 243, 0, 1619, 1617, 1, 0, 0, 0, 1619, 1620, 1, 0, 0, 0, 1620, 1622, + 1, 0, 0, 0, 1621, 1623, 3, 926, 463, 0, 1622, 1621, 1, 0, 0, 0, 1622, 1623, + 1, 0, 0, 0, 1623, 1625, 1, 0, 0, 0, 1624, 1626, 5, 1209, 0, 0, 1625, 1624, + 1, 0, 0, 0, 1625, 1626, 1, 0, 0, 0, 1626, 39, 1, 0, 0, 0, 1627, 1628, 5, + 1075, 0, 0, 1628, 1638, 3, 950, 475, 0, 1629, 1639, 3, 6, 3, 0, 1630, 1632, + 5, 103, 0, 0, 1631, 1633, 5, 1209, 0, 0, 1632, 1631, 1, 0, 0, 0, 1632, + 1633, 1, 0, 0, 0, 1633, 1639, 1, 0, 0, 0, 1634, 1636, 5, 186, 0, 0, 1635, + 1637, 5, 1209, 0, 0, 1636, 1635, 1, 0, 0, 0, 1636, 1637, 1, 0, 0, 0, 1637, + 1639, 1, 0, 0, 0, 1638, 1629, 1, 0, 0, 0, 1638, 1630, 1, 0, 0, 0, 1638, + 1634, 1, 0, 0, 0, 1639, 41, 1, 0, 0, 0, 1640, 1643, 5, 732, 0, 0, 1641, + 1644, 3, 926, 463, 0, 1642, 1644, 5, 1176, 0, 0, 1643, 1641, 1, 0, 0, 0, + 1643, 1642, 1, 0, 0, 0, 1644, 1649, 1, 0, 0, 0, 1645, 1646, 5, 1208, 0, + 0, 1646, 1648, 5, 1180, 0, 0, 1647, 1645, 1, 0, 0, 0, 1648, 1651, 1, 0, + 0, 0, 1649, 1647, 1, 0, 0, 0, 1649, 1650, 1, 0, 0, 0, 1650, 1653, 1, 0, + 0, 0, 1651, 1649, 1, 0, 0, 0, 1652, 1654, 5, 1209, 0, 0, 1653, 1652, 1, + 0, 0, 0, 1653, 1654, 1, 0, 0, 0, 1654, 43, 1, 0, 0, 0, 1655, 1656, 5, 759, + 0, 0, 1656, 1657, 5, 1206, 0, 0, 1657, 1658, 7, 3, 0, 0, 1658, 1659, 5, + 1208, 0, 0, 1659, 1660, 3, 924, 462, 0, 1660, 1661, 5, 1208, 0, 0, 1661, + 1669, 3, 924, 462, 0, 1662, 1665, 5, 1208, 0, 0, 1663, 1666, 3, 924, 462, + 0, 1664, 1666, 5, 643, 0, 0, 1665, 1663, 1, 0, 0, 0, 1665, 1664, 1, 0, + 0, 0, 1666, 1668, 1, 0, 0, 0, 1667, 1662, 1, 0, 0, 0, 1668, 1671, 1, 0, + 0, 0, 1669, 1667, 1, 0, 0, 0, 1669, 1670, 1, 0, 0, 0, 1670, 1672, 1, 0, + 0, 0, 1671, 1669, 1, 0, 0, 0, 1672, 1675, 5, 1207, 0, 0, 1673, 1674, 5, + 1077, 0, 0, 1674, 1676, 7, 4, 0, 0, 1675, 1673, 1, 0, 0, 0, 1675, 1676, + 1, 0, 0, 0, 1676, 1678, 1, 0, 0, 0, 1677, 1679, 5, 1209, 0, 0, 1678, 1677, + 1, 0, 0, 0, 1678, 1679, 1, 0, 0, 0, 1679, 1691, 1, 0, 0, 0, 1680, 1681, + 5, 759, 0, 0, 1681, 1682, 5, 1182, 0, 0, 1682, 1687, 7, 5, 0, 0, 1683, + 1684, 5, 1208, 0, 0, 1684, 1686, 7, 3, 0, 0, 1685, 1683, 1, 0, 0, 0, 1686, + 1689, 1, 0, 0, 0, 1687, 1685, 1, 0, 0, 0, 1687, 1688, 1, 0, 0, 0, 1688, + 1691, 1, 0, 0, 0, 1689, 1687, 1, 0, 0, 0, 1690, 1655, 1, 0, 0, 0, 1690, + 1680, 1, 0, 0, 0, 1691, 45, 1, 0, 0, 0, 1692, 1693, 5, 1209, 0, 0, 1693, + 47, 1, 0, 0, 0, 1694, 1712, 3, 452, 226, 0, 1695, 1712, 3, 818, 409, 0, + 1696, 1712, 3, 460, 230, 0, 1697, 1712, 3, 458, 229, 0, 1698, 1712, 3, + 448, 224, 0, 1699, 1712, 3, 738, 369, 0, 1700, 1712, 3, 734, 367, 0, 1701, + 1712, 3, 758, 379, 0, 1702, 1712, 3, 750, 375, 0, 1703, 1712, 3, 462, 231, + 0, 1704, 1712, 3, 814, 407, 0, 1705, 1712, 3, 774, 387, 0, 1706, 1712, + 3, 804, 402, 0, 1707, 1712, 3, 812, 406, 0, 1708, 1712, 3, 816, 408, 0, + 1709, 1712, 3, 806, 403, 0, 1710, 1712, 3, 810, 405, 0, 1711, 1694, 1, + 0, 0, 0, 1711, 1695, 1, 0, 0, 0, 1711, 1696, 1, 0, 0, 0, 1711, 1697, 1, + 0, 0, 0, 1711, 1698, 1, 0, 0, 0, 1711, 1699, 1, 0, 0, 0, 1711, 1700, 1, + 0, 0, 0, 1711, 1701, 1, 0, 0, 0, 1711, 1702, 1, 0, 0, 0, 1711, 1703, 1, + 0, 0, 0, 1711, 1704, 1, 0, 0, 0, 1711, 1705, 1, 0, 0, 0, 1711, 1706, 1, + 0, 0, 0, 1711, 1707, 1, 0, 0, 0, 1711, 1708, 1, 0, 0, 0, 1711, 1709, 1, + 0, 0, 0, 1711, 1710, 1, 0, 0, 0, 1712, 49, 1, 0, 0, 0, 1713, 1714, 5, 35, + 0, 0, 1714, 1715, 5, 48, 0, 0, 1715, 1716, 5, 832, 0, 0, 1716, 1717, 3, + 1230, 615, 0, 1717, 1724, 5, 1077, 0, 0, 1718, 1720, 5, 1208, 0, 0, 1719, + 1718, 1, 0, 0, 0, 1719, 1720, 1, 0, 0, 0, 1720, 1721, 1, 0, 0, 0, 1721, + 1722, 5, 597, 0, 0, 1722, 1723, 5, 1188, 0, 0, 1723, 1725, 3, 1230, 615, + 0, 1724, 1719, 1, 0, 0, 0, 1724, 1725, 1, 0, 0, 0, 1725, 1732, 1, 0, 0, + 0, 1726, 1728, 5, 1208, 0, 0, 1727, 1726, 1, 0, 0, 0, 1727, 1728, 1, 0, + 0, 0, 1728, 1729, 1, 0, 0, 0, 1729, 1730, 5, 703, 0, 0, 1730, 1731, 5, + 1188, 0, 0, 1731, 1733, 5, 1184, 0, 0, 1732, 1727, 1, 0, 0, 0, 1732, 1733, + 1, 0, 0, 0, 1733, 1740, 1, 0, 0, 0, 1734, 1736, 5, 1208, 0, 0, 1735, 1734, + 1, 0, 0, 0, 1735, 1736, 1, 0, 0, 0, 1736, 1737, 1, 0, 0, 0, 1737, 1738, + 5, 250, 0, 0, 1738, 1739, 5, 1188, 0, 0, 1739, 1741, 3, 1230, 615, 0, 1740, + 1735, 1, 0, 0, 0, 1740, 1741, 1, 0, 0, 0, 1741, 51, 1, 0, 0, 0, 1742, 1743, + 5, 35, 0, 0, 1743, 1744, 5, 1088, 0, 0, 1744, 1745, 5, 857, 0, 0, 1745, + 1749, 5, 154, 0, 0, 1746, 1747, 3, 1230, 615, 0, 1747, 1748, 5, 1201, 0, + 0, 1748, 1750, 1, 0, 0, 0, 1749, 1746, 1, 0, 0, 0, 1749, 1750, 1, 0, 0, + 0, 1750, 1751, 1, 0, 0, 0, 1751, 1752, 3, 1230, 615, 0, 1752, 1753, 5, + 11, 0, 0, 1753, 1754, 5, 1184, 0, 0, 1754, 53, 1, 0, 0, 0, 1755, 1756, + 5, 199, 0, 0, 1756, 1757, 5, 48, 0, 0, 1757, 1758, 5, 832, 0, 0, 1758, + 1759, 3, 1230, 615, 0, 1759, 1766, 5, 1077, 0, 0, 1760, 1762, 5, 1208, + 0, 0, 1761, 1760, 1, 0, 0, 0, 1761, 1762, 1, 0, 0, 0, 1762, 1763, 1, 0, + 0, 0, 1763, 1764, 5, 703, 0, 0, 1764, 1765, 5, 1188, 0, 0, 1765, 1767, + 5, 1184, 0, 0, 1766, 1761, 1, 0, 0, 0, 1766, 1767, 1, 0, 0, 0, 1767, 1774, + 1, 0, 0, 0, 1768, 1770, 5, 1208, 0, 0, 1769, 1768, 1, 0, 0, 0, 1769, 1770, + 1, 0, 0, 0, 1770, 1771, 1, 0, 0, 0, 1771, 1772, 5, 250, 0, 0, 1772, 1773, + 5, 1188, 0, 0, 1773, 1775, 3, 1230, 615, 0, 1774, 1769, 1, 0, 0, 0, 1774, + 1775, 1, 0, 0, 0, 1775, 55, 1, 0, 0, 0, 1776, 1777, 5, 282, 0, 0, 1777, + 1780, 5, 20, 0, 0, 1778, 1779, 5, 440, 0, 0, 1779, 1781, 5, 322, 0, 0, + 1780, 1778, 1, 0, 0, 0, 1780, 1781, 1, 0, 0, 0, 1781, 1785, 1, 0, 0, 0, + 1782, 1783, 3, 1230, 615, 0, 1783, 1784, 5, 1201, 0, 0, 1784, 1786, 1, + 0, 0, 0, 1785, 1782, 1, 0, 0, 0, 1785, 1786, 1, 0, 0, 0, 1786, 1787, 1, + 0, 0, 0, 1787, 1788, 3, 1230, 615, 0, 1788, 57, 1, 0, 0, 0, 1789, 1790, + 5, 282, 0, 0, 1790, 1791, 5, 48, 0, 0, 1791, 1792, 5, 832, 0, 0, 1792, + 1793, 3, 1230, 615, 0, 1793, 59, 1, 0, 0, 0, 1794, 1795, 3, 62, 31, 0, + 1795, 1796, 3, 1230, 615, 0, 1796, 1797, 3, 64, 32, 0, 1797, 61, 1, 0, + 0, 0, 1798, 1799, 5, 35, 0, 0, 1799, 1800, 5, 59, 0, 0, 1800, 63, 1, 0, + 0, 0, 1801, 1803, 3, 66, 33, 0, 1802, 1801, 1, 0, 0, 0, 1802, 1803, 1, + 0, 0, 0, 1803, 1805, 1, 0, 0, 0, 1804, 1806, 3, 88, 44, 0, 1805, 1804, + 1, 0, 0, 0, 1805, 1806, 1, 0, 0, 0, 1806, 1808, 1, 0, 0, 0, 1807, 1809, + 3, 70, 35, 0, 1808, 1807, 1, 0, 0, 0, 1808, 1809, 1, 0, 0, 0, 1809, 1811, + 1, 0, 0, 0, 1810, 1812, 3, 76, 38, 0, 1811, 1810, 1, 0, 0, 0, 1811, 1812, + 1, 0, 0, 0, 1812, 65, 1, 0, 0, 0, 1813, 1816, 3, 68, 34, 0, 1814, 1817, + 3, 92, 46, 0, 1815, 1817, 3, 84, 42, 0, 1816, 1814, 1, 0, 0, 0, 1816, 1815, + 1, 0, 0, 0, 1817, 67, 1, 0, 0, 0, 1818, 1819, 5, 380, 0, 0, 1819, 69, 1, + 0, 0, 0, 1820, 1821, 3, 74, 37, 0, 1821, 1822, 3, 72, 36, 0, 1822, 71, + 1, 0, 0, 0, 1823, 1826, 5, 22, 0, 0, 1824, 1826, 3, 110, 55, 0, 1825, 1823, + 1, 0, 0, 0, 1825, 1824, 1, 0, 0, 0, 1826, 73, 1, 0, 0, 0, 1827, 1828, 5, + 282, 0, 0, 1828, 75, 1, 0, 0, 0, 1829, 1830, 3, 78, 39, 0, 1830, 1831, + 3, 80, 40, 0, 1831, 77, 1, 0, 0, 0, 1832, 1833, 5, 11, 0, 0, 1833, 1834, + 5, 343, 0, 0, 1834, 1835, 5, 380, 0, 0, 1835, 79, 1, 0, 0, 0, 1836, 1840, + 3, 82, 41, 0, 1837, 1838, 3, 86, 43, 0, 1838, 1839, 3, 1230, 615, 0, 1839, + 1841, 1, 0, 0, 0, 1840, 1837, 1, 0, 0, 0, 1840, 1841, 1, 0, 0, 0, 1841, + 81, 1, 0, 0, 0, 1842, 1843, 5, 1184, 0, 0, 1843, 83, 1, 0, 0, 0, 1844, + 1845, 3, 86, 43, 0, 1845, 1846, 3, 1230, 615, 0, 1846, 85, 1, 0, 0, 0, + 1847, 1848, 5, 56, 0, 0, 1848, 87, 1, 0, 0, 0, 1849, 1850, 3, 90, 45, 0, + 1850, 1851, 3, 94, 47, 0, 1851, 89, 1, 0, 0, 0, 1852, 1853, 5, 1077, 0, + 0, 1853, 91, 1, 0, 0, 0, 1854, 1858, 3, 96, 48, 0, 1855, 1858, 3, 106, + 53, 0, 1856, 1858, 5, 1184, 0, 0, 1857, 1854, 1, 0, 0, 0, 1857, 1855, 1, + 0, 0, 0, 1857, 1856, 1, 0, 0, 0, 1858, 93, 1, 0, 0, 0, 1859, 1860, 6, 47, + -1, 0, 1860, 1861, 5, 713, 0, 0, 1861, 1862, 5, 1188, 0, 0, 1862, 1869, + 7, 6, 0, 0, 1863, 1864, 5, 1068, 0, 0, 1864, 1865, 5, 1188, 0, 0, 1865, + 1869, 3, 1196, 598, 0, 1866, 1867, 5, 1030, 0, 0, 1867, 1869, 5, 218, 0, + 0, 1868, 1859, 1, 0, 0, 0, 1868, 1863, 1, 0, 0, 0, 1868, 1866, 1, 0, 0, + 0, 1869, 1874, 1, 0, 0, 0, 1870, 1871, 10, 1, 0, 0, 1871, 1873, 5, 1208, + 0, 0, 1872, 1870, 1, 0, 0, 0, 1873, 1876, 1, 0, 0, 0, 1874, 1872, 1, 0, + 0, 0, 1874, 1875, 1, 0, 0, 0, 1875, 95, 1, 0, 0, 0, 1876, 1874, 1, 0, 0, + 0, 1877, 1878, 3, 100, 50, 0, 1878, 1879, 3, 98, 49, 0, 1879, 1880, 3, + 102, 51, 0, 1880, 97, 1, 0, 0, 0, 1881, 1882, 3, 1230, 615, 0, 1882, 99, + 1, 0, 0, 0, 1883, 1884, 5, 280, 0, 0, 1884, 101, 1, 0, 0, 0, 1885, 1886, + 3, 104, 52, 0, 1886, 1887, 3, 102, 51, 0, 1887, 1890, 1, 0, 0, 0, 1888, + 1890, 3, 1230, 615, 0, 1889, 1885, 1, 0, 0, 0, 1889, 1888, 1, 0, 0, 0, + 1890, 103, 1, 0, 0, 0, 1891, 1892, 5, 84, 0, 0, 1892, 105, 1, 0, 0, 0, + 1893, 1894, 3, 108, 54, 0, 1894, 1895, 3, 102, 51, 0, 1895, 107, 1, 0, + 0, 0, 1896, 1897, 5, 1168, 0, 0, 1897, 109, 1, 0, 0, 0, 1898, 1899, 3, + 112, 56, 0, 1899, 1900, 3, 106, 53, 0, 1900, 1901, 5, 1178, 0, 0, 1901, + 1902, 5, 1208, 0, 0, 1902, 1905, 1, 0, 0, 0, 1903, 1905, 3, 106, 53, 0, + 1904, 1898, 1, 0, 0, 0, 1904, 1903, 1, 0, 0, 0, 1905, 111, 1, 0, 0, 0, + 1906, 1907, 5, 1178, 0, 0, 1907, 113, 1, 0, 0, 0, 1908, 1909, 5, 199, 0, + 0, 1909, 1910, 5, 59, 0, 0, 1910, 1913, 3, 1230, 615, 0, 1911, 1912, 5, + 68, 0, 0, 1912, 1914, 3, 1230, 615, 0, 1913, 1911, 1, 0, 0, 0, 1913, 1914, + 1, 0, 0, 0, 1914, 1915, 1, 0, 0, 0, 1915, 1920, 5, 380, 0, 0, 1916, 1918, + 5, 1208, 0, 0, 1917, 1916, 1, 0, 0, 0, 1917, 1918, 1, 0, 0, 0, 1918, 1919, + 1, 0, 0, 0, 1919, 1921, 7, 7, 0, 0, 1920, 1917, 1, 0, 0, 0, 1921, 1922, + 1, 0, 0, 0, 1922, 1920, 1, 0, 0, 0, 1922, 1923, 1, 0, 0, 0, 1923, 1928, + 1, 0, 0, 0, 1924, 1925, 5, 1077, 0, 0, 1925, 1926, 5, 713, 0, 0, 1926, + 1927, 5, 1188, 0, 0, 1927, 1929, 7, 6, 0, 0, 1928, 1924, 1, 0, 0, 0, 1928, + 1929, 1, 0, 0, 0, 1929, 115, 1, 0, 0, 0, 1930, 1931, 5, 282, 0, 0, 1931, + 1934, 5, 59, 0, 0, 1932, 1933, 5, 440, 0, 0, 1933, 1935, 5, 322, 0, 0, + 1934, 1932, 1, 0, 0, 0, 1934, 1935, 1, 0, 0, 0, 1935, 1940, 1, 0, 0, 0, + 1936, 1938, 5, 1208, 0, 0, 1937, 1936, 1, 0, 0, 0, 1937, 1938, 1, 0, 0, + 0, 1938, 1939, 1, 0, 0, 0, 1939, 1941, 3, 1230, 615, 0, 1940, 1937, 1, + 0, 0, 0, 1941, 1942, 1, 0, 0, 0, 1942, 1940, 1, 0, 0, 0, 1942, 1943, 1, + 0, 0, 0, 1943, 1947, 1, 0, 0, 0, 1944, 1945, 5, 1077, 0, 0, 1945, 1946, + 5, 609, 0, 0, 1946, 1948, 5, 258, 0, 0, 1947, 1944, 1, 0, 0, 0, 1947, 1948, + 1, 0, 0, 0, 1948, 117, 1, 0, 0, 0, 1949, 1950, 3, 120, 60, 0, 1950, 1955, + 3, 1230, 615, 0, 1951, 1956, 3, 122, 61, 0, 1952, 1953, 5, 794, 0, 0, 1953, + 1954, 5, 736, 0, 0, 1954, 1956, 5, 498, 0, 0, 1955, 1951, 1, 0, 0, 0, 1955, + 1952, 1, 0, 0, 0, 1956, 119, 1, 0, 0, 0, 1957, 1958, 5, 35, 0, 0, 1958, + 1959, 5, 61, 0, 0, 1959, 1960, 5, 498, 0, 0, 1960, 121, 1, 0, 0, 0, 1961, + 1962, 3, 124, 62, 0, 1962, 1965, 3, 126, 63, 0, 1963, 1964, 5, 1208, 0, + 0, 1964, 1966, 3, 126, 63, 0, 1965, 1963, 1, 0, 0, 0, 1965, 1966, 1, 0, + 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1968, 5, 1207, 0, 0, 1968, 123, 1, + 0, 0, 0, 1969, 1970, 5, 1077, 0, 0, 1970, 1971, 5, 736, 0, 0, 1971, 1972, + 5, 498, 0, 0, 1972, 1973, 5, 1206, 0, 0, 1973, 125, 1, 0, 0, 0, 1974, 1975, + 5, 244, 0, 0, 1975, 1976, 5, 111, 0, 0, 1976, 1977, 5, 703, 0, 0, 1977, + 1978, 5, 1188, 0, 0, 1978, 1985, 5, 1184, 0, 0, 1979, 1980, 5, 297, 0, + 0, 1980, 1981, 5, 111, 0, 0, 1981, 1982, 5, 703, 0, 0, 1982, 1983, 5, 1188, + 0, 0, 1983, 1985, 5, 1184, 0, 0, 1984, 1974, 1, 0, 0, 0, 1984, 1979, 1, + 0, 0, 0, 1985, 127, 1, 0, 0, 0, 1986, 1987, 5, 199, 0, 0, 1987, 1988, 5, + 61, 0, 0, 1988, 1989, 5, 498, 0, 0, 1989, 1992, 3, 1230, 615, 0, 1990, + 1991, 5, 68, 0, 0, 1991, 1993, 3, 1230, 615, 0, 1992, 1990, 1, 0, 0, 0, + 1992, 1993, 1, 0, 0, 0, 1993, 2007, 1, 0, 0, 0, 1994, 2005, 5, 380, 0, + 0, 1995, 1996, 5, 343, 0, 0, 1996, 1997, 5, 1188, 0, 0, 1997, 2006, 5, + 1184, 0, 0, 1998, 1999, 5, 319, 0, 0, 1999, 2000, 5, 1188, 0, 0, 2000, + 2006, 5, 1184, 0, 0, 2001, 2002, 5, 59, 0, 0, 2002, 2006, 3, 1230, 615, + 0, 2003, 2004, 5, 746, 0, 0, 2004, 2006, 3, 1230, 615, 0, 2005, 1995, 1, + 0, 0, 0, 2005, 1998, 1, 0, 0, 0, 2005, 2001, 1, 0, 0, 0, 2005, 2003, 1, + 0, 0, 0, 2006, 2008, 1, 0, 0, 0, 2007, 1994, 1, 0, 0, 0, 2007, 2008, 1, + 0, 0, 0, 2008, 2021, 1, 0, 0, 0, 2009, 2019, 5, 1077, 0, 0, 2010, 2011, + 5, 21, 0, 0, 2011, 2012, 5, 1188, 0, 0, 2012, 2020, 7, 8, 0, 0, 2013, 2014, + 5, 747, 0, 0, 2014, 2015, 5, 1188, 0, 0, 2015, 2020, 5, 1184, 0, 0, 2016, + 2017, 5, 201, 0, 0, 2017, 2018, 5, 1188, 0, 0, 2018, 2020, 7, 9, 0, 0, + 2019, 2010, 1, 0, 0, 0, 2019, 2013, 1, 0, 0, 0, 2019, 2016, 1, 0, 0, 0, + 2020, 2022, 1, 0, 0, 0, 2021, 2009, 1, 0, 0, 0, 2021, 2022, 1, 0, 0, 0, + 2022, 2028, 1, 0, 0, 0, 2023, 2024, 5, 297, 0, 0, 2024, 2025, 5, 111, 0, + 0, 2025, 2026, 5, 703, 0, 0, 2026, 2027, 5, 1188, 0, 0, 2027, 2029, 5, + 1184, 0, 0, 2028, 2023, 1, 0, 0, 0, 2028, 2029, 1, 0, 0, 0, 2029, 129, + 1, 0, 0, 0, 2030, 2031, 5, 282, 0, 0, 2031, 2032, 5, 61, 0, 0, 2032, 2033, + 5, 498, 0, 0, 2033, 2037, 3, 1230, 615, 0, 2034, 2035, 5, 794, 0, 0, 2035, + 2036, 5, 746, 0, 0, 2036, 2038, 5, 498, 0, 0, 2037, 2034, 1, 0, 0, 0, 2037, + 2038, 1, 0, 0, 0, 2038, 131, 1, 0, 0, 0, 2039, 2043, 3, 140, 70, 0, 2040, + 2041, 3, 148, 74, 0, 2041, 2042, 3, 138, 69, 0, 2042, 2044, 1, 0, 0, 0, + 2043, 2040, 1, 0, 0, 0, 2043, 2044, 1, 0, 0, 0, 2044, 2045, 1, 0, 0, 0, + 2045, 2046, 3, 1158, 579, 0, 2046, 2047, 3, 136, 68, 0, 2047, 2048, 3, + 134, 67, 0, 2048, 133, 1, 0, 0, 0, 2049, 2053, 3, 1230, 615, 0, 2050, 2051, + 5, 857, 0, 0, 2051, 2053, 5, 687, 0, 0, 2052, 2049, 1, 0, 0, 0, 2052, 2050, + 1, 0, 0, 0, 2053, 135, 1, 0, 0, 0, 2054, 2055, 5, 1000, 0, 0, 2055, 137, + 1, 0, 0, 0, 2056, 2057, 5, 1211, 0, 0, 2057, 139, 1, 0, 0, 0, 2058, 2059, + 5, 35, 0, 0, 2059, 2060, 5, 68, 0, 0, 2060, 2061, 5, 662, 0, 0, 2061, 141, + 1, 0, 0, 0, 2062, 2066, 3, 140, 70, 0, 2063, 2064, 3, 150, 75, 0, 2064, + 2065, 3, 138, 69, 0, 2065, 2067, 1, 0, 0, 0, 2066, 2063, 1, 0, 0, 0, 2066, + 2067, 1, 0, 0, 0, 2067, 2068, 1, 0, 0, 0, 2068, 2069, 3, 1158, 579, 0, + 2069, 2070, 3, 136, 68, 0, 2070, 2071, 3, 134, 67, 0, 2071, 143, 1, 0, + 0, 0, 2072, 2076, 3, 140, 70, 0, 2073, 2074, 3, 152, 76, 0, 2074, 2075, + 3, 138, 69, 0, 2075, 2077, 1, 0, 0, 0, 2076, 2073, 1, 0, 0, 0, 2076, 2077, + 1, 0, 0, 0, 2077, 2078, 1, 0, 0, 0, 2078, 2079, 3, 1160, 580, 0, 2079, + 2080, 3, 136, 68, 0, 2080, 2081, 3, 134, 67, 0, 2081, 145, 1, 0, 0, 0, + 2082, 2086, 3, 140, 70, 0, 2083, 2084, 3, 154, 77, 0, 2084, 2085, 3, 138, + 69, 0, 2085, 2087, 1, 0, 0, 0, 2086, 2083, 1, 0, 0, 0, 2086, 2087, 1, 0, + 0, 0, 2087, 2088, 1, 0, 0, 0, 2088, 2089, 3, 1162, 581, 0, 2089, 2090, + 3, 136, 68, 0, 2090, 2091, 3, 134, 67, 0, 2091, 147, 1, 0, 0, 0, 2092, + 2127, 5, 648, 0, 0, 2093, 2127, 5, 59, 0, 0, 2094, 2095, 5, 61, 0, 0, 2095, + 2127, 5, 498, 0, 0, 2096, 2097, 5, 81, 0, 0, 2097, 2127, 5, 412, 0, 0, + 2098, 2127, 5, 123, 0, 0, 2099, 2127, 5, 188, 0, 0, 2100, 2127, 5, 1024, + 0, 0, 2101, 2127, 5, 219, 0, 0, 2102, 2127, 5, 300, 0, 0, 2103, 2104, 5, + 383, 0, 0, 2104, 2127, 5, 119, 0, 0, 2105, 2106, 5, 383, 0, 0, 2106, 2127, + 5, 956, 0, 0, 2107, 2108, 5, 578, 0, 0, 2108, 2127, 5, 1024, 0, 0, 2109, + 2110, 5, 791, 0, 0, 2110, 2111, 5, 891, 0, 0, 2111, 2127, 5, 96, 0, 0, + 2112, 2127, 5, 832, 0, 0, 2113, 2127, 5, 836, 0, 0, 2114, 2127, 5, 857, + 0, 0, 2115, 2116, 5, 867, 0, 0, 2116, 2117, 5, 745, 0, 0, 2117, 2127, 5, + 524, 0, 0, 2118, 2119, 5, 889, 0, 0, 2119, 2127, 5, 832, 0, 0, 2120, 2127, + 5, 891, 0, 0, 2121, 2122, 5, 975, 0, 0, 2122, 2127, 5, 498, 0, 0, 2123, + 2124, 5, 1088, 0, 0, 2124, 2125, 5, 857, 0, 0, 2125, 2127, 5, 154, 0, 0, + 2126, 2092, 1, 0, 0, 0, 2126, 2093, 1, 0, 0, 0, 2126, 2094, 1, 0, 0, 0, + 2126, 2096, 1, 0, 0, 0, 2126, 2098, 1, 0, 0, 0, 2126, 2099, 1, 0, 0, 0, + 2126, 2100, 1, 0, 0, 0, 2126, 2101, 1, 0, 0, 0, 2126, 2102, 1, 0, 0, 0, + 2126, 2103, 1, 0, 0, 0, 2126, 2105, 1, 0, 0, 0, 2126, 2107, 1, 0, 0, 0, + 2126, 2109, 1, 0, 0, 0, 2126, 2112, 1, 0, 0, 0, 2126, 2113, 1, 0, 0, 0, + 2126, 2114, 1, 0, 0, 0, 2126, 2115, 1, 0, 0, 0, 2126, 2118, 1, 0, 0, 0, + 2126, 2120, 1, 0, 0, 0, 2126, 2121, 1, 0, 0, 0, 2126, 2123, 1, 0, 0, 0, + 2127, 149, 1, 0, 0, 0, 2128, 2150, 5, 648, 0, 0, 2129, 2150, 5, 59, 0, + 0, 2130, 2131, 5, 61, 0, 0, 2131, 2150, 5, 498, 0, 0, 2132, 2150, 5, 123, + 0, 0, 2133, 2150, 5, 1024, 0, 0, 2134, 2150, 5, 219, 0, 0, 2135, 2136, + 5, 383, 0, 0, 2136, 2150, 5, 119, 0, 0, 2137, 2138, 5, 383, 0, 0, 2138, + 2150, 5, 956, 0, 0, 2139, 2150, 5, 832, 0, 0, 2140, 2150, 5, 857, 0, 0, + 2141, 2142, 5, 867, 0, 0, 2142, 2143, 5, 745, 0, 0, 2143, 2150, 5, 524, + 0, 0, 2144, 2145, 5, 975, 0, 0, 2145, 2150, 5, 498, 0, 0, 2146, 2147, 5, + 1088, 0, 0, 2147, 2148, 5, 857, 0, 0, 2148, 2150, 5, 154, 0, 0, 2149, 2128, + 1, 0, 0, 0, 2149, 2129, 1, 0, 0, 0, 2149, 2130, 1, 0, 0, 0, 2149, 2132, + 1, 0, 0, 0, 2149, 2133, 1, 0, 0, 0, 2149, 2134, 1, 0, 0, 0, 2149, 2135, + 1, 0, 0, 0, 2149, 2137, 1, 0, 0, 0, 2149, 2139, 1, 0, 0, 0, 2149, 2140, + 1, 0, 0, 0, 2149, 2141, 1, 0, 0, 0, 2149, 2144, 1, 0, 0, 0, 2149, 2146, + 1, 0, 0, 0, 2150, 151, 1, 0, 0, 0, 2151, 2152, 7, 10, 0, 0, 2152, 153, + 1, 0, 0, 0, 2153, 2154, 7, 11, 0, 0, 2154, 155, 1, 0, 0, 0, 2155, 2156, + 5, 48, 0, 0, 2156, 2247, 5, 832, 0, 0, 2157, 2247, 5, 59, 0, 0, 2158, 2159, + 5, 61, 0, 0, 2159, 2247, 5, 498, 0, 0, 2160, 2247, 5, 64, 0, 0, 2161, 2162, + 5, 81, 0, 0, 2162, 2247, 5, 412, 0, 0, 2163, 2164, 5, 104, 0, 0, 2164, + 2247, 5, 734, 0, 0, 2165, 2247, 5, 123, 0, 0, 2166, 2167, 5, 155, 0, 0, + 2167, 2168, 7, 12, 0, 0, 2168, 2247, 5, 498, 0, 0, 2169, 2247, 5, 188, + 0, 0, 2170, 2247, 5, 202, 0, 0, 2171, 2172, 5, 204, 0, 0, 2172, 2247, 5, + 746, 0, 0, 2173, 2187, 5, 219, 0, 0, 2174, 2175, 5, 64, 0, 0, 2175, 2188, + 5, 931, 0, 0, 2176, 2177, 5, 297, 0, 0, 2177, 2188, 5, 498, 0, 0, 2178, + 2179, 5, 313, 0, 0, 2179, 2188, 5, 895, 0, 0, 2180, 2185, 5, 862, 0, 0, + 2181, 2186, 5, 175, 0, 0, 2182, 2186, 5, 202, 0, 0, 2183, 2184, 5, 813, + 0, 0, 2184, 2186, 5, 409, 0, 0, 2185, 2181, 1, 0, 0, 0, 2185, 2182, 1, + 0, 0, 0, 2185, 2183, 1, 0, 0, 0, 2186, 2188, 1, 0, 0, 0, 2187, 2174, 1, + 0, 0, 0, 2187, 2176, 1, 0, 0, 0, 2187, 2178, 1, 0, 0, 0, 2187, 2180, 1, + 0, 0, 0, 2187, 2188, 1, 0, 0, 0, 2188, 2247, 1, 0, 0, 0, 2189, 2247, 5, + 300, 0, 0, 2190, 2191, 5, 313, 0, 0, 2191, 2247, 5, 895, 0, 0, 2192, 2193, + 5, 628, 0, 0, 2193, 2247, 7, 13, 0, 0, 2194, 2205, 5, 331, 0, 0, 2195, + 2196, 5, 218, 0, 0, 2196, 2206, 5, 926, 0, 0, 2197, 2198, 5, 343, 0, 0, + 2198, 2206, 5, 374, 0, 0, 2199, 2206, 5, 518, 0, 0, 2200, 2201, 5, 813, + 0, 0, 2201, 2206, 5, 725, 0, 0, 2202, 2206, 5, 980, 0, 0, 2203, 2206, 5, + 119, 0, 0, 2204, 2206, 5, 956, 0, 0, 2205, 2195, 1, 0, 0, 0, 2205, 2197, + 1, 0, 0, 0, 2205, 2199, 1, 0, 0, 0, 2205, 2200, 1, 0, 0, 0, 2205, 2202, + 1, 0, 0, 0, 2205, 2203, 1, 0, 0, 0, 2205, 2204, 1, 0, 0, 0, 2206, 2247, + 1, 0, 0, 0, 2207, 2247, 5, 537, 0, 0, 2208, 2209, 5, 547, 0, 0, 2209, 2247, + 5, 498, 0, 0, 2210, 2211, 5, 578, 0, 0, 2211, 2247, 5, 1024, 0, 0, 2212, + 2247, 5, 648, 0, 0, 2213, 2214, 5, 700, 0, 0, 2214, 2247, 7, 14, 0, 0, + 2215, 2216, 5, 791, 0, 0, 2216, 2217, 5, 891, 0, 0, 2217, 2247, 5, 96, + 0, 0, 2218, 2219, 5, 813, 0, 0, 2219, 2247, 5, 409, 0, 0, 2220, 2247, 5, + 832, 0, 0, 2221, 2247, 5, 836, 0, 0, 2222, 2247, 5, 857, 0, 0, 2223, 2224, + 5, 867, 0, 0, 2224, 2225, 5, 745, 0, 0, 2225, 2247, 5, 524, 0, 0, 2226, + 2232, 5, 889, 0, 0, 2227, 2229, 5, 64, 0, 0, 2228, 2230, 5, 931, 0, 0, + 2229, 2228, 1, 0, 0, 0, 2229, 2230, 1, 0, 0, 0, 2230, 2233, 1, 0, 0, 0, + 2231, 2233, 5, 832, 0, 0, 2232, 2227, 1, 0, 0, 0, 2232, 2231, 1, 0, 0, + 0, 2232, 2233, 1, 0, 0, 0, 2233, 2247, 1, 0, 0, 0, 2234, 2247, 5, 891, + 0, 0, 2235, 2236, 5, 933, 0, 0, 2236, 2247, 5, 537, 0, 0, 2237, 2238, 5, + 975, 0, 0, 2238, 2247, 5, 498, 0, 0, 2239, 2240, 5, 1013, 0, 0, 2240, 2247, + 7, 15, 0, 0, 2241, 2247, 5, 1024, 0, 0, 2242, 2247, 5, 1049, 0, 0, 2243, + 2244, 5, 1088, 0, 0, 2244, 2245, 5, 857, 0, 0, 2245, 2247, 5, 154, 0, 0, + 2246, 2155, 1, 0, 0, 0, 2246, 2157, 1, 0, 0, 0, 2246, 2158, 1, 0, 0, 0, + 2246, 2160, 1, 0, 0, 0, 2246, 2161, 1, 0, 0, 0, 2246, 2163, 1, 0, 0, 0, + 2246, 2165, 1, 0, 0, 0, 2246, 2166, 1, 0, 0, 0, 2246, 2169, 1, 0, 0, 0, + 2246, 2170, 1, 0, 0, 0, 2246, 2171, 1, 0, 0, 0, 2246, 2173, 1, 0, 0, 0, + 2246, 2189, 1, 0, 0, 0, 2246, 2190, 1, 0, 0, 0, 2246, 2192, 1, 0, 0, 0, + 2246, 2194, 1, 0, 0, 0, 2246, 2207, 1, 0, 0, 0, 2246, 2208, 1, 0, 0, 0, + 2246, 2210, 1, 0, 0, 0, 2246, 2212, 1, 0, 0, 0, 2246, 2213, 1, 0, 0, 0, + 2246, 2215, 1, 0, 0, 0, 2246, 2218, 1, 0, 0, 0, 2246, 2220, 1, 0, 0, 0, + 2246, 2221, 1, 0, 0, 0, 2246, 2222, 1, 0, 0, 0, 2246, 2223, 1, 0, 0, 0, + 2246, 2226, 1, 0, 0, 0, 2246, 2234, 1, 0, 0, 0, 2246, 2235, 1, 0, 0, 0, + 2246, 2237, 1, 0, 0, 0, 2246, 2239, 1, 0, 0, 0, 2246, 2241, 1, 0, 0, 0, + 2246, 2242, 1, 0, 0, 0, 2246, 2243, 1, 0, 0, 0, 2247, 157, 1, 0, 0, 0, + 2248, 2249, 5, 282, 0, 0, 2249, 2250, 5, 81, 0, 0, 2250, 2251, 5, 412, + 0, 0, 2251, 2252, 3, 1230, 615, 0, 2252, 159, 1, 0, 0, 0, 2253, 2254, 3, + 162, 81, 0, 2254, 2255, 3, 164, 82, 0, 2255, 161, 1, 0, 0, 0, 2256, 2257, + 5, 35, 0, 0, 2257, 2258, 5, 81, 0, 0, 2258, 2259, 5, 412, 0, 0, 2259, 2260, + 3, 1230, 615, 0, 2260, 163, 1, 0, 0, 0, 2261, 2262, 5, 900, 0, 0, 2262, + 2278, 5, 1206, 0, 0, 2263, 2264, 5, 72, 0, 0, 2264, 2265, 5, 1188, 0, 0, + 2265, 2279, 7, 16, 0, 0, 2266, 2267, 5, 337, 0, 0, 2267, 2268, 5, 1188, + 0, 0, 2268, 2279, 5, 1182, 0, 0, 2269, 2270, 5, 423, 0, 0, 2270, 2271, + 5, 1188, 0, 0, 2271, 2279, 5, 1182, 0, 0, 2272, 2273, 5, 237, 0, 0, 2273, + 2274, 5, 1188, 0, 0, 2274, 2279, 7, 17, 0, 0, 2275, 2276, 5, 809, 0, 0, + 2276, 2277, 5, 1188, 0, 0, 2277, 2279, 5, 1182, 0, 0, 2278, 2263, 1, 0, + 0, 0, 2278, 2266, 1, 0, 0, 0, 2278, 2269, 1, 0, 0, 0, 2278, 2272, 1, 0, + 0, 0, 2278, 2275, 1, 0, 0, 0, 2279, 2280, 1, 0, 0, 0, 2280, 2617, 5, 1207, + 0, 0, 2281, 2282, 5, 11, 0, 0, 2282, 2283, 5, 219, 0, 0, 2283, 2617, 3, + 1230, 615, 0, 2284, 2285, 5, 794, 0, 0, 2285, 2286, 5, 219, 0, 0, 2286, + 2617, 3, 1230, 615, 0, 2287, 2288, 5, 11, 0, 0, 2288, 2289, 5, 802, 0, + 0, 2289, 2290, 5, 662, 0, 0, 2290, 2291, 5, 1184, 0, 0, 2291, 2292, 5, + 1077, 0, 0, 2292, 2296, 5, 1206, 0, 0, 2293, 2294, 5, 301, 0, 0, 2294, + 2295, 5, 1188, 0, 0, 2295, 2297, 5, 1184, 0, 0, 2296, 2293, 1, 0, 0, 0, + 2296, 2297, 1, 0, 0, 0, 2297, 2304, 1, 0, 0, 0, 2298, 2300, 5, 1208, 0, + 0, 2299, 2298, 1, 0, 0, 0, 2299, 2300, 1, 0, 0, 0, 2300, 2301, 1, 0, 0, + 0, 2301, 2302, 5, 82, 0, 0, 2302, 2303, 5, 1188, 0, 0, 2303, 2305, 7, 18, + 0, 0, 2304, 2299, 1, 0, 0, 0, 2304, 2305, 1, 0, 0, 0, 2305, 2312, 1, 0, + 0, 0, 2306, 2308, 5, 1208, 0, 0, 2307, 2306, 1, 0, 0, 0, 2307, 2308, 1, + 0, 0, 0, 2308, 2309, 1, 0, 0, 0, 2309, 2310, 5, 334, 0, 0, 2310, 2311, + 5, 1188, 0, 0, 2311, 2313, 7, 19, 0, 0, 2312, 2307, 1, 0, 0, 0, 2312, 2313, + 1, 0, 0, 0, 2313, 2320, 1, 0, 0, 0, 2314, 2316, 5, 1208, 0, 0, 2315, 2314, + 1, 0, 0, 0, 2315, 2316, 1, 0, 0, 0, 2316, 2317, 1, 0, 0, 0, 2317, 2318, + 5, 877, 0, 0, 2318, 2319, 5, 1188, 0, 0, 2319, 2321, 7, 19, 0, 0, 2320, + 2315, 1, 0, 0, 0, 2320, 2321, 1, 0, 0, 0, 2321, 2328, 1, 0, 0, 0, 2322, + 2324, 5, 1208, 0, 0, 2323, 2322, 1, 0, 0, 0, 2323, 2324, 1, 0, 0, 0, 2324, + 2325, 1, 0, 0, 0, 2325, 2326, 5, 87, 0, 0, 2326, 2327, 5, 1188, 0, 0, 2327, + 2329, 5, 1182, 0, 0, 2328, 2323, 1, 0, 0, 0, 2328, 2329, 1, 0, 0, 0, 2329, + 2339, 1, 0, 0, 0, 2330, 2332, 5, 1208, 0, 0, 2331, 2330, 1, 0, 0, 0, 2331, + 2332, 1, 0, 0, 0, 2332, 2333, 1, 0, 0, 0, 2333, 2334, 5, 731, 0, 0, 2334, + 2335, 5, 1206, 0, 0, 2335, 2336, 5, 24, 0, 0, 2336, 2337, 5, 1188, 0, 0, + 2337, 2338, 7, 20, 0, 0, 2338, 2340, 5, 1207, 0, 0, 2339, 2331, 1, 0, 0, + 0, 2339, 2340, 1, 0, 0, 0, 2340, 2350, 1, 0, 0, 0, 2341, 2343, 5, 1208, + 0, 0, 2342, 2341, 1, 0, 0, 0, 2342, 2343, 1, 0, 0, 0, 2343, 2344, 1, 0, + 0, 0, 2344, 2345, 5, 870, 0, 0, 2345, 2346, 5, 1206, 0, 0, 2346, 2347, + 5, 24, 0, 0, 2347, 2348, 5, 1188, 0, 0, 2348, 2349, 5, 776, 0, 0, 2349, + 2351, 5, 1207, 0, 0, 2350, 2342, 1, 0, 0, 0, 2350, 2351, 1, 0, 0, 0, 2351, + 2352, 1, 0, 0, 0, 2352, 2617, 5, 1207, 0, 0, 2353, 2354, 5, 870, 0, 0, + 2354, 2363, 5, 1206, 0, 0, 2355, 2356, 5, 24, 0, 0, 2356, 2357, 5, 1188, + 0, 0, 2357, 2364, 7, 21, 0, 0, 2358, 2359, 5, 777, 0, 0, 2359, 2360, 5, + 1188, 0, 0, 2360, 2361, 5, 1206, 0, 0, 2361, 2362, 5, 1184, 0, 0, 2362, + 2364, 5, 1207, 0, 0, 2363, 2355, 1, 0, 0, 0, 2363, 2358, 1, 0, 0, 0, 2364, + 2617, 1, 0, 0, 0, 2365, 2366, 5, 731, 0, 0, 2366, 2389, 5, 1206, 0, 0, + 2367, 2368, 5, 24, 0, 0, 2368, 2369, 5, 1188, 0, 0, 2369, 2390, 7, 21, + 0, 0, 2370, 2371, 5, 777, 0, 0, 2371, 2372, 5, 1188, 0, 0, 2372, 2383, + 5, 1206, 0, 0, 2373, 2375, 5, 1208, 0, 0, 2374, 2373, 1, 0, 0, 0, 2374, + 2375, 1, 0, 0, 0, 2375, 2376, 1, 0, 0, 0, 2376, 2378, 5, 1184, 0, 0, 2377, + 2374, 1, 0, 0, 0, 2378, 2381, 1, 0, 0, 0, 2379, 2377, 1, 0, 0, 0, 2379, + 2380, 1, 0, 0, 0, 2380, 2384, 1, 0, 0, 0, 2381, 2379, 1, 0, 0, 0, 2382, + 2384, 5, 621, 0, 0, 2383, 2379, 1, 0, 0, 0, 2383, 2382, 1, 0, 0, 0, 2384, + 2385, 1, 0, 0, 0, 2385, 2390, 5, 1207, 0, 0, 2386, 2387, 5, 898, 0, 0, + 2387, 2388, 5, 1188, 0, 0, 2388, 2390, 5, 1182, 0, 0, 2389, 2367, 1, 0, + 0, 0, 2389, 2370, 1, 0, 0, 0, 2389, 2386, 1, 0, 0, 0, 2390, 2617, 1, 0, + 0, 0, 2391, 2392, 5, 592, 0, 0, 2392, 2393, 5, 802, 0, 0, 2393, 2394, 5, + 662, 0, 0, 2394, 2452, 5, 1184, 0, 0, 2395, 2396, 5, 1077, 0, 0, 2396, + 2412, 5, 1206, 0, 0, 2397, 2398, 5, 301, 0, 0, 2398, 2399, 5, 1188, 0, + 0, 2399, 2413, 5, 1184, 0, 0, 2400, 2401, 5, 82, 0, 0, 2401, 2402, 5, 1188, + 0, 0, 2402, 2413, 7, 18, 0, 0, 2403, 2404, 5, 334, 0, 0, 2404, 2405, 5, + 1188, 0, 0, 2405, 2413, 7, 19, 0, 0, 2406, 2407, 5, 877, 0, 0, 2407, 2408, + 5, 1188, 0, 0, 2408, 2413, 7, 19, 0, 0, 2409, 2410, 5, 87, 0, 0, 2410, + 2411, 5, 1188, 0, 0, 2411, 2413, 5, 1182, 0, 0, 2412, 2397, 1, 0, 0, 0, + 2412, 2400, 1, 0, 0, 0, 2412, 2403, 1, 0, 0, 0, 2412, 2406, 1, 0, 0, 0, + 2412, 2409, 1, 0, 0, 0, 2413, 2453, 1, 0, 0, 0, 2414, 2415, 5, 870, 0, + 0, 2415, 2424, 5, 1206, 0, 0, 2416, 2417, 5, 24, 0, 0, 2417, 2418, 5, 1188, + 0, 0, 2418, 2425, 7, 21, 0, 0, 2419, 2420, 5, 777, 0, 0, 2420, 2421, 5, + 1188, 0, 0, 2421, 2422, 5, 1206, 0, 0, 2422, 2423, 5, 1184, 0, 0, 2423, + 2425, 5, 1207, 0, 0, 2424, 2416, 1, 0, 0, 0, 2424, 2419, 1, 0, 0, 0, 2425, + 2453, 1, 0, 0, 0, 2426, 2427, 5, 731, 0, 0, 2427, 2450, 5, 1206, 0, 0, + 2428, 2429, 5, 24, 0, 0, 2429, 2430, 5, 1188, 0, 0, 2430, 2451, 7, 21, + 0, 0, 2431, 2432, 5, 777, 0, 0, 2432, 2433, 5, 1188, 0, 0, 2433, 2444, + 5, 1206, 0, 0, 2434, 2436, 5, 1208, 0, 0, 2435, 2434, 1, 0, 0, 0, 2435, + 2436, 1, 0, 0, 0, 2436, 2437, 1, 0, 0, 0, 2437, 2439, 5, 1184, 0, 0, 2438, + 2435, 1, 0, 0, 0, 2439, 2442, 1, 0, 0, 0, 2440, 2438, 1, 0, 0, 0, 2440, + 2441, 1, 0, 0, 0, 2441, 2445, 1, 0, 0, 0, 2442, 2440, 1, 0, 0, 0, 2443, + 2445, 5, 621, 0, 0, 2444, 2440, 1, 0, 0, 0, 2444, 2443, 1, 0, 0, 0, 2445, + 2446, 1, 0, 0, 0, 2446, 2451, 5, 1207, 0, 0, 2447, 2448, 5, 898, 0, 0, + 2448, 2449, 5, 1188, 0, 0, 2449, 2451, 5, 1182, 0, 0, 2450, 2428, 1, 0, + 0, 0, 2450, 2431, 1, 0, 0, 0, 2450, 2447, 1, 0, 0, 0, 2451, 2453, 1, 0, + 0, 0, 2452, 2395, 1, 0, 0, 0, 2452, 2414, 1, 0, 0, 0, 2452, 2426, 1, 0, + 0, 0, 2453, 2454, 1, 0, 0, 0, 2454, 2617, 5, 1207, 0, 0, 2455, 2456, 5, + 794, 0, 0, 2456, 2457, 5, 802, 0, 0, 2457, 2458, 5, 662, 0, 0, 2458, 2617, + 5, 1184, 0, 0, 2459, 2617, 5, 484, 0, 0, 2460, 2461, 5, 484, 0, 0, 2461, + 2462, 5, 81, 0, 0, 2462, 2463, 5, 412, 0, 0, 2463, 2486, 5, 662, 0, 0, + 2464, 2466, 5, 1208, 0, 0, 2465, 2464, 1, 0, 0, 0, 2465, 2466, 1, 0, 0, + 0, 2466, 2467, 1, 0, 0, 0, 2467, 2468, 5, 1184, 0, 0, 2468, 2469, 5, 1077, + 0, 0, 2469, 2470, 5, 1206, 0, 0, 2470, 2471, 5, 528, 0, 0, 2471, 2472, + 5, 1188, 0, 0, 2472, 2473, 5, 1184, 0, 0, 2473, 2474, 5, 1208, 0, 0, 2474, + 2475, 5, 82, 0, 0, 2475, 2476, 5, 1188, 0, 0, 2476, 2477, 7, 18, 0, 0, + 2477, 2478, 5, 1208, 0, 0, 2478, 2479, 5, 334, 0, 0, 2479, 2480, 5, 1188, + 0, 0, 2480, 2481, 5, 543, 0, 0, 2481, 2482, 5, 1208, 0, 0, 2482, 2483, + 5, 877, 0, 0, 2483, 2484, 5, 1188, 0, 0, 2484, 2485, 7, 19, 0, 0, 2485, + 2487, 5, 1207, 0, 0, 2486, 2465, 1, 0, 0, 0, 2487, 2488, 1, 0, 0, 0, 2488, + 2486, 1, 0, 0, 0, 2488, 2489, 1, 0, 0, 0, 2489, 2617, 1, 0, 0, 0, 2490, + 2491, 5, 592, 0, 0, 2491, 2492, 5, 81, 0, 0, 2492, 2493, 5, 412, 0, 0, + 2493, 2528, 5, 662, 0, 0, 2494, 2496, 5, 1208, 0, 0, 2495, 2494, 1, 0, + 0, 0, 2495, 2496, 1, 0, 0, 0, 2496, 2497, 1, 0, 0, 0, 2497, 2498, 5, 1184, + 0, 0, 2498, 2499, 5, 1077, 0, 0, 2499, 2500, 5, 1206, 0, 0, 2500, 2501, + 5, 528, 0, 0, 2501, 2502, 5, 1188, 0, 0, 2502, 2509, 5, 1184, 0, 0, 2503, + 2505, 5, 1208, 0, 0, 2504, 2503, 1, 0, 0, 0, 2504, 2505, 1, 0, 0, 0, 2505, + 2506, 1, 0, 0, 0, 2506, 2507, 5, 82, 0, 0, 2507, 2508, 5, 1188, 0, 0, 2508, + 2510, 7, 18, 0, 0, 2509, 2504, 1, 0, 0, 0, 2509, 2510, 1, 0, 0, 0, 2510, + 2517, 1, 0, 0, 0, 2511, 2513, 5, 1208, 0, 0, 2512, 2511, 1, 0, 0, 0, 2512, + 2513, 1, 0, 0, 0, 2513, 2514, 1, 0, 0, 0, 2514, 2515, 5, 334, 0, 0, 2515, + 2516, 5, 1188, 0, 0, 2516, 2518, 5, 543, 0, 0, 2517, 2512, 1, 0, 0, 0, + 2517, 2518, 1, 0, 0, 0, 2518, 2525, 1, 0, 0, 0, 2519, 2521, 5, 1208, 0, + 0, 2520, 2519, 1, 0, 0, 0, 2520, 2521, 1, 0, 0, 0, 2521, 2522, 1, 0, 0, + 0, 2522, 2523, 5, 877, 0, 0, 2523, 2524, 5, 1188, 0, 0, 2524, 2526, 7, + 19, 0, 0, 2525, 2520, 1, 0, 0, 0, 2525, 2526, 1, 0, 0, 0, 2526, 2527, 1, + 0, 0, 0, 2527, 2529, 5, 1207, 0, 0, 2528, 2495, 1, 0, 0, 0, 2529, 2530, + 1, 0, 0, 0, 2530, 2528, 1, 0, 0, 0, 2530, 2531, 1, 0, 0, 0, 2531, 2617, + 1, 0, 0, 0, 2532, 2533, 5, 410, 0, 0, 2533, 2534, 5, 199, 0, 0, 2534, 2535, + 5, 46, 0, 0, 2535, 2617, 5, 219, 0, 0, 2536, 2537, 5, 257, 0, 0, 2537, + 2538, 5, 199, 0, 0, 2538, 2539, 5, 46, 0, 0, 2539, 2617, 5, 219, 0, 0, + 2540, 2617, 5, 333, 0, 0, 2541, 2617, 5, 371, 0, 0, 2542, 2543, 5, 11, + 0, 0, 2543, 2544, 5, 525, 0, 0, 2544, 2545, 5, 1184, 0, 0, 2545, 2581, + 5, 1206, 0, 0, 2546, 2547, 5, 1077, 0, 0, 2547, 2548, 5, 264, 0, 0, 2548, + 2549, 5, 662, 0, 0, 2549, 2550, 5, 1206, 0, 0, 2550, 2551, 3, 166, 83, + 0, 2551, 2552, 3, 166, 83, 0, 2552, 2553, 5, 1207, 0, 0, 2553, 2582, 1, + 0, 0, 0, 2554, 2555, 5, 1077, 0, 0, 2555, 2556, 5, 473, 0, 0, 2556, 2570, + 5, 1206, 0, 0, 2557, 2559, 5, 1208, 0, 0, 2558, 2557, 1, 0, 0, 0, 2558, + 2559, 1, 0, 0, 0, 2559, 2560, 1, 0, 0, 0, 2560, 2566, 5, 1206, 0, 0, 2561, + 2562, 3, 166, 83, 0, 2562, 2563, 5, 1208, 0, 0, 2563, 2564, 3, 166, 83, + 0, 2564, 2567, 1, 0, 0, 0, 2565, 2567, 3, 168, 84, 0, 2566, 2561, 1, 0, + 0, 0, 2566, 2565, 1, 0, 0, 0, 2567, 2568, 1, 0, 0, 0, 2568, 2569, 5, 1207, + 0, 0, 2569, 2571, 1, 0, 0, 0, 2570, 2558, 1, 0, 0, 0, 2571, 2572, 1, 0, + 0, 0, 2572, 2570, 1, 0, 0, 0, 2572, 2573, 1, 0, 0, 0, 2573, 2574, 1, 0, + 0, 0, 2574, 2579, 5, 1207, 0, 0, 2575, 2576, 5, 1208, 0, 0, 2576, 2577, + 5, 726, 0, 0, 2577, 2578, 5, 1188, 0, 0, 2578, 2580, 5, 1182, 0, 0, 2579, + 2575, 1, 0, 0, 0, 2579, 2580, 1, 0, 0, 0, 2580, 2582, 1, 0, 0, 0, 2581, + 2546, 1, 0, 0, 0, 2581, 2554, 1, 0, 0, 0, 2582, 2583, 1, 0, 0, 0, 2583, + 2584, 5, 1207, 0, 0, 2584, 2617, 1, 0, 0, 0, 2585, 2586, 5, 592, 0, 0, + 2586, 2601, 5, 525, 0, 0, 2587, 2588, 5, 11, 0, 0, 2588, 2589, 5, 473, + 0, 0, 2589, 2594, 5, 1206, 0, 0, 2590, 2591, 3, 166, 83, 0, 2591, 2592, + 3, 166, 83, 0, 2592, 2595, 1, 0, 0, 0, 2593, 2595, 3, 168, 84, 0, 2594, + 2590, 1, 0, 0, 0, 2594, 2593, 1, 0, 0, 0, 2595, 2596, 1, 0, 0, 0, 2596, + 2597, 5, 1207, 0, 0, 2597, 2602, 1, 0, 0, 0, 2598, 2599, 5, 726, 0, 0, + 2599, 2600, 5, 1188, 0, 0, 2600, 2602, 5, 1182, 0, 0, 2601, 2587, 1, 0, + 0, 0, 2601, 2598, 1, 0, 0, 0, 2602, 2617, 1, 0, 0, 0, 2603, 2604, 5, 816, + 0, 0, 2604, 2605, 5, 525, 0, 0, 2605, 2617, 5, 1184, 0, 0, 2606, 2607, + 5, 794, 0, 0, 2607, 2608, 5, 525, 0, 0, 2608, 2617, 5, 1184, 0, 0, 2609, + 2617, 5, 657, 0, 0, 2610, 2611, 5, 1077, 0, 0, 2611, 2612, 5, 1206, 0, + 0, 2612, 2613, 5, 285, 0, 0, 2613, 2614, 5, 1188, 0, 0, 2614, 2615, 5, + 717, 0, 0, 2615, 2617, 5, 1207, 0, 0, 2616, 2261, 1, 0, 0, 0, 2616, 2281, + 1, 0, 0, 0, 2616, 2284, 1, 0, 0, 0, 2616, 2287, 1, 0, 0, 0, 2616, 2353, + 1, 0, 0, 0, 2616, 2365, 1, 0, 0, 0, 2616, 2391, 1, 0, 0, 0, 2616, 2455, + 1, 0, 0, 0, 2616, 2459, 1, 0, 0, 0, 2616, 2460, 1, 0, 0, 0, 2616, 2490, + 1, 0, 0, 0, 2616, 2532, 1, 0, 0, 0, 2616, 2536, 1, 0, 0, 0, 2616, 2540, + 1, 0, 0, 0, 2616, 2541, 1, 0, 0, 0, 2616, 2542, 1, 0, 0, 0, 2616, 2585, + 1, 0, 0, 0, 2616, 2603, 1, 0, 0, 0, 2616, 2606, 1, 0, 0, 0, 2616, 2609, + 1, 0, 0, 0, 2616, 2610, 1, 0, 0, 0, 2617, 165, 1, 0, 0, 0, 2618, 2619, + 5, 1184, 0, 0, 2619, 167, 1, 0, 0, 0, 2620, 2621, 5, 1184, 0, 0, 2621, + 169, 1, 0, 0, 0, 2622, 2623, 7, 22, 0, 0, 2623, 2624, 5, 104, 0, 0, 2624, + 2625, 5, 734, 0, 0, 2625, 2626, 3, 1230, 615, 0, 2626, 2627, 5, 365, 0, + 0, 2627, 2628, 5, 191, 0, 0, 2628, 2629, 5, 900, 0, 0, 2629, 2639, 5, 1206, + 0, 0, 2630, 2631, 5, 189, 0, 0, 2631, 2634, 5, 1188, 0, 0, 2632, 2635, + 3, 1230, 615, 0, 2633, 2635, 5, 46, 0, 0, 2634, 2632, 1, 0, 0, 0, 2634, + 2633, 1, 0, 0, 0, 2635, 2637, 1, 0, 0, 0, 2636, 2638, 5, 1208, 0, 0, 2637, + 2636, 1, 0, 0, 0, 2637, 2638, 1, 0, 0, 0, 2638, 2640, 1, 0, 0, 0, 2639, + 2630, 1, 0, 0, 0, 2639, 2640, 1, 0, 0, 0, 2640, 2653, 1, 0, 0, 0, 2641, + 2642, 5, 532, 0, 0, 2642, 2648, 5, 1188, 0, 0, 2643, 2645, 5, 281, 0, 0, + 2644, 2643, 1, 0, 0, 0, 2644, 2645, 1, 0, 0, 0, 2645, 2646, 1, 0, 0, 0, + 2646, 2649, 3, 1230, 615, 0, 2647, 2649, 5, 46, 0, 0, 2648, 2644, 1, 0, + 0, 0, 2648, 2647, 1, 0, 0, 0, 2649, 2651, 1, 0, 0, 0, 2650, 2652, 5, 1208, + 0, 0, 2651, 2650, 1, 0, 0, 0, 2651, 2652, 1, 0, 0, 0, 2652, 2654, 1, 0, + 0, 0, 2653, 2641, 1, 0, 0, 0, 2653, 2654, 1, 0, 0, 0, 2654, 2664, 1, 0, + 0, 0, 2655, 2656, 5, 793, 0, 0, 2656, 2659, 5, 1188, 0, 0, 2657, 2660, + 5, 1184, 0, 0, 2658, 2660, 5, 46, 0, 0, 2659, 2657, 1, 0, 0, 0, 2659, 2658, + 1, 0, 0, 0, 2660, 2662, 1, 0, 0, 0, 2661, 2663, 5, 1208, 0, 0, 2662, 2661, + 1, 0, 0, 0, 2662, 2663, 1, 0, 0, 0, 2663, 2665, 1, 0, 0, 0, 2664, 2655, + 1, 0, 0, 0, 2664, 2665, 1, 0, 0, 0, 2665, 2672, 1, 0, 0, 0, 2666, 2667, + 5, 735, 0, 0, 2667, 2670, 5, 1188, 0, 0, 2668, 2671, 5, 1182, 0, 0, 2669, + 2671, 5, 245, 0, 0, 2670, 2668, 1, 0, 0, 0, 2670, 2669, 1, 0, 0, 0, 2671, + 2673, 1, 0, 0, 0, 2672, 2666, 1, 0, 0, 0, 2672, 2673, 1, 0, 0, 0, 2673, + 2674, 1, 0, 0, 0, 2674, 2675, 5, 1207, 0, 0, 2675, 171, 1, 0, 0, 0, 2676, + 2677, 5, 282, 0, 0, 2677, 2678, 5, 104, 0, 0, 2678, 2679, 5, 734, 0, 0, + 2679, 2680, 3, 1230, 615, 0, 2680, 173, 1, 0, 0, 0, 2681, 2682, 5, 35, + 0, 0, 2682, 2683, 5, 123, 0, 0, 2683, 2723, 3, 1230, 615, 0, 2684, 2685, + 5, 794, 0, 0, 2685, 2724, 5, 737, 0, 0, 2686, 2687, 5, 1077, 0, 0, 2687, + 2688, 5, 736, 0, 0, 2688, 2689, 5, 498, 0, 0, 2689, 2712, 5, 1206, 0, 0, + 2690, 2691, 5, 343, 0, 0, 2691, 2692, 5, 1188, 0, 0, 2692, 2694, 5, 1184, + 0, 0, 2693, 2695, 5, 1208, 0, 0, 2694, 2693, 1, 0, 0, 0, 2694, 2695, 1, + 0, 0, 0, 2695, 2713, 1, 0, 0, 0, 2696, 2697, 5, 244, 0, 0, 2697, 2698, + 5, 111, 0, 0, 2698, 2699, 5, 703, 0, 0, 2699, 2700, 5, 1188, 0, 0, 2700, + 2702, 5, 1184, 0, 0, 2701, 2703, 5, 1208, 0, 0, 2702, 2701, 1, 0, 0, 0, + 2702, 2703, 1, 0, 0, 0, 2703, 2713, 1, 0, 0, 0, 2704, 2705, 5, 297, 0, + 0, 2705, 2706, 5, 111, 0, 0, 2706, 2707, 5, 703, 0, 0, 2707, 2708, 5, 1188, + 0, 0, 2708, 2710, 5, 1184, 0, 0, 2709, 2711, 5, 1208, 0, 0, 2710, 2709, + 1, 0, 0, 0, 2710, 2711, 1, 0, 0, 0, 2711, 2713, 1, 0, 0, 0, 2712, 2690, + 1, 0, 0, 0, 2712, 2696, 1, 0, 0, 0, 2712, 2704, 1, 0, 0, 0, 2713, 2714, + 1, 0, 0, 0, 2714, 2712, 1, 0, 0, 0, 2714, 2715, 1, 0, 0, 0, 2715, 2716, + 1, 0, 0, 0, 2716, 2724, 5, 1207, 0, 0, 2717, 2718, 5, 1077, 0, 0, 2718, + 2719, 5, 10, 0, 0, 2719, 2720, 5, 365, 0, 0, 2720, 2721, 5, 91, 0, 0, 2721, + 2722, 5, 1188, 0, 0, 2722, 2724, 7, 17, 0, 0, 2723, 2684, 1, 0, 0, 0, 2723, + 2686, 1, 0, 0, 0, 2723, 2717, 1, 0, 0, 0, 2724, 175, 1, 0, 0, 0, 2725, + 2726, 5, 35, 0, 0, 2726, 2727, 5, 155, 0, 0, 2727, 2728, 5, 297, 0, 0, + 2728, 2729, 5, 498, 0, 0, 2729, 2730, 3, 1230, 615, 0, 2730, 2731, 7, 23, + 0, 0, 2731, 2732, 5, 1055, 0, 0, 2732, 2733, 5, 1206, 0, 0, 2733, 2734, + 5, 161, 0, 0, 2734, 2735, 5, 1188, 0, 0, 2735, 2744, 3, 1230, 615, 0, 2736, + 2737, 5, 1208, 0, 0, 2737, 2738, 5, 21, 0, 0, 2738, 2739, 5, 1188, 0, 0, + 2739, 2740, 5, 1184, 0, 0, 2740, 2741, 5, 1208, 0, 0, 2741, 2742, 5, 296, + 0, 0, 2742, 2743, 5, 1188, 0, 0, 2743, 2745, 5, 1185, 0, 0, 2744, 2736, + 1, 0, 0, 0, 2744, 2745, 1, 0, 0, 0, 2745, 2746, 1, 0, 0, 0, 2746, 2747, + 5, 1207, 0, 0, 2747, 177, 1, 0, 0, 0, 2748, 2749, 5, 199, 0, 0, 2749, 2750, + 5, 155, 0, 0, 2750, 2751, 5, 297, 0, 0, 2751, 2752, 5, 498, 0, 0, 2752, + 2753, 3, 1230, 615, 0, 2753, 2754, 5, 1077, 0, 0, 2754, 2774, 5, 1056, + 0, 0, 2755, 2757, 5, 1206, 0, 0, 2756, 2758, 5, 1208, 0, 0, 2757, 2756, + 1, 0, 0, 0, 2757, 2758, 1, 0, 0, 0, 2758, 2759, 1, 0, 0, 0, 2759, 2760, + 5, 161, 0, 0, 2760, 2761, 5, 1188, 0, 0, 2761, 2762, 3, 1230, 615, 0, 2762, + 2763, 5, 1208, 0, 0, 2763, 2764, 5, 21, 0, 0, 2764, 2765, 5, 1188, 0, 0, + 2765, 2766, 5, 1184, 0, 0, 2766, 2767, 5, 1208, 0, 0, 2767, 2768, 5, 296, + 0, 0, 2768, 2769, 5, 1188, 0, 0, 2769, 2770, 5, 1185, 0, 0, 2770, 2772, + 5, 1207, 0, 0, 2771, 2773, 5, 1208, 0, 0, 2772, 2771, 1, 0, 0, 0, 2772, + 2773, 1, 0, 0, 0, 2773, 2775, 1, 0, 0, 0, 2774, 2755, 1, 0, 0, 0, 2775, + 2776, 1, 0, 0, 0, 2776, 2774, 1, 0, 0, 0, 2776, 2777, 1, 0, 0, 0, 2777, + 179, 1, 0, 0, 0, 2778, 2779, 5, 282, 0, 0, 2779, 2780, 5, 123, 0, 0, 2780, + 2781, 3, 1230, 615, 0, 2781, 181, 1, 0, 0, 0, 2782, 2783, 5, 282, 0, 0, + 2783, 2784, 5, 155, 0, 0, 2784, 2785, 5, 297, 0, 0, 2785, 2786, 5, 498, + 0, 0, 2786, 2787, 3, 1230, 615, 0, 2787, 183, 1, 0, 0, 0, 2788, 2789, 5, + 282, 0, 0, 2789, 2790, 5, 155, 0, 0, 2790, 2791, 5, 547, 0, 0, 2791, 2792, + 5, 498, 0, 0, 2792, 2793, 3, 1230, 615, 0, 2793, 185, 1, 0, 0, 0, 2794, + 2795, 5, 282, 0, 0, 2795, 2796, 5, 188, 0, 0, 2796, 2797, 3, 1230, 615, + 0, 2797, 187, 1, 0, 0, 0, 2798, 2799, 5, 282, 0, 0, 2799, 2800, 5, 202, + 0, 0, 2800, 2801, 3, 1230, 615, 0, 2801, 189, 1, 0, 0, 0, 2802, 2803, 5, + 282, 0, 0, 2803, 2804, 5, 204, 0, 0, 2804, 2805, 5, 746, 0, 0, 2805, 2806, + 3, 1230, 615, 0, 2806, 191, 1, 0, 0, 0, 2807, 2808, 5, 282, 0, 0, 2808, + 2811, 5, 219, 0, 0, 2809, 2810, 5, 440, 0, 0, 2810, 2812, 5, 322, 0, 0, + 2811, 2809, 1, 0, 0, 0, 2811, 2812, 1, 0, 0, 0, 2812, 2817, 1, 0, 0, 0, + 2813, 2815, 5, 1208, 0, 0, 2814, 2813, 1, 0, 0, 0, 2814, 2815, 1, 0, 0, + 0, 2815, 2816, 1, 0, 0, 0, 2816, 2818, 3, 1230, 615, 0, 2817, 2814, 1, + 0, 0, 0, 2818, 2819, 1, 0, 0, 0, 2819, 2817, 1, 0, 0, 0, 2819, 2820, 1, + 0, 0, 0, 2820, 193, 1, 0, 0, 0, 2821, 2822, 5, 282, 0, 0, 2822, 2823, 5, + 219, 0, 0, 2823, 2824, 5, 64, 0, 0, 2824, 2825, 5, 931, 0, 0, 2825, 2826, + 3, 1230, 615, 0, 2826, 195, 1, 0, 0, 0, 2827, 2828, 5, 282, 0, 0, 2828, + 2829, 5, 219, 0, 0, 2829, 2830, 5, 297, 0, 0, 2830, 2831, 5, 498, 0, 0, + 2831, 197, 1, 0, 0, 0, 2832, 2833, 5, 282, 0, 0, 2833, 2834, 5, 219, 0, + 0, 2834, 2835, 5, 862, 0, 0, 2835, 2836, 5, 202, 0, 0, 2836, 2837, 3, 1230, + 615, 0, 2837, 199, 1, 0, 0, 0, 2838, 2839, 5, 282, 0, 0, 2839, 2842, 5, + 245, 0, 0, 2840, 2841, 5, 440, 0, 0, 2841, 2843, 5, 322, 0, 0, 2842, 2840, + 1, 0, 0, 0, 2842, 2843, 1, 0, 0, 0, 2843, 2845, 1, 0, 0, 0, 2844, 2846, + 5, 1208, 0, 0, 2845, 2844, 1, 0, 0, 0, 2845, 2846, 1, 0, 0, 0, 2846, 2850, + 1, 0, 0, 0, 2847, 2848, 3, 1230, 615, 0, 2848, 2849, 5, 1201, 0, 0, 2849, + 2851, 1, 0, 0, 0, 2850, 2847, 1, 0, 0, 0, 2850, 2851, 1, 0, 0, 0, 2851, + 2852, 1, 0, 0, 0, 2852, 2853, 3, 1230, 615, 0, 2853, 201, 1, 0, 0, 0, 2854, + 2855, 5, 282, 0, 0, 2855, 2856, 5, 300, 0, 0, 2856, 2857, 3, 1230, 615, + 0, 2857, 203, 1, 0, 0, 0, 2858, 2859, 5, 282, 0, 0, 2859, 2860, 5, 331, + 0, 0, 2860, 2861, 5, 218, 0, 0, 2861, 2862, 5, 926, 0, 0, 2862, 2863, 3, + 1230, 615, 0, 2863, 205, 1, 0, 0, 0, 2864, 2865, 5, 282, 0, 0, 2865, 2866, + 5, 331, 0, 0, 2866, 2867, 5, 343, 0, 0, 2867, 2868, 5, 374, 0, 0, 2868, + 2869, 3, 1230, 615, 0, 2869, 207, 1, 0, 0, 0, 2870, 2871, 5, 282, 0, 0, + 2871, 2872, 5, 331, 0, 0, 2872, 2873, 5, 518, 0, 0, 2873, 2876, 3, 1230, + 615, 0, 2874, 2875, 5, 68, 0, 0, 2875, 2877, 3, 1230, 615, 0, 2876, 2874, + 1, 0, 0, 0, 2876, 2877, 1, 0, 0, 0, 2877, 209, 1, 0, 0, 0, 2878, 2879, + 5, 282, 0, 0, 2879, 2880, 5, 331, 0, 0, 2880, 2881, 5, 813, 0, 0, 2881, + 2882, 5, 725, 0, 0, 2882, 2883, 3, 1230, 615, 0, 2883, 211, 1, 0, 0, 0, + 2884, 2885, 5, 282, 0, 0, 2885, 2886, 5, 331, 0, 0, 2886, 2890, 5, 980, + 0, 0, 2887, 2888, 3, 1230, 615, 0, 2888, 2889, 5, 1201, 0, 0, 2889, 2891, + 1, 0, 0, 0, 2890, 2887, 1, 0, 0, 0, 2890, 2891, 1, 0, 0, 0, 2891, 2895, + 1, 0, 0, 0, 2892, 2893, 3, 1230, 615, 0, 2893, 2894, 5, 1201, 0, 0, 2894, + 2896, 1, 0, 0, 0, 2895, 2892, 1, 0, 0, 0, 2895, 2896, 1, 0, 0, 0, 2896, + 2897, 1, 0, 0, 0, 2897, 2898, 3, 1230, 615, 0, 2898, 213, 1, 0, 0, 0, 2899, + 2900, 5, 282, 0, 0, 2900, 2901, 5, 313, 0, 0, 2901, 2906, 5, 628, 0, 0, + 2902, 2904, 5, 1208, 0, 0, 2903, 2902, 1, 0, 0, 0, 2903, 2904, 1, 0, 0, + 0, 2904, 2905, 1, 0, 0, 0, 2905, 2907, 3, 1230, 615, 0, 2906, 2903, 1, + 0, 0, 0, 2907, 2908, 1, 0, 0, 0, 2908, 2906, 1, 0, 0, 0, 2908, 2909, 1, + 0, 0, 0, 2909, 2910, 1, 0, 0, 0, 2910, 2915, 5, 662, 0, 0, 2911, 2916, + 5, 889, 0, 0, 2912, 2916, 5, 219, 0, 0, 2913, 2914, 5, 754, 0, 0, 2914, + 2916, 3, 1230, 615, 0, 2915, 2911, 1, 0, 0, 0, 2915, 2912, 1, 0, 0, 0, + 2915, 2913, 1, 0, 0, 0, 2916, 215, 1, 0, 0, 0, 2917, 2918, 5, 282, 0, 0, + 2918, 2919, 5, 313, 0, 0, 2919, 2920, 5, 895, 0, 0, 2920, 2921, 3, 1230, + 615, 0, 2921, 2922, 5, 662, 0, 0, 2922, 2923, 5, 889, 0, 0, 2923, 217, + 1, 0, 0, 0, 2924, 2925, 5, 282, 0, 0, 2925, 2926, 5, 383, 0, 0, 2926, 2927, + 5, 119, 0, 0, 2927, 2928, 3, 1230, 615, 0, 2928, 219, 1, 0, 0, 0, 2929, + 2930, 5, 282, 0, 0, 2930, 2931, 5, 383, 0, 0, 2931, 2932, 5, 456, 0, 0, + 2932, 2936, 5, 662, 0, 0, 2933, 2934, 3, 1230, 615, 0, 2934, 2935, 5, 1201, + 0, 0, 2935, 2937, 1, 0, 0, 0, 2936, 2933, 1, 0, 0, 0, 2936, 2937, 1, 0, + 0, 0, 2937, 2938, 1, 0, 0, 0, 2938, 2939, 3, 1230, 615, 0, 2939, 221, 1, + 0, 0, 0, 2940, 2941, 5, 282, 0, 0, 2941, 2942, 5, 383, 0, 0, 2942, 2943, + 5, 956, 0, 0, 2943, 2944, 3, 1230, 615, 0, 2944, 223, 1, 0, 0, 0, 2945, + 2946, 5, 282, 0, 0, 2946, 2947, 5, 537, 0, 0, 2947, 2948, 3, 1230, 615, + 0, 2948, 225, 1, 0, 0, 0, 2949, 2950, 5, 282, 0, 0, 2950, 2951, 5, 547, + 0, 0, 2951, 2952, 5, 498, 0, 0, 2952, 227, 1, 0, 0, 0, 2953, 2954, 5, 282, + 0, 0, 2954, 2955, 5, 578, 0, 0, 2955, 2956, 5, 1024, 0, 0, 2956, 2957, + 3, 1230, 615, 0, 2957, 229, 1, 0, 0, 0, 2958, 2959, 5, 282, 0, 0, 2959, + 2960, 5, 700, 0, 0, 2960, 2961, 5, 386, 0, 0, 2961, 2962, 3, 1230, 615, + 0, 2962, 231, 1, 0, 0, 0, 2963, 2964, 5, 282, 0, 0, 2964, 2965, 5, 700, + 0, 0, 2965, 2966, 5, 861, 0, 0, 2966, 2967, 3, 1230, 615, 0, 2967, 233, + 1, 0, 0, 0, 2968, 2969, 5, 282, 0, 0, 2969, 2973, 5, 754, 0, 0, 2970, 2971, + 3, 1230, 615, 0, 2971, 2972, 5, 1201, 0, 0, 2972, 2974, 1, 0, 0, 0, 2973, + 2970, 1, 0, 0, 0, 2973, 2974, 1, 0, 0, 0, 2974, 2978, 1, 0, 0, 0, 2975, + 2976, 3, 1230, 615, 0, 2976, 2977, 5, 1201, 0, 0, 2977, 2979, 1, 0, 0, + 0, 2978, 2975, 1, 0, 0, 0, 2978, 2979, 1, 0, 0, 0, 2979, 2980, 1, 0, 0, + 0, 2980, 2981, 3, 1230, 615, 0, 2981, 235, 1, 0, 0, 0, 2982, 2983, 5, 282, + 0, 0, 2983, 2984, 5, 791, 0, 0, 2984, 2985, 5, 891, 0, 0, 2985, 2986, 5, + 96, 0, 0, 2986, 2987, 3, 1230, 615, 0, 2987, 237, 1, 0, 0, 0, 2988, 2989, + 5, 282, 0, 0, 2989, 2990, 5, 813, 0, 0, 2990, 2991, 5, 725, 0, 0, 2991, + 2992, 3, 1230, 615, 0, 2992, 239, 1, 0, 0, 0, 2993, 2994, 5, 282, 0, 0, + 2994, 2997, 5, 832, 0, 0, 2995, 2996, 5, 440, 0, 0, 2996, 2998, 5, 322, + 0, 0, 2997, 2995, 1, 0, 0, 0, 2997, 2998, 1, 0, 0, 0, 2998, 2999, 1, 0, + 0, 0, 2999, 3000, 3, 1230, 615, 0, 3000, 241, 1, 0, 0, 0, 3001, 3002, 5, + 282, 0, 0, 3002, 3003, 5, 836, 0, 0, 3003, 3004, 3, 1230, 615, 0, 3004, + 243, 1, 0, 0, 0, 3005, 3006, 5, 282, 0, 0, 3006, 3009, 5, 851, 0, 0, 3007, + 3008, 5, 440, 0, 0, 3008, 3010, 5, 322, 0, 0, 3009, 3007, 1, 0, 0, 0, 3009, + 3010, 1, 0, 0, 0, 3010, 3020, 1, 0, 0, 0, 3011, 3013, 5, 1208, 0, 0, 3012, + 3011, 1, 0, 0, 0, 3012, 3013, 1, 0, 0, 0, 3013, 3017, 1, 0, 0, 0, 3014, + 3015, 3, 1230, 615, 0, 3015, 3016, 5, 1201, 0, 0, 3016, 3018, 1, 0, 0, + 0, 3017, 3014, 1, 0, 0, 0, 3017, 3018, 1, 0, 0, 0, 3018, 3019, 1, 0, 0, + 0, 3019, 3021, 3, 1230, 615, 0, 3020, 3012, 1, 0, 0, 0, 3020, 3021, 1, + 0, 0, 0, 3021, 245, 1, 0, 0, 0, 3022, 3023, 5, 282, 0, 0, 3023, 3026, 5, + 857, 0, 0, 3024, 3025, 5, 440, 0, 0, 3025, 3027, 5, 322, 0, 0, 3026, 3024, + 1, 0, 0, 0, 3026, 3027, 1, 0, 0, 0, 3027, 3028, 1, 0, 0, 0, 3028, 3029, + 3, 1230, 615, 0, 3029, 247, 1, 0, 0, 0, 3030, 3031, 5, 282, 0, 0, 3031, + 3032, 5, 867, 0, 0, 3032, 3033, 5, 745, 0, 0, 3033, 3034, 5, 524, 0, 0, + 3034, 3035, 3, 1230, 615, 0, 3035, 249, 1, 0, 0, 0, 3036, 3037, 5, 282, + 0, 0, 3037, 3038, 5, 874, 0, 0, 3038, 3041, 5, 724, 0, 0, 3039, 3040, 5, + 440, 0, 0, 3040, 3042, 5, 322, 0, 0, 3041, 3039, 1, 0, 0, 0, 3041, 3042, + 1, 0, 0, 0, 3042, 3046, 1, 0, 0, 0, 3043, 3044, 3, 1230, 615, 0, 3044, + 3045, 5, 1201, 0, 0, 3045, 3047, 1, 0, 0, 0, 3046, 3043, 1, 0, 0, 0, 3046, + 3047, 1, 0, 0, 0, 3047, 3048, 1, 0, 0, 0, 3048, 3049, 3, 1230, 615, 0, + 3049, 251, 1, 0, 0, 0, 3050, 3051, 5, 282, 0, 0, 3051, 3054, 5, 886, 0, + 0, 3052, 3053, 5, 440, 0, 0, 3053, 3055, 5, 322, 0, 0, 3054, 3052, 1, 0, + 0, 0, 3054, 3055, 1, 0, 0, 0, 3055, 3070, 1, 0, 0, 0, 3056, 3058, 5, 1208, + 0, 0, 3057, 3056, 1, 0, 0, 0, 3057, 3058, 1, 0, 0, 0, 3058, 3062, 1, 0, + 0, 0, 3059, 3060, 3, 1230, 615, 0, 3060, 3061, 5, 1201, 0, 0, 3061, 3063, + 1, 0, 0, 0, 3062, 3059, 1, 0, 0, 0, 3062, 3063, 1, 0, 0, 0, 3063, 3067, + 1, 0, 0, 0, 3064, 3065, 3, 1230, 615, 0, 3065, 3066, 5, 1201, 0, 0, 3066, + 3068, 1, 0, 0, 0, 3067, 3064, 1, 0, 0, 0, 3067, 3068, 1, 0, 0, 0, 3068, + 3069, 1, 0, 0, 0, 3069, 3071, 3, 1230, 615, 0, 3070, 3057, 1, 0, 0, 0, + 3070, 3071, 1, 0, 0, 0, 3071, 253, 1, 0, 0, 0, 3072, 3073, 5, 282, 0, 0, + 3073, 3074, 5, 889, 0, 0, 3074, 3075, 5, 64, 0, 0, 3075, 3076, 3, 1230, + 615, 0, 3076, 255, 1, 0, 0, 0, 3077, 3078, 5, 282, 0, 0, 3078, 3079, 5, + 889, 0, 0, 3079, 3080, 5, 64, 0, 0, 3080, 3081, 5, 931, 0, 0, 3081, 3082, + 3, 1230, 615, 0, 3082, 257, 1, 0, 0, 0, 3083, 3084, 5, 282, 0, 0, 3084, + 3085, 5, 889, 0, 0, 3085, 3086, 5, 832, 0, 0, 3086, 3087, 3, 1230, 615, + 0, 3087, 259, 1, 0, 0, 0, 3088, 3089, 5, 282, 0, 0, 3089, 3090, 5, 891, + 0, 0, 3090, 3091, 3, 1230, 615, 0, 3091, 261, 1, 0, 0, 0, 3092, 3094, 5, + 282, 0, 0, 3093, 3095, 5, 196, 0, 0, 3094, 3093, 1, 0, 0, 0, 3094, 3095, + 1, 0, 0, 0, 3095, 3096, 1, 0, 0, 0, 3096, 3097, 5, 915, 0, 0, 3097, 3101, + 5, 380, 0, 0, 3098, 3099, 3, 1230, 615, 0, 3099, 3100, 5, 1201, 0, 0, 3100, + 3102, 1, 0, 0, 0, 3101, 3098, 1, 0, 0, 0, 3101, 3102, 1, 0, 0, 0, 3102, + 3103, 1, 0, 0, 0, 3103, 3104, 3, 1230, 615, 0, 3104, 3116, 5, 111, 0, 0, + 3105, 3107, 5, 1208, 0, 0, 3106, 3105, 1, 0, 0, 0, 3106, 3107, 1, 0, 0, + 0, 3107, 3108, 1, 0, 0, 0, 3108, 3109, 5, 123, 0, 0, 3109, 3117, 3, 1230, + 615, 0, 3110, 3112, 5, 1208, 0, 0, 3111, 3110, 1, 0, 0, 0, 3111, 3112, + 1, 0, 0, 0, 3112, 3113, 1, 0, 0, 0, 3113, 3114, 5, 61, 0, 0, 3114, 3115, + 5, 498, 0, 0, 3115, 3117, 3, 1230, 615, 0, 3116, 3106, 1, 0, 0, 0, 3116, + 3111, 1, 0, 0, 0, 3117, 3118, 1, 0, 0, 0, 3118, 3116, 1, 0, 0, 0, 3118, + 3119, 1, 0, 0, 0, 3119, 263, 1, 0, 0, 0, 3120, 3121, 5, 282, 0, 0, 3121, + 3125, 5, 945, 0, 0, 3122, 3123, 3, 1230, 615, 0, 3123, 3124, 5, 1201, 0, + 0, 3124, 3126, 1, 0, 0, 0, 3125, 3122, 1, 0, 0, 0, 3125, 3126, 1, 0, 0, + 0, 3126, 3127, 1, 0, 0, 0, 3127, 3128, 3, 1230, 615, 0, 3128, 3129, 5, + 1201, 0, 0, 3129, 3130, 3, 1230, 615, 0, 3130, 265, 1, 0, 0, 0, 3131, 3132, + 5, 282, 0, 0, 3132, 3133, 5, 975, 0, 0, 3133, 3134, 5, 498, 0, 0, 3134, + 3138, 3, 1230, 615, 0, 3135, 3136, 5, 794, 0, 0, 3136, 3137, 5, 746, 0, + 0, 3137, 3139, 5, 498, 0, 0, 3138, 3135, 1, 0, 0, 0, 3138, 3139, 1, 0, + 0, 0, 3139, 267, 1, 0, 0, 0, 3140, 3141, 5, 282, 0, 0, 3141, 3144, 5, 977, + 0, 0, 3142, 3143, 5, 440, 0, 0, 3143, 3145, 5, 322, 0, 0, 3144, 3142, 1, + 0, 0, 0, 3144, 3145, 1, 0, 0, 0, 3145, 3149, 1, 0, 0, 0, 3146, 3147, 3, + 1230, 615, 0, 3147, 3148, 5, 1201, 0, 0, 3148, 3150, 1, 0, 0, 0, 3149, + 3146, 1, 0, 0, 0, 3149, 3150, 1, 0, 0, 0, 3150, 3151, 1, 0, 0, 0, 3151, + 3152, 3, 1230, 615, 0, 3152, 269, 1, 0, 0, 0, 3153, 3154, 5, 282, 0, 0, + 3154, 3157, 5, 1049, 0, 0, 3155, 3156, 5, 440, 0, 0, 3156, 3158, 5, 322, + 0, 0, 3157, 3155, 1, 0, 0, 0, 3157, 3158, 1, 0, 0, 0, 3158, 3159, 1, 0, + 0, 0, 3159, 3160, 3, 1230, 615, 0, 3160, 271, 1, 0, 0, 0, 3161, 3162, 5, + 282, 0, 0, 3162, 3163, 5, 1083, 0, 0, 3163, 3164, 5, 412, 0, 0, 3164, 3165, + 3, 1230, 615, 0, 3165, 273, 1, 0, 0, 0, 3166, 3167, 5, 282, 0, 0, 3167, + 3168, 5, 1088, 0, 0, 3168, 3169, 5, 857, 0, 0, 3169, 3173, 5, 154, 0, 0, + 3170, 3171, 3, 1230, 615, 0, 3171, 3172, 5, 1201, 0, 0, 3172, 3174, 1, + 0, 0, 0, 3173, 3170, 1, 0, 0, 0, 3173, 3174, 1, 0, 0, 0, 3174, 3175, 1, + 0, 0, 0, 3175, 3176, 3, 1230, 615, 0, 3176, 275, 1, 0, 0, 0, 3177, 3178, + 5, 270, 0, 0, 3178, 3193, 5, 1013, 0, 0, 3179, 3181, 5, 1208, 0, 0, 3180, + 3179, 1, 0, 0, 0, 3180, 3181, 1, 0, 0, 0, 3181, 3185, 1, 0, 0, 0, 3182, + 3183, 3, 1230, 615, 0, 3183, 3184, 5, 1201, 0, 0, 3184, 3186, 1, 0, 0, + 0, 3185, 3182, 1, 0, 0, 0, 3185, 3186, 1, 0, 0, 0, 3186, 3187, 1, 0, 0, + 0, 3187, 3189, 3, 1230, 615, 0, 3188, 3180, 1, 0, 0, 0, 3189, 3190, 1, + 0, 0, 0, 3190, 3188, 1, 0, 0, 0, 3190, 3191, 1, 0, 0, 0, 3191, 3194, 1, + 0, 0, 0, 3192, 3194, 5, 22, 0, 0, 3193, 3188, 1, 0, 0, 0, 3193, 3192, 1, + 0, 0, 0, 3194, 3195, 1, 0, 0, 0, 3195, 3205, 5, 662, 0, 0, 3196, 3197, + 3, 1230, 615, 0, 3197, 3198, 5, 1201, 0, 0, 3198, 3200, 1, 0, 0, 0, 3199, + 3196, 1, 0, 0, 0, 3199, 3200, 1, 0, 0, 0, 3200, 3201, 1, 0, 0, 0, 3201, + 3206, 3, 1230, 615, 0, 3202, 3206, 5, 219, 0, 0, 3203, 3204, 5, 22, 0, + 0, 3204, 3206, 5, 889, 0, 0, 3205, 3199, 1, 0, 0, 0, 3205, 3202, 1, 0, + 0, 0, 3205, 3203, 1, 0, 0, 0, 3206, 277, 1, 0, 0, 0, 3207, 3208, 5, 292, + 0, 0, 3208, 3223, 5, 1013, 0, 0, 3209, 3211, 5, 1208, 0, 0, 3210, 3209, + 1, 0, 0, 0, 3210, 3211, 1, 0, 0, 0, 3211, 3215, 1, 0, 0, 0, 3212, 3213, + 3, 1230, 615, 0, 3213, 3214, 5, 1201, 0, 0, 3214, 3216, 1, 0, 0, 0, 3215, + 3212, 1, 0, 0, 0, 3215, 3216, 1, 0, 0, 0, 3216, 3217, 1, 0, 0, 0, 3217, + 3219, 3, 1230, 615, 0, 3218, 3210, 1, 0, 0, 0, 3219, 3220, 1, 0, 0, 0, + 3220, 3218, 1, 0, 0, 0, 3220, 3221, 1, 0, 0, 0, 3221, 3224, 1, 0, 0, 0, + 3222, 3224, 5, 22, 0, 0, 3223, 3218, 1, 0, 0, 0, 3223, 3222, 1, 0, 0, 0, + 3224, 3225, 1, 0, 0, 0, 3225, 3235, 5, 662, 0, 0, 3226, 3227, 3, 1230, + 615, 0, 3227, 3228, 5, 1201, 0, 0, 3228, 3230, 1, 0, 0, 0, 3229, 3226, + 1, 0, 0, 0, 3229, 3230, 1, 0, 0, 0, 3230, 3231, 1, 0, 0, 0, 3231, 3236, + 3, 1230, 615, 0, 3232, 3236, 5, 219, 0, 0, 3233, 3234, 5, 22, 0, 0, 3234, + 3236, 5, 889, 0, 0, 3235, 3229, 1, 0, 0, 0, 3235, 3232, 1, 0, 0, 0, 3235, + 3233, 1, 0, 0, 0, 3236, 279, 1, 0, 0, 0, 3237, 3238, 5, 534, 0, 0, 3238, + 3239, 5, 980, 0, 0, 3239, 3240, 3, 1170, 585, 0, 3240, 3241, 5, 451, 0, + 0, 3241, 3242, 7, 24, 0, 0, 3242, 3246, 5, 591, 0, 0, 3243, 3244, 5, 1069, + 0, 0, 3244, 3247, 5, 1182, 0, 0, 3245, 3247, 5, 631, 0, 0, 3246, 3243, + 1, 0, 0, 0, 3246, 3245, 1, 0, 0, 0, 3246, 3247, 1, 0, 0, 0, 3247, 3249, + 1, 0, 0, 0, 3248, 3250, 5, 1209, 0, 0, 3249, 3248, 1, 0, 0, 0, 3249, 3250, + 1, 0, 0, 0, 3250, 281, 1, 0, 0, 0, 3251, 3252, 5, 1017, 0, 0, 3252, 3253, + 5, 980, 0, 0, 3253, 3273, 3, 1170, 585, 0, 3254, 3255, 5, 1077, 0, 0, 3255, + 3256, 5, 1206, 0, 0, 3256, 3257, 5, 701, 0, 0, 3257, 3267, 5, 1206, 0, + 0, 3258, 3260, 5, 1208, 0, 0, 3259, 3258, 1, 0, 0, 0, 3259, 3260, 1, 0, + 0, 0, 3260, 3265, 1, 0, 0, 0, 3261, 3266, 5, 1182, 0, 0, 3262, 3263, 5, + 1182, 0, 0, 3263, 3264, 5, 1000, 0, 0, 3264, 3266, 5, 1182, 0, 0, 3265, + 3261, 1, 0, 0, 0, 3265, 3262, 1, 0, 0, 0, 3266, 3268, 1, 0, 0, 0, 3267, + 3259, 1, 0, 0, 0, 3268, 3269, 1, 0, 0, 0, 3269, 3267, 1, 0, 0, 0, 3269, + 3270, 1, 0, 0, 0, 3270, 3271, 1, 0, 0, 0, 3271, 3272, 5, 1207, 0, 0, 3272, + 3274, 5, 1207, 0, 0, 3273, 3254, 1, 0, 0, 0, 3273, 3274, 1, 0, 0, 0, 3274, + 283, 1, 0, 0, 0, 3275, 3276, 5, 199, 0, 0, 3276, 3277, 5, 155, 0, 0, 3277, + 3278, 5, 547, 0, 0, 3278, 3279, 5, 498, 0, 0, 3279, 3280, 3, 1230, 615, + 0, 3280, 3281, 5, 1077, 0, 0, 3281, 3282, 5, 1206, 0, 0, 3282, 3283, 5, + 503, 0, 0, 3283, 3284, 5, 1188, 0, 0, 3284, 3285, 5, 1184, 0, 0, 3285, + 3286, 5, 1208, 0, 0, 3286, 3287, 5, 501, 0, 0, 3287, 3288, 5, 1188, 0, + 0, 3288, 3289, 5, 1184, 0, 0, 3289, 3290, 5, 1207, 0, 0, 3290, 285, 1, + 0, 0, 0, 3291, 3292, 5, 35, 0, 0, 3292, 3293, 5, 202, 0, 0, 3293, 3294, + 3, 1230, 615, 0, 3294, 3295, 5, 1077, 0, 0, 3295, 3296, 5, 433, 0, 0, 3296, + 3297, 5, 1188, 0, 0, 3297, 3302, 5, 1184, 0, 0, 3298, 3299, 5, 1208, 0, + 0, 3299, 3300, 5, 872, 0, 0, 3300, 3301, 5, 1188, 0, 0, 3301, 3303, 5, + 1184, 0, 0, 3302, 3298, 1, 0, 0, 0, 3302, 3303, 1, 0, 0, 0, 3303, 287, + 1, 0, 0, 0, 3304, 3305, 5, 199, 0, 0, 3305, 3306, 5, 202, 0, 0, 3306, 3307, + 3, 1230, 615, 0, 3307, 3308, 5, 1077, 0, 0, 3308, 3309, 5, 433, 0, 0, 3309, + 3310, 5, 1188, 0, 0, 3310, 3315, 5, 1184, 0, 0, 3311, 3312, 5, 1208, 0, + 0, 3312, 3313, 5, 872, 0, 0, 3313, 3314, 5, 1188, 0, 0, 3314, 3316, 5, + 1184, 0, 0, 3315, 3311, 1, 0, 0, 0, 3315, 3316, 1, 0, 0, 0, 3316, 3321, + 1, 0, 0, 0, 3317, 3318, 5, 365, 0, 0, 3318, 3319, 5, 204, 0, 0, 3319, 3320, + 5, 746, 0, 0, 3320, 3322, 3, 1230, 615, 0, 3321, 3317, 1, 0, 0, 0, 3321, + 3322, 1, 0, 0, 0, 3322, 289, 1, 0, 0, 0, 3323, 3324, 5, 35, 0, 0, 3324, + 3325, 5, 204, 0, 0, 3325, 3326, 5, 746, 0, 0, 3326, 3331, 3, 1230, 615, + 0, 3327, 3328, 5, 380, 0, 0, 3328, 3329, 5, 343, 0, 0, 3329, 3330, 5, 1188, + 0, 0, 3330, 3332, 5, 1184, 0, 0, 3331, 3327, 1, 0, 0, 0, 3331, 3332, 1, + 0, 0, 0, 3332, 3334, 1, 0, 0, 0, 3333, 3335, 7, 25, 0, 0, 3334, 3333, 1, + 0, 0, 0, 3334, 3335, 1, 0, 0, 0, 3335, 291, 1, 0, 0, 0, 3336, 3337, 5, + 199, 0, 0, 3337, 3338, 5, 204, 0, 0, 3338, 3339, 5, 746, 0, 0, 3339, 3340, + 3, 1230, 615, 0, 3340, 3341, 5, 380, 0, 0, 3341, 3342, 5, 343, 0, 0, 3342, + 3343, 5, 1188, 0, 0, 3343, 3344, 5, 1184, 0, 0, 3344, 293, 1, 0, 0, 0, + 3345, 3346, 5, 199, 0, 0, 3346, 3347, 5, 300, 0, 0, 3347, 3350, 3, 1230, + 615, 0, 3348, 3349, 5, 68, 0, 0, 3349, 3351, 3, 1230, 615, 0, 3350, 3348, + 1, 0, 0, 0, 3350, 3351, 1, 0, 0, 0, 3351, 3355, 1, 0, 0, 0, 3352, 3353, + 5, 943, 0, 0, 3353, 3354, 5, 1188, 0, 0, 3354, 3356, 7, 26, 0, 0, 3355, + 3352, 1, 0, 0, 0, 3355, 3356, 1, 0, 0, 0, 3356, 3357, 1, 0, 0, 0, 3357, + 3358, 5, 56, 0, 0, 3358, 3359, 5, 990, 0, 0, 3359, 3360, 5, 1206, 0, 0, + 3360, 3361, 3, 300, 150, 0, 3361, 3412, 5, 1207, 0, 0, 3362, 3363, 5, 365, + 0, 0, 3363, 3364, 5, 1022, 0, 0, 3364, 3365, 5, 1206, 0, 0, 3365, 3413, + 5, 1207, 0, 0, 3366, 3367, 5, 365, 0, 0, 3367, 3368, 5, 893, 0, 0, 3368, + 3369, 5, 1206, 0, 0, 3369, 3374, 3, 298, 149, 0, 3370, 3372, 5, 1208, 0, + 0, 3371, 3370, 1, 0, 0, 0, 3371, 3372, 1, 0, 0, 0, 3372, 3373, 1, 0, 0, + 0, 3373, 3375, 3, 296, 148, 0, 3374, 3371, 1, 0, 0, 0, 3374, 3375, 1, 0, + 0, 0, 3375, 3382, 1, 0, 0, 0, 3376, 3378, 5, 1208, 0, 0, 3377, 3376, 1, + 0, 0, 0, 3377, 3378, 1, 0, 0, 0, 3378, 3379, 1, 0, 0, 0, 3379, 3380, 5, + 579, 0, 0, 3380, 3381, 5, 1188, 0, 0, 3381, 3383, 7, 27, 0, 0, 3382, 3377, + 1, 0, 0, 0, 3382, 3383, 1, 0, 0, 0, 3383, 3390, 1, 0, 0, 0, 3384, 3386, + 5, 1208, 0, 0, 3385, 3384, 1, 0, 0, 0, 3385, 3386, 1, 0, 0, 0, 3386, 3387, + 1, 0, 0, 0, 3387, 3388, 5, 580, 0, 0, 3388, 3389, 5, 1188, 0, 0, 3389, + 3391, 5, 1182, 0, 0, 3390, 3385, 1, 0, 0, 0, 3390, 3391, 1, 0, 0, 0, 3391, + 3392, 1, 0, 0, 0, 3392, 3393, 5, 1207, 0, 0, 3393, 3413, 1, 0, 0, 0, 3394, + 3395, 5, 365, 0, 0, 3395, 3396, 5, 221, 0, 0, 3396, 3397, 5, 1206, 0, 0, + 3397, 3402, 3, 298, 149, 0, 3398, 3400, 5, 1208, 0, 0, 3399, 3398, 1, 0, + 0, 0, 3399, 3400, 1, 0, 0, 0, 3400, 3401, 1, 0, 0, 0, 3401, 3403, 3, 296, + 148, 0, 3402, 3399, 1, 0, 0, 0, 3402, 3403, 1, 0, 0, 0, 3403, 3405, 1, + 0, 0, 0, 3404, 3406, 5, 1208, 0, 0, 3405, 3404, 1, 0, 0, 0, 3405, 3406, + 1, 0, 0, 0, 3406, 3407, 1, 0, 0, 0, 3407, 3408, 5, 832, 0, 0, 3408, 3409, + 5, 1188, 0, 0, 3409, 3410, 7, 28, 0, 0, 3410, 3411, 5, 1207, 0, 0, 3411, + 3413, 1, 0, 0, 0, 3412, 3362, 1, 0, 0, 0, 3412, 3366, 1, 0, 0, 0, 3412, + 3394, 1, 0, 0, 0, 3413, 295, 1, 0, 0, 0, 3414, 3415, 5, 297, 0, 0, 3415, + 3416, 5, 1188, 0, 0, 3416, 3428, 7, 29, 0, 0, 3417, 3426, 5, 21, 0, 0, + 3418, 3420, 5, 14, 0, 0, 3419, 3421, 5, 765, 0, 0, 3420, 3419, 1, 0, 0, + 0, 3420, 3421, 1, 0, 0, 0, 3421, 3427, 1, 0, 0, 0, 3422, 3424, 5, 765, + 0, 0, 3423, 3425, 5, 14, 0, 0, 3424, 3423, 1, 0, 0, 0, 3424, 3425, 1, 0, + 0, 0, 3425, 3427, 1, 0, 0, 0, 3426, 3418, 1, 0, 0, 0, 3426, 3422, 1, 0, + 0, 0, 3427, 3429, 1, 0, 0, 0, 3428, 3417, 1, 0, 0, 0, 3428, 3429, 1, 0, + 0, 0, 3429, 297, 1, 0, 0, 0, 3430, 3431, 5, 67, 0, 0, 3431, 3448, 5, 1188, + 0, 0, 3432, 3434, 5, 1076, 0, 0, 3433, 3435, 7, 30, 0, 0, 3434, 3433, 1, + 0, 0, 0, 3434, 3435, 1, 0, 0, 0, 3435, 3438, 1, 0, 0, 0, 3436, 3437, 5, + 123, 0, 0, 3437, 3439, 3, 1230, 615, 0, 3438, 3436, 1, 0, 0, 0, 3438, 3439, + 1, 0, 0, 0, 3439, 3449, 1, 0, 0, 0, 3440, 3441, 5, 123, 0, 0, 3441, 3443, + 3, 1230, 615, 0, 3442, 3444, 5, 1076, 0, 0, 3443, 3442, 1, 0, 0, 0, 3443, + 3444, 1, 0, 0, 0, 3444, 3446, 1, 0, 0, 0, 3445, 3447, 7, 30, 0, 0, 3446, + 3445, 1, 0, 0, 0, 3446, 3447, 1, 0, 0, 0, 3447, 3449, 1, 0, 0, 0, 3448, + 3432, 1, 0, 0, 0, 3448, 3440, 1, 0, 0, 0, 3449, 299, 1, 0, 0, 0, 3450, + 3451, 5, 527, 0, 0, 3451, 3452, 5, 1188, 0, 0, 3452, 3465, 5, 1182, 0, + 0, 3453, 3454, 5, 1208, 0, 0, 3454, 3455, 5, 526, 0, 0, 3455, 3463, 5, + 1188, 0, 0, 3456, 3464, 5, 22, 0, 0, 3457, 3460, 5, 1206, 0, 0, 3458, 3461, + 5, 1172, 0, 0, 3459, 3461, 5, 1184, 0, 0, 3460, 3458, 1, 0, 0, 0, 3460, + 3459, 1, 0, 0, 0, 3461, 3462, 1, 0, 0, 0, 3462, 3464, 5, 1207, 0, 0, 3463, + 3456, 1, 0, 0, 0, 3463, 3457, 1, 0, 0, 0, 3464, 3466, 1, 0, 0, 0, 3465, + 3453, 1, 0, 0, 0, 3465, 3466, 1, 0, 0, 0, 3466, 301, 1, 0, 0, 0, 3467, + 3468, 5, 199, 0, 0, 3468, 3469, 5, 313, 0, 0, 3469, 3470, 5, 628, 0, 0, + 3470, 3471, 3, 1230, 615, 0, 3471, 3476, 5, 662, 0, 0, 3472, 3477, 5, 889, + 0, 0, 3473, 3477, 5, 219, 0, 0, 3474, 3475, 5, 754, 0, 0, 3475, 3477, 3, + 1230, 615, 0, 3476, 3472, 1, 0, 0, 0, 3476, 3473, 1, 0, 0, 0, 3476, 3474, + 1, 0, 0, 0, 3477, 3480, 1, 0, 0, 0, 3478, 3479, 5, 1077, 0, 0, 3479, 3481, + 5, 339, 0, 0, 3480, 3478, 1, 0, 0, 0, 3480, 3481, 1, 0, 0, 0, 3481, 3482, + 1, 0, 0, 0, 3482, 3487, 5, 365, 0, 0, 3483, 3485, 5, 1208, 0, 0, 3484, + 3483, 1, 0, 0, 0, 3484, 3485, 1, 0, 0, 0, 3485, 3486, 1, 0, 0, 0, 3486, + 3488, 3, 1230, 615, 0, 3487, 3484, 1, 0, 0, 0, 3488, 3489, 1, 0, 0, 0, + 3489, 3487, 1, 0, 0, 0, 3489, 3490, 1, 0, 0, 0, 3490, 3491, 1, 0, 0, 0, + 3491, 3492, 5, 1000, 0, 0, 3492, 3493, 5, 891, 0, 0, 3493, 3494, 5, 1184, + 0, 0, 3494, 3495, 5, 1208, 0, 0, 3495, 3496, 5, 1184, 0, 0, 3496, 303, + 1, 0, 0, 0, 3497, 3498, 7, 22, 0, 0, 3498, 3499, 5, 313, 0, 0, 3499, 3500, + 5, 895, 0, 0, 3500, 3501, 3, 1230, 615, 0, 3501, 3502, 5, 662, 0, 0, 3502, + 3570, 5, 889, 0, 0, 3503, 3505, 5, 1208, 0, 0, 3504, 3503, 1, 0, 0, 0, + 3504, 3505, 1, 0, 0, 0, 3505, 3506, 1, 0, 0, 0, 3506, 3507, 5, 11, 0, 0, + 3507, 3511, 5, 313, 0, 0, 3508, 3509, 3, 1230, 615, 0, 3509, 3510, 5, 1201, + 0, 0, 3510, 3512, 1, 0, 0, 0, 3511, 3508, 1, 0, 0, 0, 3511, 3512, 1, 0, + 0, 0, 3512, 3513, 1, 0, 0, 0, 3513, 3514, 3, 1230, 615, 0, 3514, 3515, + 5, 1201, 0, 0, 3515, 3516, 3, 1230, 615, 0, 3516, 3565, 1, 0, 0, 0, 3517, + 3531, 5, 1206, 0, 0, 3518, 3528, 5, 900, 0, 0, 3519, 3521, 5, 1208, 0, + 0, 3520, 3519, 1, 0, 0, 0, 3520, 3521, 1, 0, 0, 0, 3521, 3522, 1, 0, 0, + 0, 3522, 3523, 3, 1230, 615, 0, 3523, 3524, 5, 1188, 0, 0, 3524, 3525, + 7, 31, 0, 0, 3525, 3527, 1, 0, 0, 0, 3526, 3520, 1, 0, 0, 0, 3527, 3530, + 1, 0, 0, 0, 3528, 3526, 1, 0, 0, 0, 3528, 3529, 1, 0, 0, 0, 3529, 3532, + 1, 0, 0, 0, 3530, 3528, 1, 0, 0, 0, 3531, 3518, 1, 0, 0, 0, 3531, 3532, + 1, 0, 0, 0, 3532, 3553, 1, 0, 0, 0, 3533, 3534, 5, 8, 0, 0, 3534, 3547, + 5, 1206, 0, 0, 3535, 3537, 5, 1208, 0, 0, 3536, 3535, 1, 0, 0, 0, 3536, + 3537, 1, 0, 0, 0, 3537, 3541, 1, 0, 0, 0, 3538, 3539, 3, 1230, 615, 0, + 3539, 3540, 5, 1201, 0, 0, 3540, 3542, 1, 0, 0, 0, 3541, 3538, 1, 0, 0, + 0, 3541, 3542, 1, 0, 0, 0, 3542, 3543, 1, 0, 0, 0, 3543, 3544, 3, 1230, + 615, 0, 3544, 3545, 5, 1201, 0, 0, 3545, 3546, 3, 1230, 615, 0, 3546, 3548, + 1, 0, 0, 0, 3547, 3536, 1, 0, 0, 0, 3548, 3549, 1, 0, 0, 0, 3549, 3547, + 1, 0, 0, 0, 3549, 3550, 1, 0, 0, 0, 3550, 3551, 1, 0, 0, 0, 3551, 3552, + 5, 1207, 0, 0, 3552, 3554, 1, 0, 0, 0, 3553, 3533, 1, 0, 0, 0, 3554, 3555, + 1, 0, 0, 0, 3555, 3553, 1, 0, 0, 0, 3555, 3556, 1, 0, 0, 0, 3556, 3559, + 1, 0, 0, 0, 3557, 3558, 5, 1074, 0, 0, 3558, 3560, 3, 306, 153, 0, 3559, + 3557, 1, 0, 0, 0, 3559, 3560, 1, 0, 0, 0, 3560, 3561, 1, 0, 0, 0, 3561, + 3562, 5, 1207, 0, 0, 3562, 3564, 1, 0, 0, 0, 3563, 3517, 1, 0, 0, 0, 3564, + 3567, 1, 0, 0, 0, 3565, 3563, 1, 0, 0, 0, 3565, 3566, 1, 0, 0, 0, 3566, + 3569, 1, 0, 0, 0, 3567, 3565, 1, 0, 0, 0, 3568, 3504, 1, 0, 0, 0, 3569, + 3572, 1, 0, 0, 0, 3570, 3568, 1, 0, 0, 0, 3570, 3571, 1, 0, 0, 0, 3571, + 3589, 1, 0, 0, 0, 3572, 3570, 1, 0, 0, 0, 3573, 3575, 5, 1208, 0, 0, 3574, + 3573, 1, 0, 0, 0, 3574, 3575, 1, 0, 0, 0, 3575, 3576, 1, 0, 0, 0, 3576, + 3577, 5, 282, 0, 0, 3577, 3581, 5, 313, 0, 0, 3578, 3579, 3, 1230, 615, + 0, 3579, 3580, 5, 1201, 0, 0, 3580, 3582, 1, 0, 0, 0, 3581, 3578, 1, 0, + 0, 0, 3581, 3582, 1, 0, 0, 0, 3582, 3583, 1, 0, 0, 0, 3583, 3584, 3, 1230, + 615, 0, 3584, 3585, 5, 1201, 0, 0, 3585, 3586, 3, 1230, 615, 0, 3586, 3588, + 1, 0, 0, 0, 3587, 3574, 1, 0, 0, 0, 3588, 3591, 1, 0, 0, 0, 3589, 3587, + 1, 0, 0, 0, 3589, 3590, 1, 0, 0, 0, 3590, 3633, 1, 0, 0, 0, 3591, 3589, + 1, 0, 0, 0, 3592, 3593, 5, 11, 0, 0, 3593, 3597, 5, 987, 0, 0, 3594, 3595, + 3, 1230, 615, 0, 3595, 3596, 5, 1201, 0, 0, 3596, 3598, 1, 0, 0, 0, 3597, + 3594, 1, 0, 0, 0, 3597, 3598, 1, 0, 0, 0, 3598, 3599, 1, 0, 0, 0, 3599, + 3600, 3, 1230, 615, 0, 3600, 3601, 5, 1201, 0, 0, 3601, 3602, 3, 1230, + 615, 0, 3602, 3628, 1, 0, 0, 0, 3603, 3604, 5, 1206, 0, 0, 3604, 3620, + 5, 900, 0, 0, 3605, 3607, 5, 1208, 0, 0, 3606, 3605, 1, 0, 0, 0, 3606, + 3607, 1, 0, 0, 0, 3607, 3608, 1, 0, 0, 0, 3608, 3609, 3, 1230, 615, 0, + 3609, 3618, 5, 1188, 0, 0, 3610, 3612, 5, 1206, 0, 0, 3611, 3610, 1, 0, + 0, 0, 3611, 3612, 1, 0, 0, 0, 3612, 3613, 1, 0, 0, 0, 3613, 3615, 5, 1182, + 0, 0, 3614, 3616, 5, 1207, 0, 0, 3615, 3614, 1, 0, 0, 0, 3615, 3616, 1, + 0, 0, 0, 3616, 3619, 1, 0, 0, 0, 3617, 3619, 5, 1184, 0, 0, 3618, 3611, + 1, 0, 0, 0, 3618, 3617, 1, 0, 0, 0, 3619, 3621, 1, 0, 0, 0, 3620, 3606, + 1, 0, 0, 0, 3621, 3622, 1, 0, 0, 0, 3622, 3620, 1, 0, 0, 0, 3622, 3623, + 1, 0, 0, 0, 3623, 3624, 1, 0, 0, 0, 3624, 3625, 5, 1207, 0, 0, 3625, 3627, + 1, 0, 0, 0, 3626, 3603, 1, 0, 0, 0, 3627, 3630, 1, 0, 0, 0, 3628, 3626, + 1, 0, 0, 0, 3628, 3629, 1, 0, 0, 0, 3629, 3632, 1, 0, 0, 0, 3630, 3628, + 1, 0, 0, 0, 3631, 3592, 1, 0, 0, 0, 3632, 3635, 1, 0, 0, 0, 3633, 3631, + 1, 0, 0, 0, 3633, 3634, 1, 0, 0, 0, 3634, 3649, 1, 0, 0, 0, 3635, 3633, + 1, 0, 0, 0, 3636, 3637, 5, 282, 0, 0, 3637, 3641, 5, 987, 0, 0, 3638, 3639, + 3, 1230, 615, 0, 3639, 3640, 5, 1201, 0, 0, 3640, 3642, 1, 0, 0, 0, 3641, + 3638, 1, 0, 0, 0, 3641, 3642, 1, 0, 0, 0, 3642, 3643, 1, 0, 0, 0, 3643, + 3644, 3, 1230, 615, 0, 3644, 3645, 5, 1201, 0, 0, 3645, 3646, 3, 1230, + 615, 0, 3646, 3648, 1, 0, 0, 0, 3647, 3636, 1, 0, 0, 0, 3648, 3651, 1, + 0, 0, 0, 3649, 3647, 1, 0, 0, 0, 3649, 3650, 1, 0, 0, 0, 3650, 3717, 1, + 0, 0, 0, 3651, 3649, 1, 0, 0, 0, 3652, 3653, 5, 1077, 0, 0, 3653, 3661, + 5, 1206, 0, 0, 3654, 3656, 5, 1208, 0, 0, 3655, 3654, 1, 0, 0, 0, 3655, + 3656, 1, 0, 0, 0, 3656, 3657, 1, 0, 0, 0, 3657, 3658, 5, 563, 0, 0, 3658, + 3659, 5, 1188, 0, 0, 3659, 3660, 5, 1182, 0, 0, 3660, 3662, 7, 32, 0, 0, + 3661, 3655, 1, 0, 0, 0, 3661, 3662, 1, 0, 0, 0, 3662, 3669, 1, 0, 0, 0, + 3663, 3665, 5, 1208, 0, 0, 3664, 3663, 1, 0, 0, 0, 3664, 3665, 1, 0, 0, + 0, 3665, 3666, 1, 0, 0, 0, 3666, 3667, 5, 315, 0, 0, 3667, 3668, 5, 1188, + 0, 0, 3668, 3670, 7, 33, 0, 0, 3669, 3664, 1, 0, 0, 0, 3669, 3670, 1, 0, + 0, 0, 3670, 3681, 1, 0, 0, 0, 3671, 3673, 5, 1208, 0, 0, 3672, 3671, 1, + 0, 0, 0, 3672, 3673, 1, 0, 0, 0, 3673, 3674, 1, 0, 0, 0, 3674, 3675, 5, + 557, 0, 0, 3675, 3679, 5, 1188, 0, 0, 3676, 3677, 5, 1182, 0, 0, 3677, + 3680, 5, 871, 0, 0, 3678, 3680, 5, 460, 0, 0, 3679, 3676, 1, 0, 0, 0, 3679, + 3678, 1, 0, 0, 0, 3680, 3682, 1, 0, 0, 0, 3681, 3672, 1, 0, 0, 0, 3681, + 3682, 1, 0, 0, 0, 3682, 3690, 1, 0, 0, 0, 3683, 3685, 5, 1208, 0, 0, 3684, + 3683, 1, 0, 0, 0, 3684, 3685, 1, 0, 0, 0, 3685, 3686, 1, 0, 0, 0, 3686, + 3687, 5, 560, 0, 0, 3687, 3688, 5, 1188, 0, 0, 3688, 3689, 5, 1182, 0, + 0, 3689, 3691, 7, 32, 0, 0, 3690, 3684, 1, 0, 0, 0, 3690, 3691, 1, 0, 0, + 0, 3691, 3698, 1, 0, 0, 0, 3692, 3694, 5, 1208, 0, 0, 3693, 3692, 1, 0, + 0, 0, 3693, 3694, 1, 0, 0, 0, 3694, 3695, 1, 0, 0, 0, 3695, 3696, 5, 576, + 0, 0, 3696, 3697, 5, 1188, 0, 0, 3697, 3699, 7, 34, 0, 0, 3698, 3693, 1, + 0, 0, 0, 3698, 3699, 1, 0, 0, 0, 3699, 3706, 1, 0, 0, 0, 3700, 3702, 5, + 1208, 0, 0, 3701, 3700, 1, 0, 0, 0, 3701, 3702, 1, 0, 0, 0, 3702, 3703, + 1, 0, 0, 0, 3703, 3704, 5, 1006, 0, 0, 3704, 3705, 5, 1188, 0, 0, 3705, + 3707, 7, 17, 0, 0, 3706, 3701, 1, 0, 0, 0, 3706, 3707, 1, 0, 0, 0, 3707, + 3714, 1, 0, 0, 0, 3708, 3710, 5, 1208, 0, 0, 3709, 3708, 1, 0, 0, 0, 3709, + 3710, 1, 0, 0, 0, 3710, 3711, 1, 0, 0, 0, 3711, 3712, 5, 941, 0, 0, 3712, + 3713, 5, 1188, 0, 0, 3713, 3715, 7, 17, 0, 0, 3714, 3709, 1, 0, 0, 0, 3714, + 3715, 1, 0, 0, 0, 3715, 3716, 1, 0, 0, 0, 3716, 3718, 5, 1207, 0, 0, 3717, + 3652, 1, 0, 0, 0, 3717, 3718, 1, 0, 0, 0, 3718, 3722, 1, 0, 0, 0, 3719, + 3720, 5, 943, 0, 0, 3720, 3721, 5, 1188, 0, 0, 3721, 3723, 7, 35, 0, 0, + 3722, 3719, 1, 0, 0, 0, 3722, 3723, 1, 0, 0, 0, 3723, 305, 1, 0, 0, 0, + 3724, 3726, 5, 1208, 0, 0, 3725, 3724, 1, 0, 0, 0, 3725, 3726, 1, 0, 0, + 0, 3726, 3728, 1, 0, 0, 0, 3727, 3729, 7, 36, 0, 0, 3728, 3727, 1, 0, 0, + 0, 3728, 3729, 1, 0, 0, 0, 3729, 3731, 1, 0, 0, 0, 3730, 3732, 5, 627, + 0, 0, 3731, 3730, 1, 0, 0, 0, 3731, 3732, 1, 0, 0, 0, 3732, 3738, 1, 0, + 0, 0, 3733, 3739, 3, 308, 154, 0, 3734, 3735, 5, 1206, 0, 0, 3735, 3736, + 3, 306, 153, 0, 3736, 3737, 5, 1207, 0, 0, 3737, 3739, 1, 0, 0, 0, 3738, + 3733, 1, 0, 0, 0, 3738, 3734, 1, 0, 0, 0, 3739, 3741, 1, 0, 0, 0, 3740, + 3725, 1, 0, 0, 0, 3741, 3742, 1, 0, 0, 0, 3742, 3740, 1, 0, 0, 0, 3742, + 3743, 1, 0, 0, 0, 3743, 307, 1, 0, 0, 0, 3744, 3750, 3, 310, 155, 0, 3745, + 3746, 5, 1206, 0, 0, 3746, 3747, 3, 306, 153, 0, 3747, 3748, 5, 1207, 0, + 0, 3748, 3750, 1, 0, 0, 0, 3749, 3744, 1, 0, 0, 0, 3749, 3745, 1, 0, 0, + 0, 3750, 309, 1, 0, 0, 0, 3751, 3780, 3, 1230, 615, 0, 3752, 3763, 3, 1230, + 615, 0, 3753, 3754, 3, 1230, 615, 0, 3754, 3755, 5, 1201, 0, 0, 3755, 3757, + 1, 0, 0, 0, 3756, 3753, 1, 0, 0, 0, 3756, 3757, 1, 0, 0, 0, 3757, 3758, + 1, 0, 0, 0, 3758, 3759, 3, 1230, 615, 0, 3759, 3760, 5, 1201, 0, 0, 3760, + 3761, 3, 1230, 615, 0, 3761, 3763, 1, 0, 0, 0, 3762, 3752, 1, 0, 0, 0, + 3762, 3756, 1, 0, 0, 0, 3763, 3775, 1, 0, 0, 0, 3764, 3776, 5, 1188, 0, + 0, 3765, 3766, 5, 1190, 0, 0, 3766, 3776, 5, 1189, 0, 0, 3767, 3768, 5, + 1191, 0, 0, 3768, 3776, 5, 1188, 0, 0, 3769, 3776, 5, 1189, 0, 0, 3770, + 3771, 5, 1189, 0, 0, 3771, 3776, 5, 1188, 0, 0, 3772, 3776, 5, 1190, 0, + 0, 3773, 3774, 5, 1190, 0, 0, 3774, 3776, 5, 1188, 0, 0, 3775, 3764, 1, + 0, 0, 0, 3775, 3765, 1, 0, 0, 0, 3775, 3767, 1, 0, 0, 0, 3775, 3769, 1, + 0, 0, 0, 3775, 3770, 1, 0, 0, 0, 3775, 3772, 1, 0, 0, 0, 3775, 3773, 1, + 0, 0, 0, 3776, 3777, 1, 0, 0, 0, 3777, 3778, 7, 31, 0, 0, 3778, 3780, 1, + 0, 0, 0, 3779, 3751, 1, 0, 0, 0, 3779, 3762, 1, 0, 0, 0, 3780, 3808, 1, + 0, 0, 0, 3781, 3782, 3, 1230, 615, 0, 3782, 3783, 5, 1201, 0, 0, 3783, + 3785, 1, 0, 0, 0, 3784, 3781, 1, 0, 0, 0, 3784, 3785, 1, 0, 0, 0, 3785, + 3786, 1, 0, 0, 0, 3786, 3787, 3, 1230, 615, 0, 3787, 3788, 5, 1201, 0, + 0, 3788, 3789, 3, 1230, 615, 0, 3789, 3803, 5, 1206, 0, 0, 3790, 3804, + 3, 1230, 615, 0, 3791, 3792, 3, 1230, 615, 0, 3792, 3793, 5, 1201, 0, 0, + 3793, 3795, 1, 0, 0, 0, 3794, 3791, 1, 0, 0, 0, 3794, 3795, 1, 0, 0, 0, + 3795, 3796, 1, 0, 0, 0, 3796, 3797, 3, 1230, 615, 0, 3797, 3798, 5, 1201, + 0, 0, 3798, 3799, 3, 1230, 615, 0, 3799, 3800, 1, 0, 0, 0, 3800, 3801, + 5, 1208, 0, 0, 3801, 3802, 7, 31, 0, 0, 3802, 3804, 1, 0, 0, 0, 3803, 3790, + 1, 0, 0, 0, 3803, 3794, 1, 0, 0, 0, 3804, 3805, 1, 0, 0, 0, 3805, 3806, + 5, 1207, 0, 0, 3806, 3808, 1, 0, 0, 0, 3807, 3779, 1, 0, 0, 0, 3807, 3784, + 1, 0, 0, 0, 3808, 311, 1, 0, 0, 0, 3809, 3810, 5, 35, 0, 0, 3810, 3811, + 5, 331, 0, 0, 3811, 3812, 5, 218, 0, 0, 3812, 3813, 5, 926, 0, 0, 3813, + 3814, 3, 1230, 615, 0, 3814, 3830, 5, 900, 0, 0, 3815, 3816, 5, 533, 0, + 0, 3816, 3817, 5, 1188, 0, 0, 3817, 3819, 5, 1184, 0, 0, 3818, 3820, 5, + 1208, 0, 0, 3819, 3818, 1, 0, 0, 0, 3819, 3820, 1, 0, 0, 0, 3820, 3831, + 1, 0, 0, 0, 3821, 3822, 5, 815, 0, 0, 3822, 3823, 5, 1188, 0, 0, 3823, + 3825, 5, 1184, 0, 0, 3824, 3826, 5, 1208, 0, 0, 3825, 3824, 1, 0, 0, 0, + 3825, 3826, 1, 0, 0, 0, 3826, 3831, 1, 0, 0, 0, 3827, 3828, 5, 202, 0, + 0, 3828, 3829, 5, 1188, 0, 0, 3829, 3831, 3, 1230, 615, 0, 3830, 3815, + 1, 0, 0, 0, 3830, 3821, 1, 0, 0, 0, 3830, 3827, 1, 0, 0, 0, 3831, 3832, + 1, 0, 0, 0, 3832, 3830, 1, 0, 0, 0, 3832, 3833, 1, 0, 0, 0, 3833, 3857, + 1, 0, 0, 0, 3834, 3835, 5, 35, 0, 0, 3835, 3836, 5, 331, 0, 0, 3836, 3837, + 5, 218, 0, 0, 3837, 3838, 5, 926, 0, 0, 3838, 3839, 3, 1230, 615, 0, 3839, + 3840, 5, 1077, 0, 0, 3840, 3841, 5, 1206, 0, 0, 3841, 3842, 5, 1024, 0, + 0, 3842, 3843, 5, 1188, 0, 0, 3843, 3844, 5, 97, 0, 0, 3844, 3845, 5, 1208, + 0, 0, 3845, 3846, 5, 533, 0, 0, 3846, 3847, 5, 1188, 0, 0, 3847, 3852, + 5, 1184, 0, 0, 3848, 3849, 5, 1208, 0, 0, 3849, 3850, 5, 202, 0, 0, 3850, + 3851, 5, 1188, 0, 0, 3851, 3853, 3, 1230, 615, 0, 3852, 3848, 1, 0, 0, + 0, 3852, 3853, 1, 0, 0, 0, 3853, 3854, 1, 0, 0, 0, 3854, 3855, 5, 1207, + 0, 0, 3855, 3857, 1, 0, 0, 0, 3856, 3809, 1, 0, 0, 0, 3856, 3834, 1, 0, + 0, 0, 3857, 313, 1, 0, 0, 0, 3858, 3859, 5, 35, 0, 0, 3859, 3860, 5, 331, + 0, 0, 3860, 3861, 5, 518, 0, 0, 3861, 3864, 3, 1230, 615, 0, 3862, 3863, + 5, 68, 0, 0, 3863, 3865, 3, 1230, 615, 0, 3864, 3862, 1, 0, 0, 0, 3864, + 3865, 1, 0, 0, 0, 3865, 3866, 1, 0, 0, 0, 3866, 3867, 7, 37, 0, 0, 3867, + 3868, 5, 1206, 0, 0, 3868, 3869, 5, 183, 0, 0, 3869, 3873, 5, 1188, 0, + 0, 3870, 3874, 5, 1184, 0, 0, 3871, 3874, 5, 1185, 0, 0, 3872, 3874, 5, + 621, 0, 0, 3873, 3870, 1, 0, 0, 0, 3873, 3871, 1, 0, 0, 0, 3873, 3872, + 1, 0, 0, 0, 3874, 3875, 1, 0, 0, 0, 3875, 3876, 5, 1208, 0, 0, 3876, 3877, + 5, 722, 0, 0, 3877, 3879, 5, 1188, 0, 0, 3878, 3880, 7, 38, 0, 0, 3879, + 3878, 1, 0, 0, 0, 3879, 3880, 1, 0, 0, 0, 3880, 3881, 1, 0, 0, 0, 3881, + 3882, 5, 1207, 0, 0, 3882, 3883, 1, 0, 0, 0, 3883, 3893, 5, 1077, 0, 0, + 3884, 3886, 5, 1208, 0, 0, 3885, 3884, 1, 0, 0, 0, 3885, 3886, 1, 0, 0, + 0, 3886, 3887, 1, 0, 0, 0, 3887, 3888, 5, 506, 0, 0, 3888, 3889, 5, 1188, + 0, 0, 3889, 3894, 7, 39, 0, 0, 3890, 3891, 5, 227, 0, 0, 3891, 3892, 5, + 1188, 0, 0, 3892, 3894, 3, 1230, 615, 0, 3893, 3885, 1, 0, 0, 0, 3893, + 3890, 1, 0, 0, 0, 3894, 3895, 1, 0, 0, 0, 3895, 3893, 1, 0, 0, 0, 3895, + 3896, 1, 0, 0, 0, 3896, 3897, 1, 0, 0, 0, 3897, 3898, 5, 1207, 0, 0, 3898, + 315, 1, 0, 0, 0, 3899, 3900, 5, 199, 0, 0, 3900, 3901, 5, 331, 0, 0, 3901, + 3902, 5, 518, 0, 0, 3902, 3905, 3, 1230, 615, 0, 3903, 3904, 5, 68, 0, + 0, 3904, 3906, 3, 1230, 615, 0, 3905, 3903, 1, 0, 0, 0, 3905, 3906, 1, + 0, 0, 0, 3906, 3907, 1, 0, 0, 0, 3907, 3909, 5, 380, 0, 0, 3908, 3910, + 5, 1208, 0, 0, 3909, 3908, 1, 0, 0, 0, 3909, 3910, 1, 0, 0, 0, 3910, 3912, + 1, 0, 0, 0, 3911, 3913, 5, 1206, 0, 0, 3912, 3911, 1, 0, 0, 0, 3912, 3913, + 1, 0, 0, 0, 3913, 3916, 1, 0, 0, 0, 3914, 3915, 5, 183, 0, 0, 3915, 3917, + 5, 1188, 0, 0, 3916, 3914, 1, 0, 0, 0, 3916, 3917, 1, 0, 0, 0, 3917, 3921, + 1, 0, 0, 0, 3918, 3922, 5, 1184, 0, 0, 3919, 3922, 5, 1185, 0, 0, 3920, + 3922, 5, 621, 0, 0, 3921, 3918, 1, 0, 0, 0, 3921, 3919, 1, 0, 0, 0, 3921, + 3920, 1, 0, 0, 0, 3922, 3930, 1, 0, 0, 0, 3923, 3924, 5, 1208, 0, 0, 3924, + 3925, 5, 722, 0, 0, 3925, 3927, 5, 1188, 0, 0, 3926, 3928, 7, 38, 0, 0, + 3927, 3926, 1, 0, 0, 0, 3927, 3928, 1, 0, 0, 0, 3928, 3929, 1, 0, 0, 0, + 3929, 3931, 5, 1207, 0, 0, 3930, 3923, 1, 0, 0, 0, 3930, 3931, 1, 0, 0, + 0, 3931, 3947, 1, 0, 0, 0, 3932, 3942, 5, 1077, 0, 0, 3933, 3935, 5, 1208, + 0, 0, 3934, 3933, 1, 0, 0, 0, 3934, 3935, 1, 0, 0, 0, 3935, 3936, 1, 0, + 0, 0, 3936, 3937, 5, 506, 0, 0, 3937, 3938, 5, 1188, 0, 0, 3938, 3943, + 7, 39, 0, 0, 3939, 3940, 5, 227, 0, 0, 3940, 3941, 5, 1188, 0, 0, 3941, + 3943, 3, 1230, 615, 0, 3942, 3934, 1, 0, 0, 0, 3942, 3939, 1, 0, 0, 0, + 3943, 3944, 1, 0, 0, 0, 3944, 3942, 1, 0, 0, 0, 3944, 3945, 1, 0, 0, 0, + 3945, 3946, 1, 0, 0, 0, 3946, 3948, 5, 1207, 0, 0, 3947, 3932, 1, 0, 0, + 0, 3947, 3948, 1, 0, 0, 0, 3948, 317, 1, 0, 0, 0, 3949, 3950, 5, 35, 0, + 0, 3950, 3951, 5, 331, 0, 0, 3951, 3952, 5, 813, 0, 0, 3952, 3955, 5, 725, + 0, 0, 3953, 3956, 3, 1230, 615, 0, 3954, 3956, 5, 247, 0, 0, 3955, 3953, + 1, 0, 0, 0, 3955, 3954, 1, 0, 0, 0, 3956, 3957, 1, 0, 0, 0, 3957, 3958, + 5, 1077, 0, 0, 3958, 3959, 5, 1206, 0, 0, 3959, 3960, 5, 556, 0, 0, 3960, + 3961, 5, 1188, 0, 0, 3961, 3999, 5, 1182, 0, 0, 3962, 3964, 5, 1208, 0, + 0, 3963, 3962, 1, 0, 0, 0, 3963, 3964, 1, 0, 0, 0, 3964, 3965, 1, 0, 0, + 0, 3965, 3966, 5, 18, 0, 0, 3966, 3967, 5, 198, 0, 0, 3967, 3981, 5, 1188, + 0, 0, 3968, 3982, 5, 69, 0, 0, 3969, 3971, 5, 1208, 0, 0, 3970, 3969, 1, + 0, 0, 0, 3970, 3971, 1, 0, 0, 0, 3971, 3972, 1, 0, 0, 0, 3972, 3973, 5, + 1182, 0, 0, 3973, 3974, 5, 1000, 0, 0, 3974, 3978, 5, 1182, 0, 0, 3975, + 3976, 5, 1208, 0, 0, 3976, 3978, 5, 1182, 0, 0, 3977, 3970, 1, 0, 0, 0, + 3977, 3975, 1, 0, 0, 0, 3978, 3979, 1, 0, 0, 0, 3979, 3977, 1, 0, 0, 0, + 3979, 3980, 1, 0, 0, 0, 3980, 3982, 1, 0, 0, 0, 3981, 3968, 1, 0, 0, 0, + 3981, 3977, 1, 0, 0, 0, 3982, 4000, 1, 0, 0, 0, 3983, 3984, 5, 645, 0, + 0, 3984, 3995, 5, 1188, 0, 0, 3985, 3987, 5, 1208, 0, 0, 3986, 3985, 1, + 0, 0, 0, 3986, 3987, 1, 0, 0, 0, 3987, 3988, 1, 0, 0, 0, 3988, 3989, 5, + 1182, 0, 0, 3989, 3990, 5, 1000, 0, 0, 3990, 3996, 5, 1182, 0, 0, 3991, + 3993, 5, 1208, 0, 0, 3992, 3991, 1, 0, 0, 0, 3992, 3993, 1, 0, 0, 0, 3993, + 3994, 1, 0, 0, 0, 3994, 3996, 5, 1182, 0, 0, 3995, 3986, 1, 0, 0, 0, 3995, + 3992, 1, 0, 0, 0, 3996, 3997, 1, 0, 0, 0, 3997, 3995, 1, 0, 0, 0, 3997, + 3998, 1, 0, 0, 0, 3998, 4000, 1, 0, 0, 0, 3999, 3963, 1, 0, 0, 0, 3999, + 3983, 1, 0, 0, 0, 4000, 4007, 1, 0, 0, 0, 4001, 4003, 5, 1208, 0, 0, 4002, + 4001, 1, 0, 0, 0, 4002, 4003, 1, 0, 0, 0, 4003, 4004, 1, 0, 0, 0, 4004, + 4005, 5, 564, 0, 0, 4005, 4006, 5, 1188, 0, 0, 4006, 4008, 5, 1182, 0, + 0, 4007, 4002, 1, 0, 0, 0, 4007, 4008, 1, 0, 0, 0, 4008, 4015, 1, 0, 0, + 0, 4009, 4011, 5, 1208, 0, 0, 4010, 4009, 1, 0, 0, 0, 4010, 4011, 1, 0, + 0, 0, 4011, 4012, 1, 0, 0, 0, 4012, 4013, 5, 566, 0, 0, 4013, 4014, 5, + 1188, 0, 0, 4014, 4016, 5, 1182, 0, 0, 4015, 4010, 1, 0, 0, 0, 4015, 4016, + 1, 0, 0, 0, 4016, 4017, 1, 0, 0, 0, 4017, 4018, 5, 1207, 0, 0, 4018, 319, + 1, 0, 0, 0, 4019, 4020, 5, 199, 0, 0, 4020, 4021, 5, 331, 0, 0, 4021, 4022, + 5, 813, 0, 0, 4022, 4023, 5, 725, 0, 0, 4023, 4024, 3, 1230, 615, 0, 4024, + 4025, 5, 1077, 0, 0, 4025, 4026, 5, 1206, 0, 0, 4026, 4027, 5, 556, 0, + 0, 4027, 4028, 5, 1188, 0, 0, 4028, 4066, 5, 1182, 0, 0, 4029, 4031, 5, + 1208, 0, 0, 4030, 4029, 1, 0, 0, 0, 4030, 4031, 1, 0, 0, 0, 4031, 4032, + 1, 0, 0, 0, 4032, 4033, 5, 18, 0, 0, 4033, 4034, 5, 198, 0, 0, 4034, 4048, + 5, 1188, 0, 0, 4035, 4049, 5, 69, 0, 0, 4036, 4038, 5, 1208, 0, 0, 4037, + 4036, 1, 0, 0, 0, 4037, 4038, 1, 0, 0, 0, 4038, 4039, 1, 0, 0, 0, 4039, + 4040, 5, 1182, 0, 0, 4040, 4041, 5, 1000, 0, 0, 4041, 4045, 5, 1182, 0, + 0, 4042, 4043, 5, 1208, 0, 0, 4043, 4045, 5, 1182, 0, 0, 4044, 4037, 1, + 0, 0, 0, 4044, 4042, 1, 0, 0, 0, 4045, 4046, 1, 0, 0, 0, 4046, 4044, 1, + 0, 0, 0, 4046, 4047, 1, 0, 0, 0, 4047, 4049, 1, 0, 0, 0, 4048, 4035, 1, + 0, 0, 0, 4048, 4044, 1, 0, 0, 0, 4049, 4067, 1, 0, 0, 0, 4050, 4051, 5, + 645, 0, 0, 4051, 4062, 5, 1188, 0, 0, 4052, 4054, 5, 1208, 0, 0, 4053, + 4052, 1, 0, 0, 0, 4053, 4054, 1, 0, 0, 0, 4054, 4055, 1, 0, 0, 0, 4055, + 4056, 5, 1182, 0, 0, 4056, 4057, 5, 1000, 0, 0, 4057, 4063, 5, 1182, 0, + 0, 4058, 4060, 5, 1208, 0, 0, 4059, 4058, 1, 0, 0, 0, 4059, 4060, 1, 0, + 0, 0, 4060, 4061, 1, 0, 0, 0, 4061, 4063, 5, 1182, 0, 0, 4062, 4053, 1, + 0, 0, 0, 4062, 4059, 1, 0, 0, 0, 4063, 4064, 1, 0, 0, 0, 4064, 4062, 1, + 0, 0, 0, 4064, 4065, 1, 0, 0, 0, 4065, 4067, 1, 0, 0, 0, 4066, 4030, 1, + 0, 0, 0, 4066, 4050, 1, 0, 0, 0, 4067, 4074, 1, 0, 0, 0, 4068, 4070, 5, + 1208, 0, 0, 4069, 4068, 1, 0, 0, 0, 4069, 4070, 1, 0, 0, 0, 4070, 4071, + 1, 0, 0, 0, 4071, 4072, 5, 564, 0, 0, 4072, 4073, 5, 1188, 0, 0, 4073, + 4075, 5, 1182, 0, 0, 4074, 4069, 1, 0, 0, 0, 4074, 4075, 1, 0, 0, 0, 4075, + 4082, 1, 0, 0, 0, 4076, 4078, 5, 1208, 0, 0, 4077, 4076, 1, 0, 0, 0, 4077, + 4078, 1, 0, 0, 0, 4078, 4079, 1, 0, 0, 0, 4079, 4080, 5, 566, 0, 0, 4080, + 4081, 5, 1188, 0, 0, 4081, 4083, 5, 1182, 0, 0, 4082, 4077, 1, 0, 0, 0, + 4082, 4083, 1, 0, 0, 0, 4083, 4084, 1, 0, 0, 0, 4084, 4085, 5, 1207, 0, + 0, 4085, 321, 1, 0, 0, 0, 4086, 4087, 5, 35, 0, 0, 4087, 4088, 5, 383, + 0, 0, 4088, 4089, 5, 119, 0, 0, 4089, 4100, 3, 1230, 615, 0, 4090, 4095, + 5, 780, 0, 0, 4091, 4092, 5, 1077, 0, 0, 4092, 4093, 5, 6, 0, 0, 4093, + 4094, 5, 1188, 0, 0, 4094, 4096, 7, 17, 0, 0, 4095, 4091, 1, 0, 0, 0, 4095, + 4096, 1, 0, 0, 0, 4096, 4101, 1, 0, 0, 0, 4097, 4101, 5, 795, 0, 0, 4098, + 4099, 5, 56, 0, 0, 4099, 4101, 5, 245, 0, 0, 4100, 4090, 1, 0, 0, 0, 4100, + 4097, 1, 0, 0, 0, 4100, 4098, 1, 0, 0, 0, 4101, 323, 1, 0, 0, 0, 4102, + 4103, 5, 199, 0, 0, 4103, 4104, 5, 383, 0, 0, 4104, 4105, 5, 119, 0, 0, + 4105, 4109, 3, 1230, 615, 0, 4106, 4107, 5, 662, 0, 0, 4107, 4108, 5, 344, + 0, 0, 4108, 4110, 3, 1230, 615, 0, 4109, 4106, 1, 0, 0, 0, 4109, 4110, + 1, 0, 0, 0, 4110, 4114, 1, 0, 0, 0, 4111, 4112, 5, 451, 0, 0, 4112, 4113, + 5, 704, 0, 0, 4113, 4115, 5, 1184, 0, 0, 4114, 4111, 1, 0, 0, 0, 4114, + 4115, 1, 0, 0, 0, 4115, 4120, 1, 0, 0, 0, 4116, 4117, 5, 1077, 0, 0, 4117, + 4118, 5, 6, 0, 0, 4118, 4119, 5, 1188, 0, 0, 4119, 4121, 7, 17, 0, 0, 4120, + 4116, 1, 0, 0, 0, 4120, 4121, 1, 0, 0, 0, 4121, 4124, 1, 0, 0, 0, 4122, + 4123, 5, 56, 0, 0, 4123, 4125, 5, 245, 0, 0, 4124, 4122, 1, 0, 0, 0, 4124, + 4125, 1, 0, 0, 0, 4125, 4128, 1, 0, 0, 0, 4126, 4127, 5, 68, 0, 0, 4127, + 4129, 3, 1230, 615, 0, 4128, 4126, 1, 0, 0, 0, 4128, 4129, 1, 0, 0, 0, + 4129, 325, 1, 0, 0, 0, 4130, 4131, 5, 35, 0, 0, 4131, 4132, 5, 383, 0, + 0, 4132, 4133, 5, 956, 0, 0, 4133, 4147, 3, 1230, 615, 0, 4134, 4135, 5, + 11, 0, 0, 4135, 4136, 5, 1184, 0, 0, 4136, 4137, 5, 506, 0, 0, 4137, 4148, + 7, 40, 0, 0, 4138, 4145, 5, 282, 0, 0, 4139, 4140, 5, 1184, 0, 0, 4140, + 4141, 5, 506, 0, 0, 4141, 4146, 7, 40, 0, 0, 4142, 4143, 5, 22, 0, 0, 4143, + 4146, 7, 40, 0, 0, 4144, 4146, 5, 22, 0, 0, 4145, 4139, 1, 0, 0, 0, 4145, + 4142, 1, 0, 0, 0, 4145, 4144, 1, 0, 0, 0, 4146, 4148, 1, 0, 0, 0, 4147, + 4134, 1, 0, 0, 0, 4147, 4138, 1, 0, 0, 0, 4148, 327, 1, 0, 0, 0, 4149, + 4150, 5, 199, 0, 0, 4150, 4151, 5, 383, 0, 0, 4151, 4152, 5, 956, 0, 0, + 4152, 4164, 3, 1230, 615, 0, 4153, 4162, 5, 380, 0, 0, 4154, 4155, 3, 1230, + 615, 0, 4155, 4156, 5, 1201, 0, 0, 4156, 4158, 1, 0, 0, 0, 4157, 4154, + 1, 0, 0, 0, 4157, 4158, 1, 0, 0, 0, 4158, 4159, 1, 0, 0, 0, 4159, 4163, + 3, 1230, 615, 0, 4160, 4161, 5, 978, 0, 0, 4161, 4163, 5, 956, 0, 0, 4162, + 4157, 1, 0, 0, 0, 4162, 4160, 1, 0, 0, 0, 4163, 4165, 1, 0, 0, 0, 4164, + 4153, 1, 0, 0, 0, 4164, 4165, 1, 0, 0, 0, 4165, 4168, 1, 0, 0, 0, 4166, + 4167, 5, 68, 0, 0, 4167, 4169, 3, 1230, 615, 0, 4168, 4166, 1, 0, 0, 0, + 4168, 4169, 1, 0, 0, 0, 4169, 329, 1, 0, 0, 0, 4170, 4171, 5, 35, 0, 0, + 4171, 4172, 5, 537, 0, 0, 4172, 4240, 3, 1230, 615, 0, 4173, 4175, 7, 25, + 0, 0, 4174, 4173, 1, 0, 0, 0, 4174, 4175, 1, 0, 0, 0, 4175, 4241, 1, 0, + 0, 0, 4176, 4190, 5, 1077, 0, 0, 4177, 4178, 5, 703, 0, 0, 4178, 4182, + 5, 1188, 0, 0, 4179, 4183, 5, 1184, 0, 0, 4180, 4181, 5, 1185, 0, 0, 4181, + 4183, 5, 418, 0, 0, 4182, 4179, 1, 0, 0, 0, 4182, 4180, 1, 0, 0, 0, 4183, + 4187, 1, 0, 0, 0, 4184, 4186, 7, 41, 0, 0, 4185, 4184, 1, 0, 0, 0, 4186, + 4189, 1, 0, 0, 0, 4187, 4185, 1, 0, 0, 0, 4187, 4188, 1, 0, 0, 0, 4188, + 4191, 1, 0, 0, 0, 4189, 4187, 1, 0, 0, 0, 4190, 4177, 1, 0, 0, 0, 4190, + 4191, 1, 0, 0, 0, 4191, 4201, 1, 0, 0, 0, 4192, 4193, 5, 661, 0, 0, 4193, + 4194, 5, 1188, 0, 0, 4194, 4198, 5, 1184, 0, 0, 4195, 4197, 7, 41, 0, 0, + 4196, 4195, 1, 0, 0, 0, 4197, 4200, 1, 0, 0, 0, 4198, 4196, 1, 0, 0, 0, + 4198, 4199, 1, 0, 0, 0, 4199, 4202, 1, 0, 0, 0, 4200, 4198, 1, 0, 0, 0, + 4201, 4192, 1, 0, 0, 0, 4201, 4202, 1, 0, 0, 0, 4202, 4206, 1, 0, 0, 0, + 4203, 4204, 5, 246, 0, 0, 4204, 4205, 5, 1188, 0, 0, 4205, 4207, 3, 1230, + 615, 0, 4206, 4203, 1, 0, 0, 0, 4206, 4207, 1, 0, 0, 0, 4207, 4211, 1, + 0, 0, 0, 4208, 4209, 5, 249, 0, 0, 4209, 4210, 5, 1188, 0, 0, 4210, 4212, + 3, 1230, 615, 0, 4211, 4208, 1, 0, 0, 0, 4211, 4212, 1, 0, 0, 0, 4212, + 4216, 1, 0, 0, 0, 4213, 4214, 5, 597, 0, 0, 4214, 4215, 5, 1188, 0, 0, + 4215, 4217, 3, 1230, 615, 0, 4216, 4213, 1, 0, 0, 0, 4216, 4217, 1, 0, + 0, 0, 4217, 4221, 1, 0, 0, 0, 4218, 4219, 5, 144, 0, 0, 4219, 4220, 5, + 1188, 0, 0, 4220, 4222, 7, 17, 0, 0, 4221, 4218, 1, 0, 0, 0, 4221, 4222, + 1, 0, 0, 0, 4222, 4226, 1, 0, 0, 0, 4223, 4224, 5, 143, 0, 0, 4224, 4225, + 5, 1188, 0, 0, 4225, 4227, 7, 17, 0, 0, 4226, 4223, 1, 0, 0, 0, 4226, 4227, + 1, 0, 0, 0, 4227, 4231, 1, 0, 0, 0, 4228, 4229, 5, 202, 0, 0, 4229, 4230, + 5, 1188, 0, 0, 4230, 4232, 3, 1230, 615, 0, 4231, 4228, 1, 0, 0, 0, 4231, + 4232, 1, 0, 0, 0, 4232, 4235, 1, 0, 0, 0, 4233, 4234, 5, 609, 0, 0, 4234, + 4236, 5, 202, 0, 0, 4235, 4233, 1, 0, 0, 0, 4235, 4236, 1, 0, 0, 0, 4236, + 4241, 1, 0, 0, 0, 4237, 4238, 7, 23, 0, 0, 4238, 4239, 5, 202, 0, 0, 4239, + 4241, 3, 1230, 615, 0, 4240, 4174, 1, 0, 0, 0, 4240, 4176, 1, 0, 0, 0, + 4240, 4237, 1, 0, 0, 0, 4241, 331, 1, 0, 0, 0, 4242, 4243, 5, 199, 0, 0, + 4243, 4244, 5, 537, 0, 0, 4244, 4335, 3, 1230, 615, 0, 4245, 4259, 5, 1077, + 0, 0, 4246, 4247, 5, 703, 0, 0, 4247, 4251, 5, 1188, 0, 0, 4248, 4252, + 5, 1184, 0, 0, 4249, 4250, 5, 1185, 0, 0, 4250, 4252, 5, 418, 0, 0, 4251, + 4248, 1, 0, 0, 0, 4251, 4249, 1, 0, 0, 0, 4252, 4256, 1, 0, 0, 0, 4253, + 4255, 7, 41, 0, 0, 4254, 4253, 1, 0, 0, 0, 4255, 4258, 1, 0, 0, 0, 4256, + 4254, 1, 0, 0, 0, 4256, 4257, 1, 0, 0, 0, 4257, 4260, 1, 0, 0, 0, 4258, + 4256, 1, 0, 0, 0, 4259, 4246, 1, 0, 0, 0, 4259, 4260, 1, 0, 0, 0, 4260, + 4267, 1, 0, 0, 0, 4261, 4263, 5, 1208, 0, 0, 4262, 4261, 1, 0, 0, 0, 4262, + 4263, 1, 0, 0, 0, 4263, 4264, 1, 0, 0, 0, 4264, 4265, 5, 914, 0, 0, 4265, + 4266, 5, 1188, 0, 0, 4266, 4268, 5, 1185, 0, 0, 4267, 4262, 1, 0, 0, 0, + 4267, 4268, 1, 0, 0, 0, 4268, 4275, 1, 0, 0, 0, 4269, 4271, 5, 1208, 0, + 0, 4270, 4269, 1, 0, 0, 0, 4270, 4271, 1, 0, 0, 0, 4271, 4272, 1, 0, 0, + 0, 4272, 4273, 5, 246, 0, 0, 4273, 4274, 5, 1188, 0, 0, 4274, 4276, 3, + 1230, 615, 0, 4275, 4270, 1, 0, 0, 0, 4275, 4276, 1, 0, 0, 0, 4276, 4283, + 1, 0, 0, 0, 4277, 4279, 5, 1208, 0, 0, 4278, 4277, 1, 0, 0, 0, 4278, 4279, + 1, 0, 0, 0, 4279, 4280, 1, 0, 0, 0, 4280, 4281, 5, 249, 0, 0, 4281, 4282, + 5, 1188, 0, 0, 4282, 4284, 3, 1230, 615, 0, 4283, 4278, 1, 0, 0, 0, 4283, + 4284, 1, 0, 0, 0, 4284, 4291, 1, 0, 0, 0, 4285, 4287, 5, 1208, 0, 0, 4286, + 4285, 1, 0, 0, 0, 4286, 4287, 1, 0, 0, 0, 4287, 4288, 1, 0, 0, 0, 4288, + 4289, 5, 143, 0, 0, 4289, 4290, 5, 1188, 0, 0, 4290, 4292, 7, 17, 0, 0, + 4291, 4286, 1, 0, 0, 0, 4291, 4292, 1, 0, 0, 0, 4292, 4299, 1, 0, 0, 0, + 4293, 4295, 5, 1208, 0, 0, 4294, 4293, 1, 0, 0, 0, 4294, 4295, 1, 0, 0, + 0, 4295, 4296, 1, 0, 0, 0, 4296, 4297, 5, 144, 0, 0, 4297, 4298, 5, 1188, + 0, 0, 4298, 4300, 7, 17, 0, 0, 4299, 4294, 1, 0, 0, 0, 4299, 4300, 1, 0, + 0, 0, 4300, 4307, 1, 0, 0, 0, 4301, 4303, 5, 1208, 0, 0, 4302, 4301, 1, + 0, 0, 0, 4302, 4303, 1, 0, 0, 0, 4303, 4304, 1, 0, 0, 0, 4304, 4305, 5, + 202, 0, 0, 4305, 4306, 5, 1188, 0, 0, 4306, 4308, 3, 1230, 615, 0, 4307, + 4302, 1, 0, 0, 0, 4307, 4308, 1, 0, 0, 0, 4308, 4336, 1, 0, 0, 0, 4309, + 4333, 5, 380, 0, 0, 4310, 4311, 5, 1076, 0, 0, 4311, 4318, 5, 1077, 0, + 0, 4312, 4314, 5, 1208, 0, 0, 4313, 4312, 1, 0, 0, 0, 4313, 4314, 1, 0, + 0, 0, 4314, 4315, 1, 0, 0, 0, 4315, 4316, 5, 246, 0, 0, 4316, 4317, 5, + 1188, 0, 0, 4317, 4319, 3, 1230, 615, 0, 4318, 4313, 1, 0, 0, 0, 4318, + 4319, 1, 0, 0, 0, 4319, 4326, 1, 0, 0, 0, 4320, 4322, 5, 1208, 0, 0, 4321, + 4320, 1, 0, 0, 0, 4321, 4322, 1, 0, 0, 0, 4322, 4323, 1, 0, 0, 0, 4323, + 4324, 5, 249, 0, 0, 4324, 4325, 5, 1188, 0, 0, 4325, 4327, 5, 1184, 0, + 0, 4326, 4321, 1, 0, 0, 0, 4326, 4327, 1, 0, 0, 0, 4327, 4334, 1, 0, 0, + 0, 4328, 4329, 5, 123, 0, 0, 4329, 4334, 3, 1230, 615, 0, 4330, 4331, 5, + 61, 0, 0, 4331, 4332, 5, 498, 0, 0, 4332, 4334, 3, 1230, 615, 0, 4333, + 4310, 1, 0, 0, 0, 4333, 4328, 1, 0, 0, 0, 4333, 4330, 1, 0, 0, 0, 4334, + 4336, 1, 0, 0, 0, 4335, 4245, 1, 0, 0, 0, 4335, 4309, 1, 0, 0, 0, 4336, + 333, 1, 0, 0, 0, 4337, 4338, 5, 35, 0, 0, 4338, 4339, 5, 537, 0, 0, 4339, + 4357, 3, 1230, 615, 0, 4340, 4342, 7, 25, 0, 0, 4341, 4340, 1, 0, 0, 0, + 4341, 4342, 1, 0, 0, 0, 4342, 4358, 1, 0, 0, 0, 4343, 4355, 5, 1077, 0, + 0, 4344, 4345, 5, 703, 0, 0, 4345, 4346, 5, 1188, 0, 0, 4346, 4350, 5, + 1184, 0, 0, 4347, 4348, 5, 661, 0, 0, 4348, 4349, 5, 1188, 0, 0, 4349, + 4351, 5, 1184, 0, 0, 4350, 4347, 1, 0, 0, 0, 4350, 4351, 1, 0, 0, 0, 4351, + 4356, 1, 0, 0, 0, 4352, 4353, 5, 597, 0, 0, 4353, 4354, 5, 1188, 0, 0, + 4354, 4356, 3, 1230, 615, 0, 4355, 4344, 1, 0, 0, 0, 4355, 4352, 1, 0, + 0, 0, 4356, 4358, 1, 0, 0, 0, 4357, 4341, 1, 0, 0, 0, 4357, 4343, 1, 0, + 0, 0, 4358, 335, 1, 0, 0, 0, 4359, 4360, 5, 199, 0, 0, 4360, 4361, 5, 537, + 0, 0, 4361, 4362, 3, 1230, 615, 0, 4362, 4363, 5, 1077, 0, 0, 4363, 4364, + 5, 703, 0, 0, 4364, 4365, 5, 1188, 0, 0, 4365, 4369, 5, 1184, 0, 0, 4366, + 4367, 5, 914, 0, 0, 4367, 4368, 5, 1188, 0, 0, 4368, 4370, 5, 1185, 0, + 0, 4369, 4366, 1, 0, 0, 0, 4369, 4370, 1, 0, 0, 0, 4370, 337, 1, 0, 0, + 0, 4371, 4372, 5, 35, 0, 0, 4372, 4373, 5, 537, 0, 0, 4373, 4397, 3, 1230, + 615, 0, 4374, 4376, 7, 25, 0, 0, 4375, 4374, 1, 0, 0, 0, 4375, 4376, 1, + 0, 0, 0, 4376, 4398, 1, 0, 0, 0, 4377, 4395, 5, 1077, 0, 0, 4378, 4379, + 5, 703, 0, 0, 4379, 4380, 5, 1188, 0, 0, 4380, 4390, 5, 1184, 0, 0, 4381, + 4382, 5, 661, 0, 0, 4382, 4383, 5, 1188, 0, 0, 4383, 4387, 5, 1184, 0, + 0, 4384, 4386, 7, 41, 0, 0, 4385, 4384, 1, 0, 0, 0, 4386, 4389, 1, 0, 0, + 0, 4387, 4385, 1, 0, 0, 0, 4387, 4388, 1, 0, 0, 0, 4388, 4391, 1, 0, 0, + 0, 4389, 4387, 1, 0, 0, 0, 4390, 4381, 1, 0, 0, 0, 4390, 4391, 1, 0, 0, + 0, 4391, 4396, 1, 0, 0, 0, 4392, 4393, 5, 597, 0, 0, 4393, 4394, 5, 1188, + 0, 0, 4394, 4396, 3, 1230, 615, 0, 4395, 4378, 1, 0, 0, 0, 4395, 4392, + 1, 0, 0, 0, 4396, 4398, 1, 0, 0, 0, 4397, 4375, 1, 0, 0, 0, 4397, 4377, + 1, 0, 0, 0, 4398, 339, 1, 0, 0, 0, 4399, 4400, 5, 199, 0, 0, 4400, 4401, + 5, 537, 0, 0, 4401, 4418, 3, 1230, 615, 0, 4402, 4403, 5, 1077, 0, 0, 4403, + 4404, 5, 703, 0, 0, 4404, 4405, 5, 1188, 0, 0, 4405, 4407, 5, 1184, 0, + 0, 4406, 4408, 5, 596, 0, 0, 4407, 4406, 1, 0, 0, 0, 4407, 4408, 1, 0, + 0, 0, 4408, 4414, 1, 0, 0, 0, 4409, 4410, 5, 144, 0, 0, 4410, 4412, 5, + 1188, 0, 0, 4411, 4413, 7, 17, 0, 0, 4412, 4411, 1, 0, 0, 0, 4412, 4413, + 1, 0, 0, 0, 4413, 4415, 1, 0, 0, 0, 4414, 4409, 1, 0, 0, 0, 4414, 4415, + 1, 0, 0, 0, 4415, 4419, 1, 0, 0, 0, 4416, 4417, 5, 380, 0, 0, 4417, 4419, + 5, 1076, 0, 0, 4418, 4402, 1, 0, 0, 0, 4418, 4416, 1, 0, 0, 0, 4419, 341, + 1, 0, 0, 0, 4420, 4421, 5, 35, 0, 0, 4421, 4422, 5, 547, 0, 0, 4422, 4444, + 5, 498, 0, 0, 4423, 4425, 5, 366, 0, 0, 4424, 4423, 1, 0, 0, 0, 4424, 4425, + 1, 0, 0, 0, 4425, 4426, 1, 0, 0, 0, 4426, 4427, 5, 787, 0, 0, 4427, 4428, + 5, 1077, 0, 0, 4428, 4429, 5, 297, 0, 0, 4429, 4430, 5, 111, 0, 0, 4430, + 4431, 5, 703, 0, 0, 4431, 4432, 5, 1188, 0, 0, 4432, 4445, 5, 1184, 0, + 0, 4433, 4434, 7, 23, 0, 0, 4434, 4435, 5, 297, 0, 0, 4435, 4442, 5, 111, + 0, 0, 4436, 4437, 5, 891, 0, 0, 4437, 4438, 5, 547, 0, 0, 4438, 4443, 5, + 498, 0, 0, 4439, 4440, 5, 703, 0, 0, 4440, 4441, 5, 1188, 0, 0, 4441, 4443, + 5, 1184, 0, 0, 4442, 4436, 1, 0, 0, 0, 4442, 4439, 1, 0, 0, 0, 4443, 4445, + 1, 0, 0, 0, 4444, 4424, 1, 0, 0, 0, 4444, 4433, 1, 0, 0, 0, 4445, 343, + 1, 0, 0, 0, 4446, 4447, 5, 199, 0, 0, 4447, 4448, 5, 547, 0, 0, 4448, 4449, + 5, 498, 0, 0, 4449, 4450, 5, 297, 0, 0, 4450, 4451, 5, 111, 0, 0, 4451, + 4452, 5, 703, 0, 0, 4452, 4453, 5, 1188, 0, 0, 4453, 4454, 5, 1184, 0, + 0, 4454, 345, 1, 0, 0, 0, 4455, 4456, 5, 35, 0, 0, 4456, 4457, 5, 547, + 0, 0, 4457, 4485, 5, 498, 0, 0, 4458, 4460, 5, 366, 0, 0, 4459, 4458, 1, + 0, 0, 0, 4459, 4460, 1, 0, 0, 0, 4460, 4461, 1, 0, 0, 0, 4461, 4462, 5, + 787, 0, 0, 4462, 4463, 5, 1077, 0, 0, 4463, 4464, 5, 297, 0, 0, 4464, 4465, + 5, 111, 0, 0, 4465, 4466, 5, 703, 0, 0, 4466, 4467, 5, 1188, 0, 0, 4467, + 4486, 5, 1184, 0, 0, 4468, 4469, 5, 11, 0, 0, 4469, 4470, 5, 297, 0, 0, + 4470, 4477, 5, 111, 0, 0, 4471, 4472, 5, 891, 0, 0, 4472, 4473, 5, 547, + 0, 0, 4473, 4478, 5, 498, 0, 0, 4474, 4475, 5, 703, 0, 0, 4475, 4476, 5, + 1188, 0, 0, 4476, 4478, 5, 1184, 0, 0, 4477, 4471, 1, 0, 0, 0, 4477, 4474, + 1, 0, 0, 0, 4478, 4486, 1, 0, 0, 0, 4479, 4480, 5, 282, 0, 0, 4480, 4481, + 5, 297, 0, 0, 4481, 4482, 5, 111, 0, 0, 4482, 4483, 5, 703, 0, 0, 4483, + 4484, 5, 1188, 0, 0, 4484, 4486, 5, 1184, 0, 0, 4485, 4459, 1, 0, 0, 0, + 4485, 4468, 1, 0, 0, 0, 4485, 4479, 1, 0, 0, 0, 4486, 347, 1, 0, 0, 0, + 4487, 4488, 5, 199, 0, 0, 4488, 4489, 5, 547, 0, 0, 4489, 4495, 5, 498, + 0, 0, 4490, 4491, 5, 297, 0, 0, 4491, 4492, 5, 111, 0, 0, 4492, 4493, 5, + 703, 0, 0, 4493, 4494, 5, 1188, 0, 0, 4494, 4496, 5, 1184, 0, 0, 4495, + 4490, 1, 0, 0, 0, 4495, 4496, 1, 0, 0, 0, 4496, 349, 1, 0, 0, 0, 4497, + 4498, 5, 35, 0, 0, 4498, 4499, 5, 578, 0, 0, 4499, 4500, 5, 1024, 0, 0, + 4500, 4501, 3, 1230, 615, 0, 4501, 4502, 5, 1053, 0, 0, 4502, 4511, 5, + 1188, 0, 0, 4503, 4512, 5, 621, 0, 0, 4504, 4512, 5, 291, 0, 0, 4505, 4512, + 5, 1072, 0, 0, 4506, 4507, 5, 1054, 0, 0, 4507, 4508, 5, 1077, 0, 0, 4508, + 4509, 5, 857, 0, 0, 4509, 4510, 5, 154, 0, 0, 4510, 4512, 3, 1230, 615, + 0, 4511, 4503, 1, 0, 0, 0, 4511, 4504, 1, 0, 0, 0, 4511, 4505, 1, 0, 0, + 0, 4511, 4506, 1, 0, 0, 0, 4512, 351, 1, 0, 0, 0, 4513, 4514, 5, 35, 0, + 0, 4514, 4515, 5, 700, 0, 0, 4515, 4516, 5, 386, 0, 0, 4516, 4517, 3, 1230, + 615, 0, 4517, 4518, 5, 1206, 0, 0, 4518, 4519, 5, 1207, 0, 0, 4519, 4520, + 7, 42, 0, 0, 4520, 4521, 5, 761, 0, 0, 4521, 4522, 5, 1206, 0, 0, 4522, + 4523, 5, 1182, 0, 0, 4523, 4524, 5, 1207, 0, 0, 4524, 353, 1, 0, 0, 0, + 4525, 4526, 5, 35, 0, 0, 4526, 4527, 5, 700, 0, 0, 4527, 4528, 5, 861, + 0, 0, 4528, 4529, 3, 1230, 615, 0, 4529, 4530, 5, 608, 0, 0, 4530, 4532, + 5, 1048, 0, 0, 4531, 4533, 3, 1230, 615, 0, 4532, 4531, 1, 0, 0, 0, 4532, + 4533, 1, 0, 0, 0, 4533, 355, 1, 0, 0, 0, 4534, 4535, 5, 35, 0, 0, 4535, + 4536, 5, 791, 0, 0, 4536, 4537, 5, 891, 0, 0, 4537, 4538, 5, 96, 0, 0, + 4538, 4539, 3, 1230, 615, 0, 4539, 4543, 5, 1077, 0, 0, 4540, 4541, 5, + 1049, 0, 0, 4541, 4542, 5, 1188, 0, 0, 4542, 4544, 3, 1230, 615, 0, 4543, + 4540, 1, 0, 0, 0, 4543, 4544, 1, 0, 0, 0, 4544, 4549, 1, 0, 0, 0, 4545, + 4546, 5, 1208, 0, 0, 4546, 4547, 5, 38, 0, 0, 4547, 4548, 5, 1188, 0, 0, + 4548, 4550, 7, 17, 0, 0, 4549, 4545, 1, 0, 0, 0, 4549, 4550, 1, 0, 0, 0, + 4550, 357, 1, 0, 0, 0, 4551, 4552, 5, 199, 0, 0, 4552, 4553, 5, 791, 0, + 0, 4553, 4554, 5, 891, 0, 0, 4554, 4555, 5, 96, 0, 0, 4555, 4558, 3, 1230, + 615, 0, 4556, 4557, 5, 68, 0, 0, 4557, 4559, 3, 1230, 615, 0, 4558, 4556, + 1, 0, 0, 0, 4558, 4559, 1, 0, 0, 0, 4559, 4560, 1, 0, 0, 0, 4560, 4561, + 5, 1000, 0, 0, 4561, 4562, 5, 891, 0, 0, 4562, 4563, 5, 1184, 0, 0, 4563, + 4567, 5, 1077, 0, 0, 4564, 4565, 5, 1049, 0, 0, 4565, 4566, 5, 1188, 0, + 0, 4566, 4568, 3, 1230, 615, 0, 4567, 4564, 1, 0, 0, 0, 4567, 4568, 1, + 0, 0, 0, 4568, 4573, 1, 0, 0, 0, 4569, 4570, 5, 1208, 0, 0, 4570, 4571, + 5, 38, 0, 0, 4571, 4572, 5, 1188, 0, 0, 4572, 4574, 7, 17, 0, 0, 4573, + 4569, 1, 0, 0, 0, 4573, 4574, 1, 0, 0, 0, 4574, 359, 1, 0, 0, 0, 4575, + 4576, 5, 199, 0, 0, 4576, 4577, 5, 813, 0, 0, 4577, 4578, 5, 725, 0, 0, + 4578, 4681, 3, 1230, 615, 0, 4579, 4580, 5, 1077, 0, 0, 4580, 4587, 5, + 1206, 0, 0, 4581, 4583, 5, 1208, 0, 0, 4582, 4581, 1, 0, 0, 0, 4582, 4583, + 1, 0, 0, 0, 4583, 4584, 1, 0, 0, 0, 4584, 4585, 5, 585, 0, 0, 4585, 4586, + 5, 1188, 0, 0, 4586, 4588, 5, 1182, 0, 0, 4587, 4582, 1, 0, 0, 0, 4587, + 4588, 1, 0, 0, 0, 4588, 4595, 1, 0, 0, 0, 4589, 4591, 5, 1208, 0, 0, 4590, + 4589, 1, 0, 0, 0, 4590, 4591, 1, 0, 0, 0, 4591, 4592, 1, 0, 0, 0, 4592, + 4593, 5, 556, 0, 0, 4593, 4594, 5, 1188, 0, 0, 4594, 4596, 5, 1182, 0, + 0, 4595, 4590, 1, 0, 0, 0, 4595, 4596, 1, 0, 0, 0, 4596, 4603, 1, 0, 0, + 0, 4597, 4599, 5, 1208, 0, 0, 4598, 4597, 1, 0, 0, 0, 4598, 4599, 1, 0, + 0, 0, 4599, 4600, 1, 0, 0, 0, 4600, 4601, 5, 115, 0, 0, 4601, 4602, 5, + 1188, 0, 0, 4602, 4604, 5, 1182, 0, 0, 4603, 4598, 1, 0, 0, 0, 4603, 4604, + 1, 0, 0, 0, 4604, 4646, 1, 0, 0, 0, 4605, 4607, 5, 1208, 0, 0, 4606, 4605, + 1, 0, 0, 0, 4606, 4607, 1, 0, 0, 0, 4607, 4608, 1, 0, 0, 0, 4608, 4609, + 5, 18, 0, 0, 4609, 4610, 5, 856, 0, 0, 4610, 4644, 5, 1188, 0, 0, 4611, + 4645, 5, 69, 0, 0, 4612, 4622, 5, 1206, 0, 0, 4613, 4615, 5, 1208, 0, 0, + 4614, 4613, 1, 0, 0, 0, 4614, 4615, 1, 0, 0, 0, 4615, 4620, 1, 0, 0, 0, + 4616, 4621, 5, 1182, 0, 0, 4617, 4618, 5, 1182, 0, 0, 4618, 4619, 5, 1000, + 0, 0, 4619, 4621, 5, 1182, 0, 0, 4620, 4616, 1, 0, 0, 0, 4620, 4617, 1, + 0, 0, 0, 4621, 4623, 1, 0, 0, 0, 4622, 4614, 1, 0, 0, 0, 4623, 4624, 1, + 0, 0, 0, 4624, 4622, 1, 0, 0, 0, 4624, 4625, 1, 0, 0, 0, 4625, 4626, 1, + 0, 0, 0, 4626, 4645, 5, 1207, 0, 0, 4627, 4628, 5, 645, 0, 0, 4628, 4629, + 5, 1188, 0, 0, 4629, 4639, 5, 1206, 0, 0, 4630, 4632, 5, 1208, 0, 0, 4631, + 4630, 1, 0, 0, 0, 4631, 4632, 1, 0, 0, 0, 4632, 4637, 1, 0, 0, 0, 4633, + 4638, 5, 1182, 0, 0, 4634, 4635, 5, 1182, 0, 0, 4635, 4636, 5, 1000, 0, + 0, 4636, 4638, 5, 1182, 0, 0, 4637, 4633, 1, 0, 0, 0, 4637, 4634, 1, 0, + 0, 0, 4638, 4640, 1, 0, 0, 0, 4639, 4631, 1, 0, 0, 0, 4640, 4641, 1, 0, + 0, 0, 4641, 4639, 1, 0, 0, 0, 4641, 4642, 1, 0, 0, 0, 4642, 4643, 1, 0, + 0, 0, 4643, 4645, 5, 1207, 0, 0, 4644, 4611, 1, 0, 0, 0, 4644, 4612, 1, + 0, 0, 0, 4644, 4627, 1, 0, 0, 0, 4645, 4647, 1, 0, 0, 0, 4646, 4606, 1, + 0, 0, 0, 4646, 4647, 1, 0, 0, 0, 4647, 4654, 1, 0, 0, 0, 4648, 4650, 5, + 1208, 0, 0, 4649, 4648, 1, 0, 0, 0, 4649, 4650, 1, 0, 0, 0, 4650, 4651, + 1, 0, 0, 0, 4651, 4652, 5, 587, 0, 0, 4652, 4653, 5, 1188, 0, 0, 4653, + 4655, 5, 1182, 0, 0, 4654, 4649, 1, 0, 0, 0, 4654, 4655, 1, 0, 0, 0, 4655, + 4662, 1, 0, 0, 0, 4656, 4658, 5, 1208, 0, 0, 4657, 4656, 1, 0, 0, 0, 4657, + 4658, 1, 0, 0, 0, 4658, 4659, 1, 0, 0, 0, 4659, 4660, 5, 564, 0, 0, 4660, + 4661, 5, 1188, 0, 0, 4661, 4663, 5, 1182, 0, 0, 4662, 4657, 1, 0, 0, 0, + 4662, 4663, 1, 0, 0, 0, 4663, 4670, 1, 0, 0, 0, 4664, 4666, 5, 1208, 0, + 0, 4665, 4664, 1, 0, 0, 0, 4665, 4666, 1, 0, 0, 0, 4666, 4667, 1, 0, 0, + 0, 4667, 4668, 5, 586, 0, 0, 4668, 4669, 5, 1188, 0, 0, 4669, 4671, 5, + 1182, 0, 0, 4670, 4665, 1, 0, 0, 0, 4670, 4671, 1, 0, 0, 0, 4671, 4678, + 1, 0, 0, 0, 4672, 4674, 5, 1208, 0, 0, 4673, 4672, 1, 0, 0, 0, 4673, 4674, + 1, 0, 0, 0, 4674, 4675, 1, 0, 0, 0, 4675, 4676, 5, 562, 0, 0, 4676, 4677, + 5, 1188, 0, 0, 4677, 4679, 5, 1182, 0, 0, 4678, 4673, 1, 0, 0, 0, 4678, + 4679, 1, 0, 0, 0, 4679, 4680, 1, 0, 0, 0, 4680, 4682, 5, 1207, 0, 0, 4681, + 4579, 1, 0, 0, 0, 4681, 4682, 1, 0, 0, 0, 4682, 361, 1, 0, 0, 0, 4683, + 4684, 5, 35, 0, 0, 4684, 4685, 5, 813, 0, 0, 4685, 4707, 5, 409, 0, 0, + 4686, 4708, 7, 43, 0, 0, 4687, 4688, 5, 1077, 0, 0, 4688, 4689, 5, 1206, + 0, 0, 4689, 4690, 5, 145, 0, 0, 4690, 4696, 5, 1188, 0, 0, 4691, 4692, + 3, 1230, 615, 0, 4692, 4693, 5, 1201, 0, 0, 4693, 4694, 3, 1230, 615, 0, + 4694, 4697, 1, 0, 0, 0, 4695, 4697, 5, 643, 0, 0, 4696, 4691, 1, 0, 0, + 0, 4696, 4695, 1, 0, 0, 0, 4697, 4698, 1, 0, 0, 0, 4698, 4708, 5, 1207, + 0, 0, 4699, 4700, 5, 812, 0, 0, 4700, 4708, 5, 945, 0, 0, 4701, 4702, 5, + 1077, 0, 0, 4702, 4703, 5, 1206, 0, 0, 4703, 4704, 5, 565, 0, 0, 4704, + 4705, 5, 1188, 0, 0, 4705, 4706, 5, 1182, 0, 0, 4706, 4708, 5, 1207, 0, + 0, 4707, 4686, 1, 0, 0, 0, 4707, 4687, 1, 0, 0, 0, 4707, 4699, 1, 0, 0, + 0, 4707, 4701, 1, 0, 0, 0, 4708, 363, 1, 0, 0, 0, 4709, 4710, 5, 35, 0, + 0, 4710, 4711, 5, 219, 0, 0, 4711, 4712, 5, 64, 0, 0, 4712, 4713, 5, 931, + 0, 0, 4713, 4718, 3, 1230, 615, 0, 4714, 4715, 5, 365, 0, 0, 4715, 4716, + 5, 889, 0, 0, 4716, 4717, 5, 64, 0, 0, 4717, 4719, 3, 1230, 615, 0, 4718, + 4714, 1, 0, 0, 0, 4718, 4719, 1, 0, 0, 0, 4719, 4728, 1, 0, 0, 0, 4720, + 4725, 3, 366, 183, 0, 4721, 4722, 5, 1208, 0, 0, 4722, 4724, 3, 366, 183, + 0, 4723, 4721, 1, 0, 0, 0, 4724, 4727, 1, 0, 0, 0, 4725, 4723, 1, 0, 0, + 0, 4725, 4726, 1, 0, 0, 0, 4726, 4729, 1, 0, 0, 0, 4727, 4725, 1, 0, 0, + 0, 4728, 4720, 1, 0, 0, 0, 4728, 4729, 1, 0, 0, 0, 4729, 4736, 1, 0, 0, + 0, 4730, 4731, 5, 1077, 0, 0, 4731, 4732, 5, 1206, 0, 0, 4732, 4733, 5, + 943, 0, 0, 4733, 4734, 5, 1188, 0, 0, 4734, 4735, 7, 17, 0, 0, 4735, 4737, + 5, 1207, 0, 0, 4736, 4730, 1, 0, 0, 0, 4736, 4737, 1, 0, 0, 0, 4737, 365, + 1, 0, 0, 0, 4738, 4739, 7, 23, 0, 0, 4739, 4742, 5, 1206, 0, 0, 4740, 4743, + 3, 368, 184, 0, 4741, 4743, 3, 1230, 615, 0, 4742, 4740, 1, 0, 0, 0, 4742, + 4741, 1, 0, 0, 0, 4743, 4744, 1, 0, 0, 0, 4744, 4745, 5, 1207, 0, 0, 4745, + 367, 1, 0, 0, 0, 4746, 4751, 3, 370, 185, 0, 4747, 4748, 5, 1208, 0, 0, + 4748, 4750, 3, 370, 185, 0, 4749, 4747, 1, 0, 0, 0, 4750, 4753, 1, 0, 0, + 0, 4751, 4749, 1, 0, 0, 0, 4751, 4752, 1, 0, 0, 0, 4752, 4754, 1, 0, 0, + 0, 4753, 4751, 1, 0, 0, 0, 4754, 4758, 5, 662, 0, 0, 4755, 4756, 3, 372, + 186, 0, 4756, 4757, 5, 1211, 0, 0, 4757, 4759, 1, 0, 0, 0, 4758, 4755, + 1, 0, 0, 0, 4758, 4759, 1, 0, 0, 0, 4759, 4760, 1, 0, 0, 0, 4760, 4761, + 3, 374, 187, 0, 4761, 4762, 5, 111, 0, 0, 4762, 4767, 3, 776, 388, 0, 4763, + 4764, 5, 1208, 0, 0, 4764, 4766, 3, 776, 388, 0, 4765, 4763, 1, 0, 0, 0, + 4766, 4769, 1, 0, 0, 0, 4767, 4765, 1, 0, 0, 0, 4767, 4768, 1, 0, 0, 0, + 4768, 369, 1, 0, 0, 0, 4769, 4767, 1, 0, 0, 0, 4770, 4771, 7, 44, 0, 0, + 4771, 371, 1, 0, 0, 0, 4772, 4773, 7, 45, 0, 0, 4773, 373, 1, 0, 0, 0, + 4774, 4775, 3, 1230, 615, 0, 4775, 4776, 5, 1201, 0, 0, 4776, 4778, 1, + 0, 0, 0, 4777, 4774, 1, 0, 0, 0, 4777, 4778, 1, 0, 0, 0, 4778, 4779, 1, + 0, 0, 0, 4779, 4780, 3, 1230, 615, 0, 4780, 4781, 5, 1201, 0, 0, 4781, + 4783, 1, 0, 0, 0, 4782, 4777, 1, 0, 0, 0, 4782, 4783, 1, 0, 0, 0, 4783, + 4784, 1, 0, 0, 0, 4784, 4785, 3, 1230, 615, 0, 4785, 375, 1, 0, 0, 0, 4786, + 4787, 5, 35, 0, 0, 4787, 4788, 5, 832, 0, 0, 4788, 4796, 3, 1230, 615, + 0, 4789, 4790, 7, 23, 0, 0, 4790, 4791, 5, 574, 0, 0, 4791, 4797, 3, 1230, + 615, 0, 4792, 4793, 5, 1077, 0, 0, 4793, 4794, 5, 597, 0, 0, 4794, 4795, + 5, 1188, 0, 0, 4795, 4797, 3, 1230, 615, 0, 4796, 4789, 1, 0, 0, 0, 4796, + 4792, 1, 0, 0, 0, 4797, 377, 1, 0, 0, 0, 4798, 4799, 5, 199, 0, 0, 4799, + 4800, 5, 219, 0, 0, 4800, 4801, 5, 64, 0, 0, 4801, 4802, 5, 931, 0, 0, + 4802, 4807, 3, 1230, 615, 0, 4803, 4804, 5, 365, 0, 0, 4804, 4805, 5, 889, + 0, 0, 4805, 4806, 5, 64, 0, 0, 4806, 4808, 3, 1230, 615, 0, 4807, 4803, + 1, 0, 0, 0, 4807, 4808, 1, 0, 0, 0, 4808, 4817, 1, 0, 0, 0, 4809, 4814, + 3, 366, 183, 0, 4810, 4811, 5, 1208, 0, 0, 4811, 4813, 3, 366, 183, 0, + 4812, 4810, 1, 0, 0, 0, 4813, 4816, 1, 0, 0, 0, 4814, 4812, 1, 0, 0, 0, + 4814, 4815, 1, 0, 0, 0, 4815, 4818, 1, 0, 0, 0, 4816, 4814, 1, 0, 0, 0, + 4817, 4809, 1, 0, 0, 0, 4817, 4818, 1, 0, 0, 0, 4818, 4825, 1, 0, 0, 0, + 4819, 4820, 5, 1077, 0, 0, 4820, 4821, 5, 1206, 0, 0, 4821, 4822, 5, 943, + 0, 0, 4822, 4823, 5, 1188, 0, 0, 4823, 4824, 7, 17, 0, 0, 4824, 4826, 5, + 1207, 0, 0, 4825, 4819, 1, 0, 0, 0, 4825, 4826, 1, 0, 0, 0, 4826, 379, + 1, 0, 0, 0, 4827, 4828, 5, 199, 0, 0, 4828, 4829, 5, 832, 0, 0, 4829, 4832, + 3, 1230, 615, 0, 4830, 4831, 5, 68, 0, 0, 4831, 4833, 3, 1230, 615, 0, + 4832, 4830, 1, 0, 0, 0, 4832, 4833, 1, 0, 0, 0, 4833, 381, 1, 0, 0, 0, + 4834, 4835, 5, 199, 0, 0, 4835, 4836, 5, 836, 0, 0, 4836, 4839, 3, 1230, + 615, 0, 4837, 4838, 5, 68, 0, 0, 4838, 4840, 3, 1230, 615, 0, 4839, 4837, + 1, 0, 0, 0, 4839, 4840, 1, 0, 0, 0, 4840, 4841, 1, 0, 0, 0, 4841, 4848, + 5, 1077, 0, 0, 4842, 4844, 5, 1208, 0, 0, 4843, 4842, 1, 0, 0, 0, 4843, + 4844, 1, 0, 0, 0, 4844, 4845, 1, 0, 0, 0, 4845, 4846, 5, 894, 0, 0, 4846, + 4847, 5, 1188, 0, 0, 4847, 4849, 5, 1184, 0, 0, 4848, 4843, 1, 0, 0, 0, + 4848, 4849, 1, 0, 0, 0, 4849, 4856, 1, 0, 0, 0, 4850, 4852, 5, 1208, 0, + 0, 4851, 4850, 1, 0, 0, 0, 4851, 4852, 1, 0, 0, 0, 4852, 4853, 1, 0, 0, + 0, 4853, 4854, 5, 105, 0, 0, 4854, 4855, 5, 1188, 0, 0, 4855, 4857, 5, + 1184, 0, 0, 4856, 4851, 1, 0, 0, 0, 4856, 4857, 1, 0, 0, 0, 4857, 4864, + 1, 0, 0, 0, 4858, 4860, 5, 1208, 0, 0, 4859, 4858, 1, 0, 0, 0, 4859, 4860, + 1, 0, 0, 0, 4860, 4861, 1, 0, 0, 0, 4861, 4862, 5, 519, 0, 0, 4862, 4863, + 5, 1188, 0, 0, 4863, 4865, 5, 1182, 0, 0, 4864, 4859, 1, 0, 0, 0, 4864, + 4865, 1, 0, 0, 0, 4865, 4867, 1, 0, 0, 0, 4866, 4868, 5, 1208, 0, 0, 4867, + 4866, 1, 0, 0, 0, 4867, 4868, 1, 0, 0, 0, 4868, 4869, 1, 0, 0, 0, 4869, + 4870, 5, 12, 0, 0, 4870, 4871, 5, 1188, 0, 0, 4871, 4876, 5, 1184, 0, 0, + 4872, 4873, 5, 1208, 0, 0, 4873, 4874, 5, 589, 0, 0, 4874, 4875, 5, 1188, + 0, 0, 4875, 4877, 5, 1184, 0, 0, 4876, 4872, 1, 0, 0, 0, 4876, 4877, 1, + 0, 0, 0, 4877, 383, 1, 0, 0, 0, 4878, 4879, 5, 199, 0, 0, 4879, 4883, 5, + 851, 0, 0, 4880, 4881, 3, 1230, 615, 0, 4881, 4882, 5, 1201, 0, 0, 4882, + 4884, 1, 0, 0, 0, 4883, 4880, 1, 0, 0, 0, 4883, 4884, 1, 0, 0, 0, 4884, + 4885, 1, 0, 0, 0, 4885, 4886, 3, 1230, 615, 0, 4886, 4887, 5, 56, 0, 0, + 4887, 4888, 3, 950, 475, 0, 4888, 385, 1, 0, 0, 0, 4889, 4890, 5, 35, 0, + 0, 4890, 4891, 5, 857, 0, 0, 4891, 4892, 3, 1230, 615, 0, 4892, 4901, 5, + 1010, 0, 0, 4893, 4899, 5, 648, 0, 0, 4894, 4899, 5, 1024, 0, 0, 4895, + 4896, 5, 1088, 0, 0, 4896, 4897, 5, 857, 0, 0, 4897, 4899, 5, 154, 0, 0, + 4898, 4893, 1, 0, 0, 0, 4898, 4894, 1, 0, 0, 0, 4898, 4895, 1, 0, 0, 0, + 4899, 4900, 1, 0, 0, 0, 4900, 4902, 5, 1211, 0, 0, 4901, 4898, 1, 0, 0, + 0, 4901, 4902, 1, 0, 0, 0, 4902, 4903, 1, 0, 0, 0, 4903, 4906, 3, 1230, + 615, 0, 4904, 4905, 5, 1201, 0, 0, 4905, 4907, 3, 1230, 615, 0, 4906, 4904, + 1, 0, 0, 0, 4906, 4907, 1, 0, 0, 0, 4907, 387, 1, 0, 0, 0, 4908, 4909, + 5, 199, 0, 0, 4909, 4917, 5, 857, 0, 0, 4910, 4918, 3, 1230, 615, 0, 4911, + 4912, 5, 68, 0, 0, 4912, 4918, 3, 1230, 615, 0, 4913, 4914, 3, 1230, 615, + 0, 4914, 4915, 5, 68, 0, 0, 4915, 4916, 3, 1230, 615, 0, 4916, 4918, 1, + 0, 0, 0, 4917, 4910, 1, 0, 0, 0, 4917, 4911, 1, 0, 0, 0, 4917, 4913, 1, + 0, 0, 0, 4918, 4945, 1, 0, 0, 0, 4919, 4944, 3, 598, 299, 0, 4920, 4944, + 3, 610, 305, 0, 4921, 4922, 7, 46, 0, 0, 4922, 4923, 7, 47, 0, 0, 4923, + 4926, 5, 662, 0, 0, 4924, 4925, 5, 857, 0, 0, 4925, 4927, 5, 1211, 0, 0, + 4926, 4924, 1, 0, 0, 0, 4926, 4927, 1, 0, 0, 0, 4927, 4928, 1, 0, 0, 0, + 4928, 4929, 3, 1230, 615, 0, 4929, 4930, 5, 1000, 0, 0, 4930, 4931, 3, + 1230, 615, 0, 4931, 4944, 1, 0, 0, 0, 4932, 4933, 5, 828, 0, 0, 4933, 4934, + 7, 47, 0, 0, 4934, 4937, 5, 662, 0, 0, 4935, 4936, 5, 857, 0, 0, 4936, + 4938, 5, 1211, 0, 0, 4937, 4935, 1, 0, 0, 0, 4937, 4938, 1, 0, 0, 0, 4938, + 4939, 1, 0, 0, 0, 4939, 4940, 3, 1230, 615, 0, 4940, 4941, 5, 380, 0, 0, + 4941, 4942, 3, 1230, 615, 0, 4942, 4944, 1, 0, 0, 0, 4943, 4919, 1, 0, + 0, 0, 4943, 4920, 1, 0, 0, 0, 4943, 4921, 1, 0, 0, 0, 4943, 4932, 1, 0, + 0, 0, 4944, 4947, 1, 0, 0, 0, 4945, 4943, 1, 0, 0, 0, 4945, 4946, 1, 0, + 0, 0, 4946, 389, 1, 0, 0, 0, 4947, 4945, 1, 0, 0, 0, 4948, 4949, 5, 199, + 0, 0, 4949, 4950, 5, 857, 0, 0, 4950, 4953, 3, 1230, 615, 0, 4951, 4952, + 5, 68, 0, 0, 4952, 4954, 3, 1230, 615, 0, 4953, 4951, 1, 0, 0, 0, 4953, + 4954, 1, 0, 0, 0, 4954, 391, 1, 0, 0, 0, 4955, 4956, 5, 35, 0, 0, 4956, + 4957, 5, 857, 0, 0, 4957, 4958, 3, 1230, 615, 0, 4958, 4961, 5, 1010, 0, + 0, 4959, 4960, 5, 648, 0, 0, 4960, 4962, 5, 1211, 0, 0, 4961, 4959, 1, + 0, 0, 0, 4961, 4962, 1, 0, 0, 0, 4962, 4963, 1, 0, 0, 0, 4963, 4966, 3, + 1230, 615, 0, 4964, 4965, 5, 1201, 0, 0, 4965, 4967, 5, 1183, 0, 0, 4966, + 4964, 1, 0, 0, 0, 4966, 4967, 1, 0, 0, 0, 4967, 393, 1, 0, 0, 0, 4968, + 4969, 5, 199, 0, 0, 4969, 4970, 5, 867, 0, 0, 4970, 4971, 5, 745, 0, 0, + 4971, 4972, 5, 524, 0, 0, 4972, 4980, 3, 1230, 615, 0, 4973, 4977, 5, 380, + 0, 0, 4974, 4975, 3, 1230, 615, 0, 4975, 4976, 5, 1201, 0, 0, 4976, 4978, + 1, 0, 0, 0, 4977, 4974, 1, 0, 0, 0, 4977, 4978, 1, 0, 0, 0, 4978, 4979, + 1, 0, 0, 0, 4979, 4981, 3, 1230, 615, 0, 4980, 4973, 1, 0, 0, 0, 4980, + 4981, 1, 0, 0, 0, 4981, 4984, 1, 0, 0, 0, 4982, 4983, 5, 68, 0, 0, 4983, + 4985, 3, 1230, 615, 0, 4984, 4982, 1, 0, 0, 0, 4984, 4985, 1, 0, 0, 0, + 4985, 395, 1, 0, 0, 0, 4986, 4987, 5, 199, 0, 0, 4987, 4988, 5, 874, 0, + 0, 4988, 4992, 5, 724, 0, 0, 4989, 4990, 3, 1230, 615, 0, 4990, 4991, 5, + 1201, 0, 0, 4991, 4993, 1, 0, 0, 0, 4992, 4989, 1, 0, 0, 0, 4992, 4993, + 1, 0, 0, 0, 4993, 4994, 1, 0, 0, 0, 4994, 5035, 3, 1230, 615, 0, 4995, + 4997, 5, 1208, 0, 0, 4996, 4995, 1, 0, 0, 0, 4996, 4997, 1, 0, 0, 0, 4997, + 4998, 1, 0, 0, 0, 4998, 5000, 5, 11, 0, 0, 4999, 5001, 7, 48, 0, 0, 5000, + 4999, 1, 0, 0, 0, 5000, 5001, 1, 0, 0, 0, 5001, 5002, 1, 0, 0, 0, 5002, + 5003, 5, 729, 0, 0, 5003, 5004, 3, 1230, 615, 0, 5004, 5005, 5, 1201, 0, + 0, 5005, 5006, 3, 1230, 615, 0, 5006, 5011, 5, 1206, 0, 0, 5007, 5009, + 5, 1208, 0, 0, 5008, 5007, 1, 0, 0, 0, 5008, 5009, 1, 0, 0, 0, 5009, 5010, + 1, 0, 0, 0, 5010, 5012, 3, 1230, 615, 0, 5011, 5008, 1, 0, 0, 0, 5012, + 5013, 1, 0, 0, 0, 5013, 5011, 1, 0, 0, 0, 5013, 5014, 1, 0, 0, 0, 5014, + 5015, 1, 0, 0, 0, 5015, 5016, 5, 1207, 0, 0, 5016, 5017, 5, 662, 0, 0, + 5017, 5018, 3, 1230, 615, 0, 5018, 5019, 5, 1201, 0, 0, 5019, 5032, 3, + 1230, 615, 0, 5020, 5022, 5, 1208, 0, 0, 5021, 5020, 1, 0, 0, 0, 5021, + 5022, 1, 0, 0, 0, 5022, 5023, 1, 0, 0, 0, 5023, 5024, 5, 19, 0, 0, 5024, + 5031, 7, 49, 0, 0, 5025, 5027, 5, 1208, 0, 0, 5026, 5025, 1, 0, 0, 0, 5026, + 5027, 1, 0, 0, 0, 5027, 5028, 1, 0, 0, 0, 5028, 5029, 5, 89, 0, 0, 5029, + 5031, 7, 50, 0, 0, 5030, 5021, 1, 0, 0, 0, 5030, 5026, 1, 0, 0, 0, 5031, + 5034, 1, 0, 0, 0, 5032, 5030, 1, 0, 0, 0, 5032, 5033, 1, 0, 0, 0, 5033, + 5036, 1, 0, 0, 0, 5034, 5032, 1, 0, 0, 0, 5035, 4996, 1, 0, 0, 0, 5036, + 5037, 1, 0, 0, 0, 5037, 5035, 1, 0, 0, 0, 5037, 5038, 1, 0, 0, 0, 5038, + 5049, 1, 0, 0, 0, 5039, 5040, 5, 1077, 0, 0, 5040, 5041, 5, 1206, 0, 0, + 5041, 5042, 5, 943, 0, 0, 5042, 5043, 5, 1188, 0, 0, 5043, 5046, 7, 17, + 0, 0, 5044, 5045, 5, 858, 0, 0, 5045, 5047, 7, 17, 0, 0, 5046, 5044, 1, + 0, 0, 0, 5046, 5047, 1, 0, 0, 0, 5047, 5048, 1, 0, 0, 0, 5048, 5050, 5, + 1207, 0, 0, 5049, 5039, 1, 0, 0, 0, 5049, 5050, 1, 0, 0, 0, 5050, 5054, + 1, 0, 0, 0, 5051, 5052, 5, 627, 0, 0, 5052, 5053, 5, 365, 0, 0, 5053, 5055, + 5, 804, 0, 0, 5054, 5051, 1, 0, 0, 0, 5054, 5055, 1, 0, 0, 0, 5055, 397, + 1, 0, 0, 0, 5056, 5057, 5, 35, 0, 0, 5057, 5061, 5, 886, 0, 0, 5058, 5059, + 3, 1230, 615, 0, 5059, 5060, 5, 1201, 0, 0, 5060, 5062, 1, 0, 0, 0, 5061, + 5058, 1, 0, 0, 0, 5061, 5062, 1, 0, 0, 0, 5062, 5063, 1, 0, 0, 0, 5063, + 5069, 3, 1230, 615, 0, 5064, 5067, 5, 816, 0, 0, 5065, 5066, 5, 1077, 0, + 0, 5066, 5068, 5, 1182, 0, 0, 5067, 5065, 1, 0, 0, 0, 5067, 5068, 1, 0, + 0, 0, 5068, 5070, 1, 0, 0, 0, 5069, 5064, 1, 0, 0, 0, 5069, 5070, 1, 0, + 0, 0, 5070, 5074, 1, 0, 0, 0, 5071, 5072, 5, 454, 0, 0, 5072, 5073, 5, + 111, 0, 0, 5073, 5075, 5, 1182, 0, 0, 5074, 5071, 1, 0, 0, 0, 5074, 5075, + 1, 0, 0, 0, 5075, 5080, 1, 0, 0, 0, 5076, 5077, 5, 583, 0, 0, 5077, 5081, + 5, 1182, 0, 0, 5078, 5079, 5, 609, 0, 0, 5079, 5081, 5, 583, 0, 0, 5080, + 5076, 1, 0, 0, 0, 5080, 5078, 1, 0, 0, 0, 5080, 5081, 1, 0, 0, 0, 5081, + 5086, 1, 0, 0, 0, 5082, 5083, 5, 555, 0, 0, 5083, 5087, 5, 1182, 0, 0, + 5084, 5085, 5, 609, 0, 0, 5085, 5087, 5, 555, 0, 0, 5086, 5082, 1, 0, 0, + 0, 5086, 5084, 1, 0, 0, 0, 5086, 5087, 1, 0, 0, 0, 5087, 5091, 1, 0, 0, + 0, 5088, 5092, 5, 217, 0, 0, 5089, 5090, 5, 609, 0, 0, 5090, 5092, 5, 217, + 0, 0, 5091, 5088, 1, 0, 0, 0, 5091, 5089, 1, 0, 0, 0, 5091, 5092, 1, 0, + 0, 0, 5092, 5097, 1, 0, 0, 0, 5093, 5094, 5, 112, 0, 0, 5094, 5098, 5, + 1182, 0, 0, 5095, 5096, 5, 609, 0, 0, 5096, 5098, 5, 112, 0, 0, 5097, 5093, + 1, 0, 0, 0, 5097, 5095, 1, 0, 0, 0, 5097, 5098, 1, 0, 0, 0, 5098, 399, + 1, 0, 0, 0, 5099, 5100, 5, 199, 0, 0, 5100, 5104, 5, 886, 0, 0, 5101, 5102, + 3, 1230, 615, 0, 5102, 5103, 5, 1201, 0, 0, 5103, 5105, 1, 0, 0, 0, 5104, + 5101, 1, 0, 0, 0, 5104, 5105, 1, 0, 0, 0, 5105, 5106, 1, 0, 0, 0, 5106, + 5109, 3, 1230, 615, 0, 5107, 5108, 5, 56, 0, 0, 5108, 5110, 3, 1222, 611, + 0, 5109, 5107, 1, 0, 0, 0, 5109, 5110, 1, 0, 0, 0, 5110, 5114, 1, 0, 0, + 0, 5111, 5112, 5, 939, 0, 0, 5112, 5113, 5, 1077, 0, 0, 5113, 5115, 5, + 1182, 0, 0, 5114, 5111, 1, 0, 0, 0, 5114, 5115, 1, 0, 0, 0, 5115, 5122, + 1, 0, 0, 0, 5116, 5117, 5, 454, 0, 0, 5117, 5119, 5, 111, 0, 0, 5118, 5120, + 5, 1216, 0, 0, 5119, 5118, 1, 0, 0, 0, 5119, 5120, 1, 0, 0, 0, 5120, 5121, + 1, 0, 0, 0, 5121, 5123, 5, 1182, 0, 0, 5122, 5116, 1, 0, 0, 0, 5122, 5123, + 1, 0, 0, 0, 5123, 5133, 1, 0, 0, 0, 5124, 5129, 5, 583, 0, 0, 5125, 5127, + 5, 1216, 0, 0, 5126, 5125, 1, 0, 0, 0, 5126, 5127, 1, 0, 0, 0, 5127, 5128, + 1, 0, 0, 0, 5128, 5130, 5, 1182, 0, 0, 5129, 5126, 1, 0, 0, 0, 5129, 5130, + 1, 0, 0, 0, 5130, 5134, 1, 0, 0, 0, 5131, 5132, 5, 609, 0, 0, 5132, 5134, + 5, 583, 0, 0, 5133, 5124, 1, 0, 0, 0, 5133, 5131, 1, 0, 0, 0, 5133, 5134, + 1, 0, 0, 0, 5134, 5144, 1, 0, 0, 0, 5135, 5140, 5, 555, 0, 0, 5136, 5138, + 5, 1216, 0, 0, 5137, 5136, 1, 0, 0, 0, 5137, 5138, 1, 0, 0, 0, 5138, 5139, + 1, 0, 0, 0, 5139, 5141, 5, 1182, 0, 0, 5140, 5137, 1, 0, 0, 0, 5140, 5141, + 1, 0, 0, 0, 5141, 5145, 1, 0, 0, 0, 5142, 5143, 5, 609, 0, 0, 5143, 5145, + 5, 555, 0, 0, 5144, 5135, 1, 0, 0, 0, 5144, 5142, 1, 0, 0, 0, 5144, 5145, + 1, 0, 0, 0, 5145, 5149, 1, 0, 0, 0, 5146, 5150, 5, 217, 0, 0, 5147, 5148, + 5, 609, 0, 0, 5148, 5150, 5, 217, 0, 0, 5149, 5146, 1, 0, 0, 0, 5149, 5147, + 1, 0, 0, 0, 5149, 5150, 1, 0, 0, 0, 5150, 5157, 1, 0, 0, 0, 5151, 5153, + 5, 112, 0, 0, 5152, 5154, 5, 1182, 0, 0, 5153, 5152, 1, 0, 0, 0, 5153, + 5154, 1, 0, 0, 0, 5154, 5158, 1, 0, 0, 0, 5155, 5156, 5, 609, 0, 0, 5156, + 5158, 5, 112, 0, 0, 5157, 5151, 1, 0, 0, 0, 5157, 5155, 1, 0, 0, 0, 5157, + 5158, 1, 0, 0, 0, 5158, 401, 1, 0, 0, 0, 5159, 5160, 5, 35, 0, 0, 5160, + 5161, 5, 889, 0, 0, 5161, 5162, 5, 64, 0, 0, 5162, 5294, 3, 1230, 615, + 0, 5163, 5208, 5, 1000, 0, 0, 5164, 5165, 5, 343, 0, 0, 5165, 5202, 5, + 1206, 0, 0, 5166, 5168, 5, 1208, 0, 0, 5167, 5166, 1, 0, 0, 0, 5167, 5168, + 1, 0, 0, 0, 5168, 5169, 1, 0, 0, 0, 5169, 5170, 5, 350, 0, 0, 5170, 5171, + 5, 1188, 0, 0, 5171, 5201, 5, 1184, 0, 0, 5172, 5174, 5, 1208, 0, 0, 5173, + 5172, 1, 0, 0, 0, 5173, 5174, 1, 0, 0, 0, 5174, 5175, 1, 0, 0, 0, 5175, + 5176, 5, 553, 0, 0, 5176, 5180, 5, 1188, 0, 0, 5177, 5178, 5, 1182, 0, + 0, 5178, 5181, 7, 51, 0, 0, 5179, 5181, 5, 1036, 0, 0, 5180, 5177, 1, 0, + 0, 0, 5180, 5179, 1, 0, 0, 0, 5181, 5201, 1, 0, 0, 0, 5182, 5184, 5, 1208, + 0, 0, 5183, 5182, 1, 0, 0, 0, 5183, 5184, 1, 0, 0, 0, 5184, 5185, 1, 0, + 0, 0, 5185, 5186, 5, 568, 0, 0, 5186, 5187, 5, 1188, 0, 0, 5187, 5201, + 7, 52, 0, 0, 5188, 5190, 5, 1208, 0, 0, 5189, 5188, 1, 0, 0, 0, 5189, 5190, + 1, 0, 0, 0, 5190, 5191, 1, 0, 0, 0, 5191, 5192, 5, 561, 0, 0, 5192, 5193, + 5, 1188, 0, 0, 5193, 5201, 5, 1182, 0, 0, 5194, 5196, 5, 1208, 0, 0, 5195, + 5194, 1, 0, 0, 0, 5195, 5196, 1, 0, 0, 0, 5196, 5197, 1, 0, 0, 0, 5197, + 5198, 5, 811, 0, 0, 5198, 5199, 5, 1188, 0, 0, 5199, 5201, 7, 17, 0, 0, + 5200, 5167, 1, 0, 0, 0, 5200, 5173, 1, 0, 0, 0, 5200, 5183, 1, 0, 0, 0, + 5200, 5189, 1, 0, 0, 0, 5200, 5195, 1, 0, 0, 0, 5201, 5204, 1, 0, 0, 0, + 5202, 5200, 1, 0, 0, 0, 5202, 5203, 1, 0, 0, 0, 5203, 5205, 1, 0, 0, 0, + 5204, 5202, 1, 0, 0, 0, 5205, 5209, 5, 1207, 0, 0, 5206, 5209, 5, 49, 0, + 0, 5207, 5209, 5, 876, 0, 0, 5208, 5164, 1, 0, 0, 0, 5208, 5206, 1, 0, + 0, 0, 5208, 5207, 1, 0, 0, 0, 5209, 5211, 1, 0, 0, 0, 5210, 5163, 1, 0, + 0, 0, 5210, 5211, 1, 0, 0, 0, 5211, 5238, 1, 0, 0, 0, 5212, 5213, 5, 1077, + 0, 0, 5213, 5234, 5, 1206, 0, 0, 5214, 5216, 5, 1208, 0, 0, 5215, 5214, + 1, 0, 0, 0, 5215, 5216, 1, 0, 0, 0, 5216, 5217, 1, 0, 0, 0, 5217, 5218, + 5, 755, 0, 0, 5218, 5219, 5, 1188, 0, 0, 5219, 5233, 5, 1182, 0, 0, 5220, + 5222, 5, 1208, 0, 0, 5221, 5220, 1, 0, 0, 0, 5221, 5222, 1, 0, 0, 0, 5222, + 5223, 1, 0, 0, 0, 5223, 5224, 5, 665, 0, 0, 5224, 5225, 5, 1188, 0, 0, + 5225, 5233, 7, 53, 0, 0, 5226, 5228, 5, 1208, 0, 0, 5227, 5226, 1, 0, 0, + 0, 5227, 5228, 1, 0, 0, 0, 5228, 5229, 1, 0, 0, 0, 5229, 5230, 5, 943, + 0, 0, 5230, 5231, 5, 1188, 0, 0, 5231, 5233, 7, 17, 0, 0, 5232, 5215, 1, + 0, 0, 0, 5232, 5221, 1, 0, 0, 0, 5232, 5227, 1, 0, 0, 0, 5233, 5236, 1, + 0, 0, 0, 5234, 5232, 1, 0, 0, 0, 5234, 5235, 1, 0, 0, 0, 5235, 5237, 1, + 0, 0, 0, 5236, 5234, 1, 0, 0, 0, 5237, 5239, 5, 1207, 0, 0, 5238, 5212, + 1, 0, 0, 0, 5238, 5239, 1, 0, 0, 0, 5239, 5286, 1, 0, 0, 0, 5240, 5284, + 5, 1074, 0, 0, 5241, 5243, 5, 1208, 0, 0, 5242, 5241, 1, 0, 0, 0, 5242, + 5243, 1, 0, 0, 0, 5243, 5245, 1, 0, 0, 0, 5244, 5246, 5, 627, 0, 0, 5245, + 5244, 1, 0, 0, 0, 5245, 5246, 1, 0, 0, 0, 5246, 5247, 1, 0, 0, 0, 5247, + 5259, 3, 1230, 615, 0, 5248, 5260, 5, 1188, 0, 0, 5249, 5250, 5, 1190, + 0, 0, 5250, 5260, 5, 1189, 0, 0, 5251, 5252, 5, 1191, 0, 0, 5252, 5260, + 5, 1188, 0, 0, 5253, 5260, 5, 1189, 0, 0, 5254, 5255, 5, 1189, 0, 0, 5255, + 5260, 5, 1188, 0, 0, 5256, 5260, 5, 1190, 0, 0, 5257, 5258, 5, 1190, 0, + 0, 5258, 5260, 5, 1188, 0, 0, 5259, 5248, 1, 0, 0, 0, 5259, 5249, 1, 0, + 0, 0, 5259, 5251, 1, 0, 0, 0, 5259, 5253, 1, 0, 0, 0, 5259, 5254, 1, 0, + 0, 0, 5259, 5256, 1, 0, 0, 0, 5259, 5257, 1, 0, 0, 0, 5260, 5261, 1, 0, + 0, 0, 5261, 5262, 7, 31, 0, 0, 5262, 5285, 1, 0, 0, 0, 5263, 5265, 5, 1208, + 0, 0, 5264, 5263, 1, 0, 0, 0, 5264, 5265, 1, 0, 0, 0, 5265, 5266, 1, 0, + 0, 0, 5266, 5268, 7, 36, 0, 0, 5267, 5269, 5, 627, 0, 0, 5268, 5267, 1, + 0, 0, 0, 5268, 5269, 1, 0, 0, 0, 5269, 5281, 1, 0, 0, 0, 5270, 5282, 5, + 1188, 0, 0, 5271, 5272, 5, 1190, 0, 0, 5272, 5282, 5, 1189, 0, 0, 5273, + 5274, 5, 1191, 0, 0, 5274, 5282, 5, 1188, 0, 0, 5275, 5282, 5, 1189, 0, + 0, 5276, 5277, 5, 1189, 0, 0, 5277, 5282, 5, 1188, 0, 0, 5278, 5282, 5, + 1190, 0, 0, 5279, 5280, 5, 1190, 0, 0, 5280, 5282, 5, 1188, 0, 0, 5281, + 5270, 1, 0, 0, 0, 5281, 5271, 1, 0, 0, 0, 5281, 5273, 1, 0, 0, 0, 5281, + 5275, 1, 0, 0, 0, 5281, 5276, 1, 0, 0, 0, 5281, 5278, 1, 0, 0, 0, 5281, + 5279, 1, 0, 0, 0, 5282, 5283, 1, 0, 0, 0, 5283, 5285, 7, 31, 0, 0, 5284, + 5242, 1, 0, 0, 0, 5284, 5264, 1, 0, 0, 0, 5285, 5287, 1, 0, 0, 0, 5286, + 5240, 1, 0, 0, 0, 5286, 5287, 1, 0, 0, 0, 5287, 5295, 1, 0, 0, 0, 5288, + 5289, 5, 794, 0, 0, 5289, 5295, 5, 1074, 0, 0, 5290, 5291, 5, 592, 0, 0, + 5291, 5292, 5, 597, 0, 0, 5292, 5293, 5, 1188, 0, 0, 5293, 5295, 3, 1230, + 615, 0, 5294, 5210, 1, 0, 0, 0, 5294, 5288, 1, 0, 0, 0, 5294, 5290, 1, + 0, 0, 0, 5295, 403, 1, 0, 0, 0, 5296, 5297, 5, 199, 0, 0, 5297, 5298, 5, + 889, 0, 0, 5298, 5299, 5, 64, 0, 0, 5299, 5437, 3, 1230, 615, 0, 5300, + 5345, 5, 1000, 0, 0, 5301, 5302, 5, 343, 0, 0, 5302, 5339, 5, 1206, 0, + 0, 5303, 5305, 5, 1208, 0, 0, 5304, 5303, 1, 0, 0, 0, 5304, 5305, 1, 0, + 0, 0, 5305, 5306, 1, 0, 0, 0, 5306, 5307, 5, 350, 0, 0, 5307, 5308, 5, + 1188, 0, 0, 5308, 5338, 5, 1184, 0, 0, 5309, 5311, 5, 1208, 0, 0, 5310, + 5309, 1, 0, 0, 0, 5310, 5311, 1, 0, 0, 0, 5311, 5312, 1, 0, 0, 0, 5312, + 5313, 5, 553, 0, 0, 5313, 5317, 5, 1188, 0, 0, 5314, 5315, 5, 1182, 0, + 0, 5315, 5318, 7, 51, 0, 0, 5316, 5318, 5, 1036, 0, 0, 5317, 5314, 1, 0, + 0, 0, 5317, 5316, 1, 0, 0, 0, 5318, 5338, 1, 0, 0, 0, 5319, 5321, 5, 1208, + 0, 0, 5320, 5319, 1, 0, 0, 0, 5320, 5321, 1, 0, 0, 0, 5321, 5322, 1, 0, + 0, 0, 5322, 5323, 5, 568, 0, 0, 5323, 5324, 5, 1188, 0, 0, 5324, 5338, + 7, 52, 0, 0, 5325, 5327, 5, 1208, 0, 0, 5326, 5325, 1, 0, 0, 0, 5326, 5327, + 1, 0, 0, 0, 5327, 5328, 1, 0, 0, 0, 5328, 5329, 5, 561, 0, 0, 5329, 5330, + 5, 1188, 0, 0, 5330, 5338, 5, 1182, 0, 0, 5331, 5333, 5, 1208, 0, 0, 5332, + 5331, 1, 0, 0, 0, 5332, 5333, 1, 0, 0, 0, 5333, 5334, 1, 0, 0, 0, 5334, + 5335, 5, 811, 0, 0, 5335, 5336, 5, 1188, 0, 0, 5336, 5338, 7, 17, 0, 0, + 5337, 5304, 1, 0, 0, 0, 5337, 5310, 1, 0, 0, 0, 5337, 5320, 1, 0, 0, 0, + 5337, 5326, 1, 0, 0, 0, 5337, 5332, 1, 0, 0, 0, 5338, 5341, 1, 0, 0, 0, + 5339, 5337, 1, 0, 0, 0, 5339, 5340, 1, 0, 0, 0, 5340, 5342, 1, 0, 0, 0, + 5341, 5339, 1, 0, 0, 0, 5342, 5346, 5, 1207, 0, 0, 5343, 5346, 5, 49, 0, + 0, 5344, 5346, 5, 876, 0, 0, 5345, 5301, 1, 0, 0, 0, 5345, 5343, 1, 0, + 0, 0, 5345, 5344, 1, 0, 0, 0, 5346, 5348, 1, 0, 0, 0, 5347, 5300, 1, 0, + 0, 0, 5347, 5348, 1, 0, 0, 0, 5348, 5381, 1, 0, 0, 0, 5349, 5350, 5, 1077, + 0, 0, 5350, 5377, 5, 1206, 0, 0, 5351, 5353, 5, 1208, 0, 0, 5352, 5351, + 1, 0, 0, 0, 5352, 5353, 1, 0, 0, 0, 5353, 5354, 1, 0, 0, 0, 5354, 5355, + 5, 755, 0, 0, 5355, 5356, 5, 1188, 0, 0, 5356, 5376, 5, 1182, 0, 0, 5357, + 5359, 5, 1208, 0, 0, 5358, 5357, 1, 0, 0, 0, 5358, 5359, 1, 0, 0, 0, 5359, + 5360, 1, 0, 0, 0, 5360, 5361, 5, 665, 0, 0, 5361, 5362, 5, 1188, 0, 0, + 5362, 5376, 7, 53, 0, 0, 5363, 5365, 5, 1208, 0, 0, 5364, 5363, 1, 0, 0, + 0, 5364, 5365, 1, 0, 0, 0, 5365, 5366, 1, 0, 0, 0, 5366, 5367, 5, 943, + 0, 0, 5367, 5368, 5, 1188, 0, 0, 5368, 5376, 7, 17, 0, 0, 5369, 5371, 5, + 1208, 0, 0, 5370, 5369, 1, 0, 0, 0, 5370, 5371, 1, 0, 0, 0, 5371, 5372, + 1, 0, 0, 0, 5372, 5373, 5, 65, 0, 0, 5373, 5374, 5, 1188, 0, 0, 5374, 5376, + 3, 1230, 615, 0, 5375, 5352, 1, 0, 0, 0, 5375, 5358, 1, 0, 0, 0, 5375, + 5364, 1, 0, 0, 0, 5375, 5370, 1, 0, 0, 0, 5376, 5379, 1, 0, 0, 0, 5377, + 5375, 1, 0, 0, 0, 5377, 5378, 1, 0, 0, 0, 5378, 5380, 1, 0, 0, 0, 5379, + 5377, 1, 0, 0, 0, 5380, 5382, 5, 1207, 0, 0, 5381, 5349, 1, 0, 0, 0, 5381, + 5382, 1, 0, 0, 0, 5382, 5429, 1, 0, 0, 0, 5383, 5427, 5, 1074, 0, 0, 5384, + 5386, 5, 1208, 0, 0, 5385, 5384, 1, 0, 0, 0, 5385, 5386, 1, 0, 0, 0, 5386, + 5388, 1, 0, 0, 0, 5387, 5389, 5, 627, 0, 0, 5388, 5387, 1, 0, 0, 0, 5388, + 5389, 1, 0, 0, 0, 5389, 5390, 1, 0, 0, 0, 5390, 5402, 3, 1230, 615, 0, + 5391, 5403, 5, 1188, 0, 0, 5392, 5393, 5, 1190, 0, 0, 5393, 5403, 5, 1189, + 0, 0, 5394, 5395, 5, 1191, 0, 0, 5395, 5403, 5, 1188, 0, 0, 5396, 5403, + 5, 1189, 0, 0, 5397, 5398, 5, 1189, 0, 0, 5398, 5403, 5, 1188, 0, 0, 5399, + 5403, 5, 1190, 0, 0, 5400, 5401, 5, 1190, 0, 0, 5401, 5403, 5, 1188, 0, + 0, 5402, 5391, 1, 0, 0, 0, 5402, 5392, 1, 0, 0, 0, 5402, 5394, 1, 0, 0, + 0, 5402, 5396, 1, 0, 0, 0, 5402, 5397, 1, 0, 0, 0, 5402, 5399, 1, 0, 0, + 0, 5402, 5400, 1, 0, 0, 0, 5403, 5404, 1, 0, 0, 0, 5404, 5405, 7, 31, 0, + 0, 5405, 5428, 1, 0, 0, 0, 5406, 5408, 5, 1208, 0, 0, 5407, 5406, 1, 0, + 0, 0, 5407, 5408, 1, 0, 0, 0, 5408, 5409, 1, 0, 0, 0, 5409, 5411, 7, 36, + 0, 0, 5410, 5412, 5, 627, 0, 0, 5411, 5410, 1, 0, 0, 0, 5411, 5412, 1, + 0, 0, 0, 5412, 5424, 1, 0, 0, 0, 5413, 5425, 5, 1188, 0, 0, 5414, 5415, + 5, 1190, 0, 0, 5415, 5425, 5, 1189, 0, 0, 5416, 5417, 5, 1191, 0, 0, 5417, + 5425, 5, 1188, 0, 0, 5418, 5425, 5, 1189, 0, 0, 5419, 5420, 5, 1189, 0, + 0, 5420, 5425, 5, 1188, 0, 0, 5421, 5425, 5, 1190, 0, 0, 5422, 5423, 5, + 1190, 0, 0, 5423, 5425, 5, 1188, 0, 0, 5424, 5413, 1, 0, 0, 0, 5424, 5414, + 1, 0, 0, 0, 5424, 5416, 1, 0, 0, 0, 5424, 5418, 1, 0, 0, 0, 5424, 5419, + 1, 0, 0, 0, 5424, 5421, 1, 0, 0, 0, 5424, 5422, 1, 0, 0, 0, 5425, 5426, + 1, 0, 0, 0, 5426, 5428, 7, 31, 0, 0, 5427, 5385, 1, 0, 0, 0, 5427, 5407, + 1, 0, 0, 0, 5428, 5430, 1, 0, 0, 0, 5429, 5383, 1, 0, 0, 0, 5429, 5430, + 1, 0, 0, 0, 5430, 5438, 1, 0, 0, 0, 5431, 5432, 5, 794, 0, 0, 5432, 5438, + 5, 1074, 0, 0, 5433, 5434, 5, 592, 0, 0, 5434, 5435, 5, 597, 0, 0, 5435, + 5436, 5, 1188, 0, 0, 5436, 5438, 3, 1230, 615, 0, 5437, 5347, 1, 0, 0, + 0, 5437, 5431, 1, 0, 0, 0, 5437, 5433, 1, 0, 0, 0, 5438, 405, 1, 0, 0, + 0, 5439, 5440, 5, 35, 0, 0, 5440, 5441, 5, 889, 0, 0, 5441, 5442, 5, 64, + 0, 0, 5442, 5443, 5, 931, 0, 0, 5443, 5448, 3, 1230, 615, 0, 5444, 5445, + 5, 365, 0, 0, 5445, 5446, 5, 889, 0, 0, 5446, 5447, 5, 64, 0, 0, 5447, + 5449, 3, 1230, 615, 0, 5448, 5444, 1, 0, 0, 0, 5448, 5449, 1, 0, 0, 0, + 5449, 5457, 1, 0, 0, 0, 5450, 5451, 7, 23, 0, 0, 5451, 5452, 5, 1206, 0, + 0, 5452, 5453, 3, 1230, 615, 0, 5453, 5454, 5, 1207, 0, 0, 5454, 5456, + 1, 0, 0, 0, 5455, 5450, 1, 0, 0, 0, 5456, 5459, 1, 0, 0, 0, 5457, 5455, + 1, 0, 0, 0, 5457, 5458, 1, 0, 0, 0, 5458, 5466, 1, 0, 0, 0, 5459, 5457, + 1, 0, 0, 0, 5460, 5461, 5, 1077, 0, 0, 5461, 5462, 5, 1206, 0, 0, 5462, + 5463, 5, 943, 0, 0, 5463, 5464, 5, 1188, 0, 0, 5464, 5465, 7, 17, 0, 0, + 5465, 5467, 5, 1207, 0, 0, 5466, 5460, 1, 0, 0, 0, 5466, 5467, 1, 0, 0, + 0, 5467, 407, 1, 0, 0, 0, 5468, 5469, 5, 199, 0, 0, 5469, 5470, 5, 889, + 0, 0, 5470, 5471, 5, 64, 0, 0, 5471, 5472, 5, 931, 0, 0, 5472, 5477, 3, + 1230, 615, 0, 5473, 5474, 5, 365, 0, 0, 5474, 5475, 5, 889, 0, 0, 5475, + 5476, 5, 64, 0, 0, 5476, 5478, 3, 1230, 615, 0, 5477, 5473, 1, 0, 0, 0, + 5477, 5478, 1, 0, 0, 0, 5478, 5486, 1, 0, 0, 0, 5479, 5480, 5, 11, 0, 0, + 5480, 5481, 5, 1206, 0, 0, 5481, 5482, 3, 1230, 615, 0, 5482, 5483, 5, + 1207, 0, 0, 5483, 5485, 1, 0, 0, 0, 5484, 5479, 1, 0, 0, 0, 5485, 5488, + 1, 0, 0, 0, 5486, 5484, 1, 0, 0, 0, 5486, 5487, 1, 0, 0, 0, 5487, 5495, + 1, 0, 0, 0, 5488, 5486, 1, 0, 0, 0, 5489, 5490, 5, 1077, 0, 0, 5490, 5491, + 5, 1206, 0, 0, 5491, 5492, 5, 943, 0, 0, 5492, 5493, 5, 1188, 0, 0, 5493, + 5494, 7, 17, 0, 0, 5494, 5496, 5, 1207, 0, 0, 5495, 5489, 1, 0, 0, 0, 5495, + 5496, 1, 0, 0, 0, 5496, 409, 1, 0, 0, 0, 5497, 5498, 5, 35, 0, 0, 5498, + 5499, 5, 889, 0, 0, 5499, 5500, 5, 175, 0, 0, 5500, 5606, 5, 900, 0, 0, + 5501, 5502, 5, 743, 0, 0, 5502, 5538, 5, 18, 0, 0, 5503, 5504, 5, 198, + 0, 0, 5504, 5520, 5, 1188, 0, 0, 5505, 5521, 5, 69, 0, 0, 5506, 5508, 5, + 1208, 0, 0, 5507, 5506, 1, 0, 0, 0, 5507, 5508, 1, 0, 0, 0, 5508, 5509, + 1, 0, 0, 0, 5509, 5517, 5, 1182, 0, 0, 5510, 5512, 5, 1208, 0, 0, 5511, + 5510, 1, 0, 0, 0, 5511, 5512, 1, 0, 0, 0, 5512, 5513, 1, 0, 0, 0, 5513, + 5514, 5, 1182, 0, 0, 5514, 5515, 5, 1000, 0, 0, 5515, 5517, 5, 1182, 0, + 0, 5516, 5507, 1, 0, 0, 0, 5516, 5511, 1, 0, 0, 0, 5517, 5518, 1, 0, 0, + 0, 5518, 5516, 1, 0, 0, 0, 5518, 5519, 1, 0, 0, 0, 5519, 5521, 1, 0, 0, + 0, 5520, 5505, 1, 0, 0, 0, 5520, 5516, 1, 0, 0, 0, 5521, 5539, 1, 0, 0, + 0, 5522, 5523, 5, 645, 0, 0, 5523, 5534, 5, 1188, 0, 0, 5524, 5526, 5, + 1208, 0, 0, 5525, 5524, 1, 0, 0, 0, 5525, 5526, 1, 0, 0, 0, 5526, 5527, + 1, 0, 0, 0, 5527, 5535, 5, 1182, 0, 0, 5528, 5530, 5, 1208, 0, 0, 5529, + 5528, 1, 0, 0, 0, 5529, 5530, 1, 0, 0, 0, 5530, 5531, 1, 0, 0, 0, 5531, + 5532, 5, 1182, 0, 0, 5532, 5533, 5, 1000, 0, 0, 5533, 5535, 5, 1182, 0, + 0, 5534, 5525, 1, 0, 0, 0, 5534, 5529, 1, 0, 0, 0, 5535, 5536, 1, 0, 0, + 0, 5536, 5534, 1, 0, 0, 0, 5536, 5537, 1, 0, 0, 0, 5537, 5539, 1, 0, 0, + 0, 5538, 5503, 1, 0, 0, 0, 5538, 5522, 1, 0, 0, 0, 5539, 5607, 1, 0, 0, + 0, 5540, 5541, 5, 265, 0, 0, 5541, 5557, 5, 536, 0, 0, 5542, 5558, 5, 662, + 0, 0, 5543, 5558, 5, 656, 0, 0, 5544, 5545, 5, 704, 0, 0, 5545, 5546, 5, + 1188, 0, 0, 5546, 5558, 7, 54, 0, 0, 5547, 5548, 5, 569, 0, 0, 5548, 5552, + 5, 1188, 0, 0, 5549, 5550, 5, 1182, 0, 0, 5550, 5553, 5, 570, 0, 0, 5551, + 5553, 5, 245, 0, 0, 5552, 5549, 1, 0, 0, 0, 5552, 5551, 1, 0, 0, 0, 5553, + 5558, 1, 0, 0, 0, 5554, 5555, 5, 561, 0, 0, 5555, 5556, 5, 1188, 0, 0, + 5556, 5558, 7, 55, 0, 0, 5557, 5542, 1, 0, 0, 0, 5557, 5543, 1, 0, 0, 0, + 5557, 5544, 1, 0, 0, 0, 5557, 5547, 1, 0, 0, 0, 5557, 5554, 1, 0, 0, 0, + 5558, 5607, 1, 0, 0, 0, 5559, 5560, 5, 333, 0, 0, 5560, 5561, 5, 150, 0, + 0, 5561, 5579, 5, 745, 0, 0, 5562, 5563, 5, 1062, 0, 0, 5563, 5564, 5, + 1188, 0, 0, 5564, 5580, 7, 54, 0, 0, 5565, 5566, 5, 934, 0, 0, 5566, 5567, + 5, 1188, 0, 0, 5567, 5580, 7, 54, 0, 0, 5568, 5569, 5, 935, 0, 0, 5569, + 5570, 5, 1188, 0, 0, 5570, 5580, 7, 54, 0, 0, 5571, 5572, 5, 936, 0, 0, + 5572, 5580, 7, 54, 0, 0, 5573, 5574, 5, 336, 0, 0, 5574, 5575, 5, 1188, + 0, 0, 5575, 5580, 7, 54, 0, 0, 5576, 5577, 5, 422, 0, 0, 5577, 5578, 5, + 1188, 0, 0, 5578, 5580, 7, 55, 0, 0, 5579, 5562, 1, 0, 0, 0, 5579, 5565, + 1, 0, 0, 0, 5579, 5568, 1, 0, 0, 0, 5579, 5571, 1, 0, 0, 0, 5579, 5573, + 1, 0, 0, 0, 5579, 5576, 1, 0, 0, 0, 5580, 5607, 1, 0, 0, 0, 5581, 5582, + 5, 416, 0, 0, 5582, 5583, 5, 150, 0, 0, 5583, 5584, 5, 184, 0, 0, 5584, + 5585, 5, 1188, 0, 0, 5585, 5607, 7, 56, 0, 0, 5586, 5587, 5, 107, 0, 0, + 5587, 5588, 5, 725, 0, 0, 5588, 5601, 5, 330, 0, 0, 5589, 5590, 5, 662, + 0, 0, 5590, 5591, 5, 1206, 0, 0, 5591, 5592, 5, 349, 0, 0, 5592, 5593, + 5, 1188, 0, 0, 5593, 5594, 5, 1184, 0, 0, 5594, 5595, 5, 1208, 0, 0, 5595, + 5596, 5, 918, 0, 0, 5596, 5597, 5, 1188, 0, 0, 5597, 5598, 5, 1182, 0, + 0, 5598, 5599, 7, 57, 0, 0, 5599, 5602, 5, 1207, 0, 0, 5600, 5602, 5, 656, + 0, 0, 5601, 5589, 1, 0, 0, 0, 5601, 5600, 1, 0, 0, 0, 5602, 5607, 1, 0, + 0, 0, 5603, 5604, 5, 900, 0, 0, 5604, 5605, 5, 922, 0, 0, 5605, 5607, 7, + 17, 0, 0, 5606, 5501, 1, 0, 0, 0, 5606, 5540, 1, 0, 0, 0, 5606, 5559, 1, + 0, 0, 0, 5606, 5581, 1, 0, 0, 0, 5606, 5586, 1, 0, 0, 0, 5606, 5603, 1, + 0, 0, 0, 5607, 411, 1, 0, 0, 0, 5608, 5609, 5, 35, 0, 0, 5609, 5610, 5, + 889, 0, 0, 5610, 5611, 5, 832, 0, 0, 5611, 5619, 3, 1230, 615, 0, 5612, + 5613, 7, 23, 0, 0, 5613, 5614, 5, 574, 0, 0, 5614, 5620, 3, 1230, 615, + 0, 5615, 5616, 5, 1077, 0, 0, 5616, 5617, 5, 597, 0, 0, 5617, 5618, 5, + 1188, 0, 0, 5618, 5620, 3, 1230, 615, 0, 5619, 5612, 1, 0, 0, 0, 5619, + 5615, 1, 0, 0, 0, 5620, 413, 1, 0, 0, 0, 5621, 5622, 5, 199, 0, 0, 5622, + 5623, 5, 889, 0, 0, 5623, 5624, 5, 832, 0, 0, 5624, 5627, 3, 1230, 615, + 0, 5625, 5626, 5, 68, 0, 0, 5626, 5628, 3, 1230, 615, 0, 5627, 5625, 1, + 0, 0, 0, 5627, 5628, 1, 0, 0, 0, 5628, 415, 1, 0, 0, 0, 5629, 5630, 5, + 35, 0, 0, 5630, 5631, 5, 889, 0, 0, 5631, 5632, 5, 832, 0, 0, 5632, 5633, + 3, 1230, 615, 0, 5633, 5634, 7, 23, 0, 0, 5634, 5635, 5, 574, 0, 0, 5635, + 5636, 3, 1230, 615, 0, 5636, 417, 1, 0, 0, 0, 5637, 5638, 5, 35, 0, 0, + 5638, 5639, 5, 891, 0, 0, 5639, 5648, 3, 1230, 615, 0, 5640, 5641, 5, 662, + 0, 0, 5641, 5645, 5, 754, 0, 0, 5642, 5643, 3, 1230, 615, 0, 5643, 5644, + 5, 1201, 0, 0, 5644, 5646, 1, 0, 0, 0, 5645, 5642, 1, 0, 0, 0, 5645, 5646, + 1, 0, 0, 0, 5646, 5647, 1, 0, 0, 0, 5647, 5649, 3, 1230, 615, 0, 5648, + 5640, 1, 0, 0, 0, 5648, 5649, 1, 0, 0, 0, 5649, 5661, 1, 0, 0, 0, 5650, + 5651, 5, 1206, 0, 0, 5651, 5656, 3, 420, 210, 0, 5652, 5653, 5, 1208, 0, + 0, 5653, 5655, 3, 420, 210, 0, 5654, 5652, 1, 0, 0, 0, 5655, 5658, 1, 0, + 0, 0, 5656, 5654, 1, 0, 0, 0, 5656, 5657, 1, 0, 0, 0, 5657, 5659, 1, 0, + 0, 0, 5658, 5656, 1, 0, 0, 0, 5659, 5660, 5, 1207, 0, 0, 5660, 5662, 1, + 0, 0, 0, 5661, 5650, 1, 0, 0, 0, 5661, 5662, 1, 0, 0, 0, 5662, 419, 1, + 0, 0, 0, 5663, 5664, 7, 23, 0, 0, 5664, 5665, 5, 188, 0, 0, 5665, 5666, + 3, 1230, 615, 0, 5666, 421, 1, 0, 0, 0, 5667, 5668, 5, 199, 0, 0, 5668, + 5669, 5, 891, 0, 0, 5669, 5672, 3, 1230, 615, 0, 5670, 5671, 5, 68, 0, + 0, 5671, 5673, 3, 1230, 615, 0, 5672, 5670, 1, 0, 0, 0, 5672, 5673, 1, + 0, 0, 0, 5673, 5674, 1, 0, 0, 0, 5674, 5675, 5, 662, 0, 0, 5675, 5679, + 5, 754, 0, 0, 5676, 5677, 3, 1230, 615, 0, 5677, 5678, 5, 1201, 0, 0, 5678, + 5680, 1, 0, 0, 0, 5679, 5676, 1, 0, 0, 0, 5679, 5680, 1, 0, 0, 0, 5680, + 5681, 1, 0, 0, 0, 5681, 5695, 3, 1230, 615, 0, 5682, 5690, 5, 1206, 0, + 0, 5683, 5685, 5, 1208, 0, 0, 5684, 5683, 1, 0, 0, 0, 5684, 5685, 1, 0, + 0, 0, 5685, 5688, 1, 0, 0, 0, 5686, 5689, 3, 1230, 615, 0, 5687, 5689, + 5, 245, 0, 0, 5688, 5686, 1, 0, 0, 0, 5688, 5687, 1, 0, 0, 0, 5689, 5691, + 1, 0, 0, 0, 5690, 5684, 1, 0, 0, 0, 5691, 5692, 1, 0, 0, 0, 5692, 5690, + 1, 0, 0, 0, 5692, 5693, 1, 0, 0, 0, 5693, 5694, 1, 0, 0, 0, 5694, 5696, + 5, 1207, 0, 0, 5695, 5682, 1, 0, 0, 0, 5695, 5696, 1, 0, 0, 0, 5696, 423, + 1, 0, 0, 0, 5697, 5698, 5, 35, 0, 0, 5698, 5699, 5, 891, 0, 0, 5699, 5700, + 5, 547, 0, 0, 5700, 5722, 5, 498, 0, 0, 5701, 5703, 5, 366, 0, 0, 5702, + 5701, 1, 0, 0, 0, 5702, 5703, 1, 0, 0, 0, 5703, 5704, 1, 0, 0, 0, 5704, + 5723, 5, 787, 0, 0, 5705, 5720, 5, 1077, 0, 0, 5706, 5707, 5, 660, 0, 0, + 5707, 5708, 5, 1188, 0, 0, 5708, 5709, 5, 1184, 0, 0, 5709, 5710, 5, 1208, + 0, 0, 5710, 5711, 5, 661, 0, 0, 5711, 5712, 5, 1188, 0, 0, 5712, 5721, + 5, 1184, 0, 0, 5713, 5714, 5, 605, 0, 0, 5714, 5715, 5, 1188, 0, 0, 5715, + 5716, 5, 1184, 0, 0, 5716, 5717, 5, 1208, 0, 0, 5717, 5718, 5, 607, 0, + 0, 5718, 5719, 5, 1188, 0, 0, 5719, 5721, 5, 1184, 0, 0, 5720, 5706, 1, + 0, 0, 0, 5720, 5713, 1, 0, 0, 0, 5720, 5721, 1, 0, 0, 0, 5721, 5723, 1, + 0, 0, 0, 5722, 5702, 1, 0, 0, 0, 5722, 5705, 1, 0, 0, 0, 5723, 425, 1, + 0, 0, 0, 5724, 5725, 5, 35, 0, 0, 5725, 5726, 5, 975, 0, 0, 5726, 5727, + 5, 498, 0, 0, 5727, 5728, 3, 1230, 615, 0, 5728, 5729, 7, 23, 0, 0, 5729, + 5730, 5, 297, 0, 0, 5730, 5742, 5, 111, 0, 0, 5731, 5732, 5, 123, 0, 0, + 5732, 5743, 3, 1230, 615, 0, 5733, 5734, 5, 703, 0, 0, 5734, 5735, 5, 1188, + 0, 0, 5735, 5743, 5, 1184, 0, 0, 5736, 5737, 5, 975, 0, 0, 5737, 5738, + 5, 498, 0, 0, 5738, 5743, 3, 1230, 615, 0, 5739, 5740, 5, 61, 0, 0, 5740, + 5741, 5, 498, 0, 0, 5741, 5743, 3, 1230, 615, 0, 5742, 5731, 1, 0, 0, 0, + 5742, 5733, 1, 0, 0, 0, 5742, 5736, 1, 0, 0, 0, 5742, 5739, 1, 0, 0, 0, + 5743, 427, 1, 0, 0, 0, 5744, 5745, 5, 199, 0, 0, 5745, 5749, 5, 977, 0, + 0, 5746, 5747, 3, 1230, 615, 0, 5747, 5748, 5, 1201, 0, 0, 5748, 5750, + 1, 0, 0, 0, 5749, 5746, 1, 0, 0, 0, 5749, 5750, 1, 0, 0, 0, 5750, 5751, + 1, 0, 0, 0, 5751, 5752, 3, 1230, 615, 0, 5752, 5779, 5, 365, 0, 0, 5753, + 5754, 3, 1230, 615, 0, 5754, 5755, 5, 1201, 0, 0, 5755, 5757, 1, 0, 0, + 0, 5756, 5753, 1, 0, 0, 0, 5756, 5757, 1, 0, 0, 0, 5757, 5761, 1, 0, 0, + 0, 5758, 5759, 3, 1230, 615, 0, 5759, 5760, 5, 1201, 0, 0, 5760, 5762, + 1, 0, 0, 0, 5761, 5758, 1, 0, 0, 0, 5761, 5762, 1, 0, 0, 0, 5762, 5766, + 1, 0, 0, 0, 5763, 5764, 3, 1230, 615, 0, 5764, 5765, 5, 1201, 0, 0, 5765, + 5767, 1, 0, 0, 0, 5766, 5763, 1, 0, 0, 0, 5766, 5767, 1, 0, 0, 0, 5767, + 5768, 1, 0, 0, 0, 5768, 5780, 3, 1230, 615, 0, 5769, 5770, 3, 1230, 615, + 0, 5770, 5771, 5, 1201, 0, 0, 5771, 5773, 1, 0, 0, 0, 5772, 5769, 1, 0, + 0, 0, 5772, 5773, 1, 0, 0, 0, 5773, 5777, 1, 0, 0, 0, 5774, 5775, 3, 1230, + 615, 0, 5775, 5776, 5, 1201, 0, 0, 5776, 5778, 1, 0, 0, 0, 5777, 5774, + 1, 0, 0, 0, 5777, 5778, 1, 0, 0, 0, 5778, 5780, 1, 0, 0, 0, 5779, 5756, + 1, 0, 0, 0, 5779, 5772, 1, 0, 0, 0, 5780, 429, 1, 0, 0, 0, 5781, 5782, + 5, 35, 0, 0, 5782, 5783, 5, 1049, 0, 0, 5783, 5784, 3, 1230, 615, 0, 5784, + 5835, 5, 1077, 0, 0, 5785, 5787, 5, 1208, 0, 0, 5786, 5785, 1, 0, 0, 0, + 5786, 5787, 1, 0, 0, 0, 5787, 5788, 1, 0, 0, 0, 5788, 5789, 5, 597, 0, + 0, 5789, 5790, 5, 1188, 0, 0, 5790, 5836, 3, 1230, 615, 0, 5791, 5793, + 5, 1208, 0, 0, 5792, 5791, 1, 0, 0, 0, 5792, 5793, 1, 0, 0, 0, 5793, 5794, + 1, 0, 0, 0, 5794, 5795, 5, 250, 0, 0, 5795, 5798, 5, 1188, 0, 0, 5796, + 5799, 3, 1230, 615, 0, 5797, 5799, 5, 643, 0, 0, 5798, 5796, 1, 0, 0, 0, + 5798, 5797, 1, 0, 0, 0, 5799, 5836, 1, 0, 0, 0, 5800, 5802, 5, 1208, 0, + 0, 5801, 5800, 1, 0, 0, 0, 5801, 5802, 1, 0, 0, 0, 5802, 5803, 1, 0, 0, + 0, 5803, 5804, 5, 537, 0, 0, 5804, 5805, 5, 1188, 0, 0, 5805, 5836, 3, + 1230, 615, 0, 5806, 5808, 5, 1208, 0, 0, 5807, 5806, 1, 0, 0, 0, 5807, + 5808, 1, 0, 0, 0, 5808, 5809, 1, 0, 0, 0, 5809, 5810, 5, 703, 0, 0, 5810, + 5811, 5, 1188, 0, 0, 5811, 5815, 5, 1184, 0, 0, 5812, 5813, 5, 661, 0, + 0, 5813, 5814, 5, 1188, 0, 0, 5814, 5816, 5, 1184, 0, 0, 5815, 5812, 1, + 0, 0, 0, 5816, 5817, 1, 0, 0, 0, 5817, 5815, 1, 0, 0, 0, 5817, 5818, 1, + 0, 0, 0, 5818, 5836, 1, 0, 0, 0, 5819, 5821, 5, 1208, 0, 0, 5820, 5819, + 1, 0, 0, 0, 5820, 5821, 1, 0, 0, 0, 5821, 5822, 1, 0, 0, 0, 5822, 5823, + 5, 249, 0, 0, 5823, 5827, 5, 1188, 0, 0, 5824, 5828, 5, 621, 0, 0, 5825, + 5828, 5, 1182, 0, 0, 5826, 5828, 3, 1230, 615, 0, 5827, 5824, 1, 0, 0, + 0, 5827, 5825, 1, 0, 0, 0, 5827, 5826, 1, 0, 0, 0, 5828, 5836, 1, 0, 0, + 0, 5829, 5831, 5, 1208, 0, 0, 5830, 5829, 1, 0, 0, 0, 5830, 5831, 1, 0, + 0, 0, 5831, 5832, 1, 0, 0, 0, 5832, 5833, 5, 25, 0, 0, 5833, 5834, 5, 1188, + 0, 0, 5834, 5836, 7, 17, 0, 0, 5835, 5786, 1, 0, 0, 0, 5835, 5792, 1, 0, + 0, 0, 5835, 5801, 1, 0, 0, 0, 5835, 5807, 1, 0, 0, 0, 5835, 5820, 1, 0, + 0, 0, 5835, 5830, 1, 0, 0, 0, 5836, 5837, 1, 0, 0, 0, 5837, 5835, 1, 0, + 0, 0, 5837, 5838, 1, 0, 0, 0, 5838, 431, 1, 0, 0, 0, 5839, 5840, 5, 199, + 0, 0, 5840, 5841, 5, 1049, 0, 0, 5841, 5845, 3, 1230, 615, 0, 5842, 5843, + 7, 58, 0, 0, 5843, 5844, 5, 537, 0, 0, 5844, 5846, 3, 1230, 615, 0, 5845, + 5842, 1, 0, 0, 0, 5845, 5846, 1, 0, 0, 0, 5846, 5865, 1, 0, 0, 0, 5847, + 5862, 5, 1077, 0, 0, 5848, 5850, 5, 1208, 0, 0, 5849, 5848, 1, 0, 0, 0, + 5849, 5850, 1, 0, 0, 0, 5850, 5851, 1, 0, 0, 0, 5851, 5852, 5, 250, 0, + 0, 5852, 5853, 5, 1188, 0, 0, 5853, 5861, 3, 1230, 615, 0, 5854, 5856, + 5, 1208, 0, 0, 5855, 5854, 1, 0, 0, 0, 5855, 5856, 1, 0, 0, 0, 5856, 5857, + 1, 0, 0, 0, 5857, 5858, 5, 25, 0, 0, 5858, 5859, 5, 1188, 0, 0, 5859, 5861, + 7, 17, 0, 0, 5860, 5849, 1, 0, 0, 0, 5860, 5855, 1, 0, 0, 0, 5861, 5864, + 1, 0, 0, 0, 5862, 5860, 1, 0, 0, 0, 5862, 5863, 1, 0, 0, 0, 5863, 5866, + 1, 0, 0, 0, 5864, 5862, 1, 0, 0, 0, 5865, 5847, 1, 0, 0, 0, 5865, 5866, + 1, 0, 0, 0, 5866, 5986, 1, 0, 0, 0, 5867, 5868, 5, 199, 0, 0, 5868, 5949, + 5, 1049, 0, 0, 5869, 5904, 3, 1230, 615, 0, 5870, 5901, 5, 1077, 0, 0, + 5871, 5873, 5, 1208, 0, 0, 5872, 5871, 1, 0, 0, 0, 5872, 5873, 1, 0, 0, + 0, 5873, 5874, 1, 0, 0, 0, 5874, 5875, 5, 250, 0, 0, 5875, 5876, 5, 1188, + 0, 0, 5876, 5900, 3, 1230, 615, 0, 5877, 5879, 5, 1208, 0, 0, 5878, 5877, + 1, 0, 0, 0, 5878, 5879, 1, 0, 0, 0, 5879, 5880, 1, 0, 0, 0, 5880, 5881, + 5, 249, 0, 0, 5881, 5885, 5, 1188, 0, 0, 5882, 5886, 5, 621, 0, 0, 5883, + 5886, 5, 1182, 0, 0, 5884, 5886, 3, 1230, 615, 0, 5885, 5882, 1, 0, 0, + 0, 5885, 5883, 1, 0, 0, 0, 5885, 5884, 1, 0, 0, 0, 5886, 5900, 1, 0, 0, + 0, 5887, 5889, 5, 1208, 0, 0, 5888, 5887, 1, 0, 0, 0, 5888, 5889, 1, 0, + 0, 0, 5889, 5890, 1, 0, 0, 0, 5890, 5891, 5, 914, 0, 0, 5891, 5892, 5, + 1188, 0, 0, 5892, 5900, 5, 1185, 0, 0, 5893, 5895, 5, 1208, 0, 0, 5894, + 5893, 1, 0, 0, 0, 5894, 5895, 1, 0, 0, 0, 5895, 5896, 1, 0, 0, 0, 5896, + 5897, 5, 25, 0, 0, 5897, 5898, 5, 1188, 0, 0, 5898, 5900, 7, 17, 0, 0, + 5899, 5872, 1, 0, 0, 0, 5899, 5878, 1, 0, 0, 0, 5899, 5888, 1, 0, 0, 0, + 5899, 5894, 1, 0, 0, 0, 5900, 5903, 1, 0, 0, 0, 5901, 5899, 1, 0, 0, 0, + 5901, 5902, 1, 0, 0, 0, 5902, 5905, 1, 0, 0, 0, 5903, 5901, 1, 0, 0, 0, + 5904, 5870, 1, 0, 0, 0, 5904, 5905, 1, 0, 0, 0, 5905, 5950, 1, 0, 0, 0, + 5906, 5907, 3, 1230, 615, 0, 5907, 5908, 5, 1077, 0, 0, 5908, 5909, 5, + 703, 0, 0, 5909, 5910, 5, 1188, 0, 0, 5910, 5941, 5, 1184, 0, 0, 5911, + 5913, 5, 1208, 0, 0, 5912, 5911, 1, 0, 0, 0, 5912, 5913, 1, 0, 0, 0, 5913, + 5914, 1, 0, 0, 0, 5914, 5915, 5, 250, 0, 0, 5915, 5916, 5, 1188, 0, 0, + 5916, 5940, 3, 1230, 615, 0, 5917, 5919, 5, 1208, 0, 0, 5918, 5917, 1, + 0, 0, 0, 5918, 5919, 1, 0, 0, 0, 5919, 5920, 1, 0, 0, 0, 5920, 5921, 5, + 249, 0, 0, 5921, 5925, 5, 1188, 0, 0, 5922, 5926, 5, 621, 0, 0, 5923, 5926, + 5, 1182, 0, 0, 5924, 5926, 3, 1230, 615, 0, 5925, 5922, 1, 0, 0, 0, 5925, + 5923, 1, 0, 0, 0, 5925, 5924, 1, 0, 0, 0, 5926, 5940, 1, 0, 0, 0, 5927, + 5929, 5, 1208, 0, 0, 5928, 5927, 1, 0, 0, 0, 5928, 5929, 1, 0, 0, 0, 5929, + 5930, 1, 0, 0, 0, 5930, 5931, 5, 914, 0, 0, 5931, 5932, 5, 1188, 0, 0, + 5932, 5940, 5, 1185, 0, 0, 5933, 5935, 5, 1208, 0, 0, 5934, 5933, 1, 0, + 0, 0, 5934, 5935, 1, 0, 0, 0, 5935, 5936, 1, 0, 0, 0, 5936, 5937, 5, 25, + 0, 0, 5937, 5938, 5, 1188, 0, 0, 5938, 5940, 7, 17, 0, 0, 5939, 5912, 1, + 0, 0, 0, 5939, 5918, 1, 0, 0, 0, 5939, 5928, 1, 0, 0, 0, 5939, 5934, 1, + 0, 0, 0, 5940, 5943, 1, 0, 0, 0, 5941, 5939, 1, 0, 0, 0, 5941, 5942, 1, + 0, 0, 0, 5942, 5950, 1, 0, 0, 0, 5943, 5941, 1, 0, 0, 0, 5944, 5945, 3, + 1230, 615, 0, 5945, 5946, 5, 380, 0, 0, 5946, 5947, 5, 331, 0, 0, 5947, + 5948, 5, 746, 0, 0, 5948, 5950, 1, 0, 0, 0, 5949, 5869, 1, 0, 0, 0, 5949, + 5906, 1, 0, 0, 0, 5949, 5944, 1, 0, 0, 0, 5950, 5986, 1, 0, 0, 0, 5951, + 5952, 5, 199, 0, 0, 5952, 5953, 5, 1049, 0, 0, 5953, 5980, 3, 1230, 615, + 0, 5954, 5955, 5, 1079, 0, 0, 5955, 5970, 5, 537, 0, 0, 5956, 5958, 5, + 1208, 0, 0, 5957, 5956, 1, 0, 0, 0, 5957, 5958, 1, 0, 0, 0, 5958, 5959, + 1, 0, 0, 0, 5959, 5960, 5, 250, 0, 0, 5960, 5961, 5, 1188, 0, 0, 5961, + 5969, 3, 1230, 615, 0, 5962, 5964, 5, 1208, 0, 0, 5963, 5962, 1, 0, 0, + 0, 5963, 5964, 1, 0, 0, 0, 5964, 5965, 1, 0, 0, 0, 5965, 5966, 5, 25, 0, + 0, 5966, 5967, 5, 1188, 0, 0, 5967, 5969, 7, 17, 0, 0, 5968, 5957, 1, 0, + 0, 0, 5968, 5963, 1, 0, 0, 0, 5969, 5972, 1, 0, 0, 0, 5970, 5968, 1, 0, + 0, 0, 5970, 5971, 1, 0, 0, 0, 5971, 5981, 1, 0, 0, 0, 5972, 5970, 1, 0, + 0, 0, 5973, 5974, 7, 58, 0, 0, 5974, 5975, 5, 123, 0, 0, 5975, 5981, 3, + 1230, 615, 0, 5976, 5977, 7, 58, 0, 0, 5977, 5978, 5, 61, 0, 0, 5978, 5979, + 5, 498, 0, 0, 5979, 5981, 3, 1230, 615, 0, 5980, 5954, 1, 0, 0, 0, 5980, + 5973, 1, 0, 0, 0, 5980, 5976, 1, 0, 0, 0, 5981, 5986, 1, 0, 0, 0, 5982, + 5983, 5, 199, 0, 0, 5983, 5984, 5, 1049, 0, 0, 5984, 5986, 3, 1230, 615, + 0, 5985, 5839, 1, 0, 0, 0, 5985, 5867, 1, 0, 0, 0, 5985, 5951, 1, 0, 0, + 0, 5985, 5982, 1, 0, 0, 0, 5986, 433, 1, 0, 0, 0, 5987, 5988, 5, 199, 0, + 0, 5988, 5989, 5, 1049, 0, 0, 5989, 5995, 3, 1230, 615, 0, 5990, 5991, + 7, 58, 0, 0, 5991, 5992, 5, 537, 0, 0, 5992, 5996, 3, 1230, 615, 0, 5993, + 5994, 5, 1079, 0, 0, 5994, 5996, 5, 537, 0, 0, 5995, 5990, 1, 0, 0, 0, + 5995, 5993, 1, 0, 0, 0, 5995, 5996, 1, 0, 0, 0, 5996, 6001, 1, 0, 0, 0, + 5997, 5998, 5, 1077, 0, 0, 5998, 5999, 5, 250, 0, 0, 5999, 6000, 5, 1188, + 0, 0, 6000, 6002, 3, 1230, 615, 0, 6001, 5997, 1, 0, 0, 0, 6001, 6002, + 1, 0, 0, 0, 6002, 6016, 1, 0, 0, 0, 6003, 6004, 5, 199, 0, 0, 6004, 6005, + 5, 1049, 0, 0, 6005, 6006, 3, 1230, 615, 0, 6006, 6007, 5, 380, 0, 0, 6007, + 6008, 5, 331, 0, 0, 6008, 6013, 5, 746, 0, 0, 6009, 6010, 5, 1077, 0, 0, + 6010, 6011, 5, 250, 0, 0, 6011, 6012, 5, 1188, 0, 0, 6012, 6014, 3, 1230, + 615, 0, 6013, 6009, 1, 0, 0, 0, 6013, 6014, 1, 0, 0, 0, 6014, 6016, 1, + 0, 0, 0, 6015, 5987, 1, 0, 0, 0, 6015, 6003, 1, 0, 0, 0, 6016, 435, 1, + 0, 0, 0, 6017, 6018, 5, 35, 0, 0, 6018, 6019, 5, 1049, 0, 0, 6019, 6020, + 3, 1230, 615, 0, 6020, 6045, 5, 1077, 0, 0, 6021, 6023, 5, 1208, 0, 0, + 6022, 6021, 1, 0, 0, 0, 6022, 6023, 1, 0, 0, 0, 6023, 6024, 1, 0, 0, 0, + 6024, 6025, 5, 597, 0, 0, 6025, 6026, 5, 1188, 0, 0, 6026, 6046, 3, 1230, + 615, 0, 6027, 6029, 5, 1208, 0, 0, 6028, 6027, 1, 0, 0, 0, 6028, 6029, + 1, 0, 0, 0, 6029, 6030, 1, 0, 0, 0, 6030, 6031, 5, 250, 0, 0, 6031, 6032, + 5, 1188, 0, 0, 6032, 6046, 3, 1230, 615, 0, 6033, 6035, 5, 1208, 0, 0, + 6034, 6033, 1, 0, 0, 0, 6034, 6035, 1, 0, 0, 0, 6035, 6036, 1, 0, 0, 0, + 6036, 6037, 5, 537, 0, 0, 6037, 6038, 5, 1188, 0, 0, 6038, 6046, 3, 1230, + 615, 0, 6039, 6041, 5, 1208, 0, 0, 6040, 6039, 1, 0, 0, 0, 6040, 6041, + 1, 0, 0, 0, 6041, 6042, 1, 0, 0, 0, 6042, 6043, 5, 25, 0, 0, 6043, 6044, + 5, 1188, 0, 0, 6044, 6046, 7, 17, 0, 0, 6045, 6022, 1, 0, 0, 0, 6045, 6028, + 1, 0, 0, 0, 6045, 6034, 1, 0, 0, 0, 6045, 6040, 1, 0, 0, 0, 6046, 6047, + 1, 0, 0, 0, 6047, 6045, 1, 0, 0, 0, 6047, 6048, 1, 0, 0, 0, 6048, 437, + 1, 0, 0, 0, 6049, 6050, 5, 35, 0, 0, 6050, 6051, 5, 1083, 0, 0, 6051, 6054, + 5, 412, 0, 0, 6052, 6055, 3, 1230, 615, 0, 6053, 6055, 5, 247, 0, 0, 6054, + 6052, 1, 0, 0, 0, 6054, 6053, 1, 0, 0, 0, 6055, 6087, 1, 0, 0, 0, 6056, + 6057, 5, 1077, 0, 0, 6057, 6082, 5, 1206, 0, 0, 6058, 6059, 5, 450, 0, + 0, 6059, 6060, 5, 1188, 0, 0, 6060, 6083, 7, 59, 0, 0, 6061, 6063, 5, 1208, + 0, 0, 6062, 6061, 1, 0, 0, 0, 6062, 6063, 1, 0, 0, 0, 6063, 6064, 1, 0, + 0, 0, 6064, 6065, 5, 806, 0, 0, 6065, 6066, 5, 1188, 0, 0, 6066, 6083, + 5, 1182, 0, 0, 6067, 6069, 5, 1208, 0, 0, 6068, 6067, 1, 0, 0, 0, 6068, + 6069, 1, 0, 0, 0, 6069, 6070, 1, 0, 0, 0, 6070, 6071, 5, 805, 0, 0, 6071, + 6072, 5, 1188, 0, 0, 6072, 6083, 5, 1182, 0, 0, 6073, 6074, 5, 807, 0, + 0, 6074, 6075, 5, 1188, 0, 0, 6075, 6083, 5, 1182, 0, 0, 6076, 6077, 5, + 558, 0, 0, 6077, 6078, 5, 1188, 0, 0, 6078, 6083, 5, 1182, 0, 0, 6079, + 6080, 5, 415, 0, 0, 6080, 6081, 5, 1188, 0, 0, 6081, 6083, 5, 1182, 0, + 0, 6082, 6058, 1, 0, 0, 0, 6082, 6062, 1, 0, 0, 0, 6082, 6068, 1, 0, 0, + 0, 6082, 6073, 1, 0, 0, 0, 6082, 6076, 1, 0, 0, 0, 6082, 6079, 1, 0, 0, + 0, 6083, 6084, 1, 0, 0, 0, 6084, 6082, 1, 0, 0, 0, 6084, 6085, 1, 0, 0, + 0, 6085, 6086, 1, 0, 0, 0, 6086, 6088, 5, 1207, 0, 0, 6087, 6056, 1, 0, + 0, 0, 6087, 6088, 1, 0, 0, 0, 6088, 6094, 1, 0, 0, 0, 6089, 6092, 5, 1052, + 0, 0, 6090, 6093, 3, 1230, 615, 0, 6091, 6093, 5, 247, 0, 0, 6092, 6090, + 1, 0, 0, 0, 6092, 6091, 1, 0, 0, 0, 6093, 6095, 1, 0, 0, 0, 6094, 6089, + 1, 0, 0, 0, 6094, 6095, 1, 0, 0, 0, 6095, 439, 1, 0, 0, 0, 6096, 6097, + 5, 199, 0, 0, 6097, 6098, 5, 1083, 0, 0, 6098, 6099, 5, 412, 0, 0, 6099, + 6131, 3, 1230, 615, 0, 6100, 6101, 5, 1077, 0, 0, 6101, 6126, 5, 1206, + 0, 0, 6102, 6103, 5, 450, 0, 0, 6103, 6104, 5, 1188, 0, 0, 6104, 6127, + 7, 59, 0, 0, 6105, 6107, 5, 1208, 0, 0, 6106, 6105, 1, 0, 0, 0, 6106, 6107, + 1, 0, 0, 0, 6107, 6108, 1, 0, 0, 0, 6108, 6109, 5, 806, 0, 0, 6109, 6110, + 5, 1188, 0, 0, 6110, 6127, 5, 1182, 0, 0, 6111, 6113, 5, 1208, 0, 0, 6112, + 6111, 1, 0, 0, 0, 6112, 6113, 1, 0, 0, 0, 6113, 6114, 1, 0, 0, 0, 6114, + 6115, 5, 805, 0, 0, 6115, 6116, 5, 1188, 0, 0, 6116, 6127, 5, 1182, 0, + 0, 6117, 6118, 5, 807, 0, 0, 6118, 6119, 5, 1188, 0, 0, 6119, 6127, 5, + 1182, 0, 0, 6120, 6121, 5, 558, 0, 0, 6121, 6122, 5, 1188, 0, 0, 6122, + 6127, 5, 1182, 0, 0, 6123, 6124, 5, 415, 0, 0, 6124, 6125, 5, 1188, 0, + 0, 6125, 6127, 5, 1182, 0, 0, 6126, 6102, 1, 0, 0, 0, 6126, 6106, 1, 0, + 0, 0, 6126, 6112, 1, 0, 0, 0, 6126, 6117, 1, 0, 0, 0, 6126, 6120, 1, 0, + 0, 0, 6126, 6123, 1, 0, 0, 0, 6127, 6128, 1, 0, 0, 0, 6128, 6126, 1, 0, + 0, 0, 6128, 6129, 1, 0, 0, 0, 6129, 6130, 1, 0, 0, 0, 6130, 6132, 5, 1207, + 0, 0, 6131, 6100, 1, 0, 0, 0, 6131, 6132, 1, 0, 0, 0, 6132, 6146, 1, 0, + 0, 0, 6133, 6136, 5, 1052, 0, 0, 6134, 6137, 3, 1230, 615, 0, 6135, 6137, + 5, 247, 0, 0, 6136, 6134, 1, 0, 0, 0, 6136, 6135, 1, 0, 0, 0, 6136, 6137, + 1, 0, 0, 0, 6137, 6144, 1, 0, 0, 0, 6138, 6140, 5, 1208, 0, 0, 6139, 6138, + 1, 0, 0, 0, 6139, 6140, 1, 0, 0, 0, 6140, 6141, 1, 0, 0, 0, 6141, 6142, + 5, 331, 0, 0, 6142, 6145, 3, 1230, 615, 0, 6143, 6145, 5, 247, 0, 0, 6144, + 6139, 1, 0, 0, 0, 6144, 6143, 1, 0, 0, 0, 6144, 6145, 1, 0, 0, 0, 6145, + 6147, 1, 0, 0, 0, 6146, 6133, 1, 0, 0, 0, 6146, 6147, 1, 0, 0, 0, 6147, + 441, 1, 0, 0, 0, 6148, 6149, 5, 199, 0, 0, 6149, 6150, 5, 1088, 0, 0, 6150, + 6151, 5, 857, 0, 0, 6151, 6155, 5, 154, 0, 0, 6152, 6153, 3, 1230, 615, + 0, 6153, 6154, 5, 1201, 0, 0, 6154, 6156, 1, 0, 0, 0, 6155, 6152, 1, 0, + 0, 0, 6155, 6156, 1, 0, 0, 0, 6156, 6157, 1, 0, 0, 0, 6157, 6158, 3, 1230, + 615, 0, 6158, 6162, 5, 56, 0, 0, 6159, 6163, 5, 1184, 0, 0, 6160, 6163, + 3, 1230, 615, 0, 6161, 6163, 5, 1180, 0, 0, 6162, 6159, 1, 0, 0, 0, 6162, + 6160, 1, 0, 0, 0, 6162, 6161, 1, 0, 0, 0, 6163, 443, 1, 0, 0, 0, 6164, + 6165, 5, 199, 0, 0, 6165, 6166, 5, 700, 0, 0, 6166, 6167, 5, 386, 0, 0, + 6167, 6168, 3, 1230, 615, 0, 6168, 6169, 5, 1206, 0, 0, 6169, 6170, 3, + 1222, 611, 0, 6170, 6171, 5, 1207, 0, 0, 6171, 6172, 5, 56, 0, 0, 6172, + 6174, 5, 761, 0, 0, 6173, 6175, 7, 60, 0, 0, 6174, 6173, 1, 0, 0, 0, 6174, + 6175, 1, 0, 0, 0, 6175, 6176, 1, 0, 0, 0, 6176, 6177, 5, 365, 0, 0, 6177, + 6178, 5, 1056, 0, 0, 6178, 6179, 5, 1206, 0, 0, 6179, 6180, 3, 1126, 563, + 0, 6180, 6181, 5, 1207, 0, 0, 6181, 445, 1, 0, 0, 0, 6182, 6183, 5, 199, + 0, 0, 6183, 6184, 5, 700, 0, 0, 6184, 6185, 5, 861, 0, 0, 6185, 6186, 3, + 1230, 615, 0, 6186, 6187, 5, 56, 0, 0, 6187, 6188, 5, 700, 0, 0, 6188, + 6190, 3, 1230, 615, 0, 6189, 6191, 5, 22, 0, 0, 6190, 6189, 1, 0, 0, 0, + 6190, 6191, 1, 0, 0, 0, 6191, 6192, 1, 0, 0, 0, 6192, 6193, 5, 1000, 0, + 0, 6193, 6194, 5, 1206, 0, 0, 6194, 6199, 3, 1230, 615, 0, 6195, 6196, + 5, 1208, 0, 0, 6196, 6198, 3, 1230, 615, 0, 6197, 6195, 1, 0, 0, 0, 6198, + 6201, 1, 0, 0, 0, 6199, 6197, 1, 0, 0, 0, 6199, 6200, 1, 0, 0, 0, 6200, + 6202, 1, 0, 0, 0, 6201, 6199, 1, 0, 0, 0, 6202, 6203, 5, 1207, 0, 0, 6203, + 447, 1, 0, 0, 0, 6204, 6205, 5, 199, 0, 0, 6205, 6208, 5, 754, 0, 0, 6206, + 6209, 3, 1164, 582, 0, 6207, 6209, 3, 1230, 615, 0, 6208, 6206, 1, 0, 0, + 0, 6208, 6207, 1, 0, 0, 0, 6209, 6211, 1, 0, 0, 0, 6210, 6212, 3, 450, + 225, 0, 6211, 6210, 1, 0, 0, 0, 6211, 6212, 1, 0, 0, 0, 6212, 6216, 1, + 0, 0, 0, 6213, 6214, 5, 662, 0, 0, 6214, 6217, 3, 1230, 615, 0, 6215, 6217, + 5, 245, 0, 0, 6216, 6213, 1, 0, 0, 0, 6216, 6215, 1, 0, 0, 0, 6216, 6217, + 1, 0, 0, 0, 6217, 449, 1, 0, 0, 0, 6218, 6225, 5, 1077, 0, 0, 6219, 6220, + 5, 951, 0, 0, 6220, 6221, 5, 1188, 0, 0, 6221, 6223, 3, 1196, 598, 0, 6222, + 6224, 5, 1208, 0, 0, 6223, 6222, 1, 0, 0, 0, 6223, 6224, 1, 0, 0, 0, 6224, + 6226, 1, 0, 0, 0, 6225, 6219, 1, 0, 0, 0, 6225, 6226, 1, 0, 0, 0, 6226, + 6233, 1, 0, 0, 0, 6227, 6228, 5, 823, 0, 0, 6228, 6229, 5, 1188, 0, 0, + 6229, 6231, 3, 1196, 598, 0, 6230, 6232, 5, 1208, 0, 0, 6231, 6230, 1, + 0, 0, 0, 6231, 6232, 1, 0, 0, 0, 6232, 6234, 1, 0, 0, 0, 6233, 6227, 1, + 0, 0, 0, 6233, 6234, 1, 0, 0, 0, 6234, 6280, 1, 0, 0, 0, 6235, 6236, 5, + 9, 0, 0, 6236, 6274, 5, 1206, 0, 0, 6237, 6238, 5, 951, 0, 0, 6238, 6239, + 5, 1188, 0, 0, 6239, 6241, 3, 1196, 598, 0, 6240, 6242, 5, 1208, 0, 0, + 6241, 6240, 1, 0, 0, 0, 6241, 6242, 1, 0, 0, 0, 6242, 6244, 1, 0, 0, 0, + 6243, 6237, 1, 0, 0, 0, 6243, 6244, 1, 0, 0, 0, 6244, 6251, 1, 0, 0, 0, + 6245, 6246, 5, 742, 0, 0, 6246, 6247, 5, 1188, 0, 0, 6247, 6249, 3, 1176, + 588, 0, 6248, 6250, 5, 1208, 0, 0, 6249, 6248, 1, 0, 0, 0, 6249, 6250, + 1, 0, 0, 0, 6250, 6252, 1, 0, 0, 0, 6251, 6245, 1, 0, 0, 0, 6251, 6252, + 1, 0, 0, 0, 6252, 6259, 1, 0, 0, 0, 6253, 6254, 5, 567, 0, 0, 6254, 6255, + 5, 1188, 0, 0, 6255, 6257, 5, 1182, 0, 0, 6256, 6258, 5, 1208, 0, 0, 6257, + 6256, 1, 0, 0, 0, 6257, 6258, 1, 0, 0, 0, 6258, 6260, 1, 0, 0, 0, 6259, + 6253, 1, 0, 0, 0, 6259, 6260, 1, 0, 0, 0, 6260, 6271, 1, 0, 0, 0, 6261, + 6262, 5, 320, 0, 0, 6262, 6266, 5, 56, 0, 0, 6263, 6267, 5, 879, 0, 0, + 6264, 6267, 5, 1184, 0, 0, 6265, 6267, 5, 687, 0, 0, 6266, 6263, 1, 0, + 0, 0, 6266, 6264, 1, 0, 0, 0, 6266, 6265, 1, 0, 0, 0, 6267, 6269, 1, 0, + 0, 0, 6268, 6270, 5, 1208, 0, 0, 6269, 6268, 1, 0, 0, 0, 6269, 6270, 1, + 0, 0, 0, 6270, 6272, 1, 0, 0, 0, 6271, 6261, 1, 0, 0, 0, 6271, 6272, 1, + 0, 0, 0, 6272, 6275, 1, 0, 0, 0, 6273, 6275, 5, 282, 0, 0, 6274, 6243, + 1, 0, 0, 0, 6274, 6273, 1, 0, 0, 0, 6275, 6276, 1, 0, 0, 0, 6276, 6278, + 5, 1207, 0, 0, 6277, 6279, 5, 1208, 0, 0, 6278, 6277, 1, 0, 0, 0, 6278, + 6279, 1, 0, 0, 0, 6279, 6281, 1, 0, 0, 0, 6280, 6235, 1, 0, 0, 0, 6280, + 6281, 1, 0, 0, 0, 6281, 6290, 1, 0, 0, 0, 6282, 6283, 5, 723, 0, 0, 6283, + 6284, 5, 1206, 0, 0, 6284, 6285, 5, 951, 0, 0, 6285, 6286, 5, 1188, 0, + 0, 6286, 6287, 3, 1196, 598, 0, 6287, 6288, 1, 0, 0, 0, 6288, 6289, 5, + 1207, 0, 0, 6289, 6291, 1, 0, 0, 0, 6290, 6282, 1, 0, 0, 0, 6290, 6291, + 1, 0, 0, 0, 6291, 451, 1, 0, 0, 0, 6292, 6293, 5, 35, 0, 0, 6293, 6296, + 5, 754, 0, 0, 6294, 6297, 3, 1164, 582, 0, 6295, 6297, 3, 1230, 615, 0, + 6296, 6294, 1, 0, 0, 0, 6296, 6295, 1, 0, 0, 0, 6297, 6300, 1, 0, 0, 0, + 6298, 6301, 3, 450, 225, 0, 6299, 6301, 3, 454, 227, 0, 6300, 6298, 1, + 0, 0, 0, 6300, 6299, 1, 0, 0, 0, 6301, 453, 1, 0, 0, 0, 6302, 6308, 5, + 780, 0, 0, 6303, 6304, 5, 1077, 0, 0, 6304, 6305, 5, 1206, 0, 0, 6305, + 6306, 3, 456, 228, 0, 6306, 6307, 5, 1207, 0, 0, 6307, 6309, 1, 0, 0, 0, + 6308, 6303, 1, 0, 0, 0, 6308, 6309, 1, 0, 0, 0, 6309, 6324, 1, 0, 0, 0, + 6310, 6315, 5, 795, 0, 0, 6311, 6312, 5, 1077, 0, 0, 6312, 6313, 5, 530, + 0, 0, 6313, 6314, 5, 1188, 0, 0, 6314, 6316, 3, 1196, 598, 0, 6315, 6311, + 1, 0, 0, 0, 6315, 6316, 1, 0, 0, 0, 6316, 6324, 1, 0, 0, 0, 6317, 6318, + 5, 594, 0, 0, 6318, 6321, 5, 1000, 0, 0, 6319, 6322, 3, 1230, 615, 0, 6320, + 6322, 5, 245, 0, 0, 6321, 6319, 1, 0, 0, 0, 6321, 6320, 1, 0, 0, 0, 6322, + 6324, 1, 0, 0, 0, 6323, 6302, 1, 0, 0, 0, 6323, 6310, 1, 0, 0, 0, 6323, + 6317, 1, 0, 0, 0, 6324, 455, 1, 0, 0, 0, 6325, 6326, 5, 551, 0, 0, 6326, + 6327, 5, 1188, 0, 0, 6327, 6328, 5, 1182, 0, 0, 6328, 457, 1, 0, 0, 0, + 6329, 6330, 5, 199, 0, 0, 6330, 6331, 5, 188, 0, 0, 6331, 6334, 3, 1208, + 604, 0, 6332, 6333, 5, 68, 0, 0, 6333, 6335, 3, 1230, 615, 0, 6334, 6332, + 1, 0, 0, 0, 6334, 6335, 1, 0, 0, 0, 6335, 6336, 1, 0, 0, 0, 6336, 6347, + 5, 1206, 0, 0, 6337, 6340, 3, 1230, 615, 0, 6338, 6340, 5, 245, 0, 0, 6339, + 6337, 1, 0, 0, 0, 6339, 6338, 1, 0, 0, 0, 6340, 6341, 1, 0, 0, 0, 6341, + 6342, 5, 885, 0, 0, 6342, 6343, 5, 111, 0, 0, 6343, 6345, 7, 61, 0, 0, + 6344, 6346, 5, 1208, 0, 0, 6345, 6344, 1, 0, 0, 0, 6345, 6346, 1, 0, 0, + 0, 6346, 6348, 1, 0, 0, 0, 6347, 6339, 1, 0, 0, 0, 6348, 6349, 1, 0, 0, + 0, 6349, 6347, 1, 0, 0, 0, 6349, 6350, 1, 0, 0, 0, 6350, 6351, 1, 0, 0, + 0, 6351, 6352, 5, 1207, 0, 0, 6352, 459, 1, 0, 0, 0, 6353, 6360, 3, 1204, + 602, 0, 6354, 6360, 3, 1206, 603, 0, 6355, 6360, 3, 1212, 606, 0, 6356, + 6360, 3, 1216, 608, 0, 6357, 6360, 3, 1220, 610, 0, 6358, 6360, 3, 1214, + 607, 0, 6359, 6353, 1, 0, 0, 0, 6359, 6354, 1, 0, 0, 0, 6359, 6355, 1, + 0, 0, 0, 6359, 6356, 1, 0, 0, 0, 6359, 6357, 1, 0, 0, 0, 6359, 6358, 1, + 0, 0, 0, 6360, 461, 1, 0, 0, 0, 6361, 6362, 5, 199, 0, 0, 6362, 6363, 5, + 578, 0, 0, 6363, 6364, 5, 1024, 0, 0, 6364, 6367, 3, 1230, 615, 0, 6365, + 6366, 5, 68, 0, 0, 6366, 6368, 3, 1230, 615, 0, 6367, 6365, 1, 0, 0, 0, + 6367, 6368, 1, 0, 0, 0, 6368, 6369, 1, 0, 0, 0, 6369, 6370, 5, 1053, 0, + 0, 6370, 6379, 5, 1188, 0, 0, 6371, 6380, 5, 621, 0, 0, 6372, 6380, 5, + 291, 0, 0, 6373, 6380, 5, 1072, 0, 0, 6374, 6375, 5, 1054, 0, 0, 6375, + 6376, 5, 1077, 0, 0, 6376, 6377, 5, 857, 0, 0, 6377, 6378, 5, 154, 0, 0, + 6378, 6380, 3, 1230, 615, 0, 6379, 6371, 1, 0, 0, 0, 6379, 6372, 1, 0, + 0, 0, 6379, 6373, 1, 0, 0, 0, 6379, 6374, 1, 0, 0, 0, 6380, 463, 1, 0, + 0, 0, 6381, 6383, 3, 942, 471, 0, 6382, 6381, 1, 0, 0, 0, 6382, 6383, 1, + 0, 0, 0, 6383, 6384, 1, 0, 0, 0, 6384, 6392, 5, 577, 0, 0, 6385, 6386, + 5, 1001, 0, 0, 6386, 6387, 5, 1206, 0, 0, 6387, 6388, 3, 926, 463, 0, 6388, + 6390, 5, 1207, 0, 0, 6389, 6391, 5, 708, 0, 0, 6390, 6389, 1, 0, 0, 0, + 6390, 6391, 1, 0, 0, 0, 6391, 6393, 1, 0, 0, 0, 6392, 6385, 1, 0, 0, 0, + 6392, 6393, 1, 0, 0, 0, 6393, 6395, 1, 0, 0, 0, 6394, 6396, 5, 471, 0, + 0, 6395, 6394, 1, 0, 0, 0, 6395, 6396, 1, 0, 0, 0, 6396, 6397, 1, 0, 0, + 0, 6397, 6399, 3, 1180, 590, 0, 6398, 6400, 3, 1108, 554, 0, 6399, 6398, + 1, 0, 0, 0, 6399, 6400, 1, 0, 0, 0, 6400, 6402, 1, 0, 0, 0, 6401, 6403, + 3, 1104, 552, 0, 6402, 6401, 1, 0, 0, 0, 6402, 6403, 1, 0, 0, 0, 6403, + 6404, 1, 0, 0, 0, 6404, 6405, 5, 1052, 0, 0, 6405, 6406, 3, 1004, 502, + 0, 6406, 6407, 5, 662, 0, 0, 6407, 6409, 3, 950, 475, 0, 6408, 6410, 3, + 466, 233, 0, 6409, 6408, 1, 0, 0, 0, 6410, 6411, 1, 0, 0, 0, 6411, 6409, + 1, 0, 0, 0, 6411, 6412, 1, 0, 0, 0, 6412, 6414, 1, 0, 0, 0, 6413, 6415, + 3, 490, 245, 0, 6414, 6413, 1, 0, 0, 0, 6414, 6415, 1, 0, 0, 0, 6415, 6417, + 1, 0, 0, 0, 6416, 6418, 3, 986, 493, 0, 6417, 6416, 1, 0, 0, 0, 6417, 6418, + 1, 0, 0, 0, 6418, 6419, 1, 0, 0, 0, 6419, 6420, 5, 1209, 0, 0, 6420, 465, + 1, 0, 0, 0, 6421, 6422, 5, 1073, 0, 0, 6422, 6425, 5, 548, 0, 0, 6423, + 6424, 5, 37, 0, 0, 6424, 6426, 3, 950, 475, 0, 6425, 6423, 1, 0, 0, 0, + 6425, 6426, 1, 0, 0, 0, 6426, 6427, 1, 0, 0, 0, 6427, 6428, 5, 993, 0, + 0, 6428, 6430, 3, 468, 234, 0, 6429, 6421, 1, 0, 0, 0, 6430, 6431, 1, 0, + 0, 0, 6431, 6429, 1, 0, 0, 0, 6431, 6432, 1, 0, 0, 0, 6432, 6462, 1, 0, + 0, 0, 6433, 6434, 5, 1073, 0, 0, 6434, 6435, 5, 627, 0, 0, 6435, 6438, + 5, 548, 0, 0, 6436, 6437, 5, 111, 0, 0, 6437, 6439, 5, 987, 0, 0, 6438, + 6436, 1, 0, 0, 0, 6438, 6439, 1, 0, 0, 0, 6439, 6442, 1, 0, 0, 0, 6440, + 6441, 5, 37, 0, 0, 6441, 6443, 3, 950, 475, 0, 6442, 6440, 1, 0, 0, 0, + 6442, 6443, 1, 0, 0, 0, 6443, 6444, 1, 0, 0, 0, 6444, 6445, 5, 993, 0, + 0, 6445, 6462, 3, 470, 235, 0, 6446, 6447, 5, 1073, 0, 0, 6447, 6448, 5, + 627, 0, 0, 6448, 6449, 5, 548, 0, 0, 6449, 6450, 5, 111, 0, 0, 6450, 6453, + 5, 926, 0, 0, 6451, 6452, 5, 37, 0, 0, 6452, 6454, 3, 950, 475, 0, 6453, + 6451, 1, 0, 0, 0, 6453, 6454, 1, 0, 0, 0, 6454, 6455, 1, 0, 0, 0, 6455, + 6456, 5, 993, 0, 0, 6456, 6458, 3, 468, 234, 0, 6457, 6446, 1, 0, 0, 0, + 6458, 6459, 1, 0, 0, 0, 6459, 6457, 1, 0, 0, 0, 6459, 6460, 1, 0, 0, 0, + 6460, 6462, 1, 0, 0, 0, 6461, 6429, 1, 0, 0, 0, 6461, 6433, 1, 0, 0, 0, + 6461, 6457, 1, 0, 0, 0, 6462, 467, 1, 0, 0, 0, 6463, 6464, 5, 1042, 0, + 0, 6464, 6465, 5, 900, 0, 0, 6465, 6470, 3, 948, 474, 0, 6466, 6467, 5, + 1208, 0, 0, 6467, 6469, 3, 948, 474, 0, 6468, 6466, 1, 0, 0, 0, 6469, 6472, + 1, 0, 0, 0, 6470, 6468, 1, 0, 0, 0, 6470, 6471, 1, 0, 0, 0, 6471, 6475, + 1, 0, 0, 0, 6472, 6470, 1, 0, 0, 0, 6473, 6475, 5, 254, 0, 0, 6474, 6463, + 1, 0, 0, 0, 6474, 6473, 1, 0, 0, 0, 6475, 469, 1, 0, 0, 0, 6476, 6481, + 5, 466, 0, 0, 6477, 6478, 5, 1206, 0, 0, 6478, 6479, 3, 1192, 596, 0, 6479, + 6480, 5, 1207, 0, 0, 6480, 6482, 1, 0, 0, 0, 6481, 6477, 1, 0, 0, 0, 6481, + 6482, 1, 0, 0, 0, 6482, 6486, 1, 0, 0, 0, 6483, 6487, 3, 1124, 562, 0, + 6484, 6485, 5, 245, 0, 0, 6485, 6487, 5, 1056, 0, 0, 6486, 6483, 1, 0, + 0, 0, 6486, 6484, 1, 0, 0, 0, 6487, 471, 1, 0, 0, 0, 6488, 6490, 3, 942, + 471, 0, 6489, 6488, 1, 0, 0, 0, 6489, 6490, 1, 0, 0, 0, 6490, 6491, 1, + 0, 0, 0, 6491, 6501, 5, 254, 0, 0, 6492, 6493, 5, 1001, 0, 0, 6493, 6494, + 5, 1206, 0, 0, 6494, 6495, 3, 926, 463, 0, 6495, 6497, 5, 1207, 0, 0, 6496, + 6498, 5, 708, 0, 0, 6497, 6496, 1, 0, 0, 0, 6497, 6498, 1, 0, 0, 0, 6498, + 6502, 1, 0, 0, 0, 6499, 6500, 5, 1001, 0, 0, 6500, 6502, 5, 1182, 0, 0, + 6501, 6492, 1, 0, 0, 0, 6501, 6499, 1, 0, 0, 0, 6501, 6502, 1, 0, 0, 0, + 6502, 6504, 1, 0, 0, 0, 6503, 6505, 5, 380, 0, 0, 6504, 6503, 1, 0, 0, + 0, 6504, 6505, 1, 0, 0, 0, 6505, 6506, 1, 0, 0, 0, 6506, 6508, 3, 474, + 237, 0, 6507, 6509, 3, 1108, 554, 0, 6508, 6507, 1, 0, 0, 0, 6508, 6509, + 1, 0, 0, 0, 6509, 6511, 1, 0, 0, 0, 6510, 6512, 3, 490, 245, 0, 6511, 6510, + 1, 0, 0, 0, 6511, 6512, 1, 0, 0, 0, 6512, 6514, 1, 0, 0, 0, 6513, 6515, + 3, 964, 482, 0, 6514, 6513, 1, 0, 0, 0, 6514, 6515, 1, 0, 0, 0, 6515, 6529, + 1, 0, 0, 0, 6516, 6527, 5, 1074, 0, 0, 6517, 6528, 3, 950, 475, 0, 6518, + 6519, 5, 206, 0, 0, 6519, 6525, 5, 655, 0, 0, 6520, 6522, 5, 406, 0, 0, + 6521, 6520, 1, 0, 0, 0, 6521, 6522, 1, 0, 0, 0, 6522, 6523, 1, 0, 0, 0, + 6523, 6526, 3, 1194, 597, 0, 6524, 6526, 5, 1180, 0, 0, 6525, 6521, 1, + 0, 0, 0, 6525, 6524, 1, 0, 0, 0, 6526, 6528, 1, 0, 0, 0, 6527, 6517, 1, + 0, 0, 0, 6527, 6518, 1, 0, 0, 0, 6528, 6530, 1, 0, 0, 0, 6529, 6516, 1, + 0, 0, 0, 6529, 6530, 1, 0, 0, 0, 6530, 6532, 1, 0, 0, 0, 6531, 6533, 3, + 976, 488, 0, 6532, 6531, 1, 0, 0, 0, 6532, 6533, 1, 0, 0, 0, 6533, 6535, + 1, 0, 0, 0, 6534, 6536, 3, 986, 493, 0, 6535, 6534, 1, 0, 0, 0, 6535, 6536, + 1, 0, 0, 0, 6536, 6538, 1, 0, 0, 0, 6537, 6539, 5, 1209, 0, 0, 6538, 6537, + 1, 0, 0, 0, 6538, 6539, 1, 0, 0, 0, 6539, 473, 1, 0, 0, 0, 6540, 6544, + 3, 1180, 590, 0, 6541, 6544, 3, 728, 364, 0, 6542, 6544, 5, 1180, 0, 0, + 6543, 6540, 1, 0, 0, 0, 6543, 6541, 1, 0, 0, 0, 6543, 6542, 1, 0, 0, 0, + 6544, 475, 1, 0, 0, 0, 6545, 6547, 3, 942, 471, 0, 6546, 6545, 1, 0, 0, + 0, 6546, 6547, 1, 0, 0, 0, 6547, 6548, 1, 0, 0, 0, 6548, 6556, 5, 466, + 0, 0, 6549, 6550, 5, 1001, 0, 0, 6550, 6551, 5, 1206, 0, 0, 6551, 6552, + 3, 926, 463, 0, 6552, 6554, 5, 1207, 0, 0, 6553, 6555, 5, 708, 0, 0, 6554, + 6553, 1, 0, 0, 0, 6554, 6555, 1, 0, 0, 0, 6555, 6557, 1, 0, 0, 0, 6556, + 6549, 1, 0, 0, 0, 6556, 6557, 1, 0, 0, 0, 6557, 6559, 1, 0, 0, 0, 6558, + 6560, 5, 471, 0, 0, 6559, 6558, 1, 0, 0, 0, 6559, 6560, 1, 0, 0, 0, 6560, + 6563, 1, 0, 0, 0, 6561, 6564, 3, 1180, 590, 0, 6562, 6564, 3, 728, 364, + 0, 6563, 6561, 1, 0, 0, 0, 6563, 6562, 1, 0, 0, 0, 6564, 6566, 1, 0, 0, + 0, 6565, 6567, 3, 1108, 554, 0, 6566, 6565, 1, 0, 0, 0, 6566, 6567, 1, + 0, 0, 0, 6567, 6572, 1, 0, 0, 0, 6568, 6569, 5, 1206, 0, 0, 6569, 6570, + 3, 1188, 594, 0, 6570, 6571, 5, 1207, 0, 0, 6571, 6573, 1, 0, 0, 0, 6572, + 6568, 1, 0, 0, 0, 6572, 6573, 1, 0, 0, 0, 6573, 6575, 1, 0, 0, 0, 6574, + 6576, 3, 490, 245, 0, 6575, 6574, 1, 0, 0, 0, 6575, 6576, 1, 0, 0, 0, 6576, + 6577, 1, 0, 0, 0, 6577, 6579, 3, 478, 239, 0, 6578, 6580, 3, 976, 488, + 0, 6579, 6578, 1, 0, 0, 0, 6579, 6580, 1, 0, 0, 0, 6580, 6582, 1, 0, 0, + 0, 6581, 6583, 3, 986, 493, 0, 6582, 6581, 1, 0, 0, 0, 6582, 6583, 1, 0, + 0, 0, 6583, 6585, 1, 0, 0, 0, 6584, 6586, 5, 1209, 0, 0, 6585, 6584, 1, + 0, 0, 0, 6585, 6586, 1, 0, 0, 0, 6586, 477, 1, 0, 0, 0, 6587, 6592, 3, + 1050, 525, 0, 6588, 6592, 3, 758, 379, 0, 6589, 6590, 5, 245, 0, 0, 6590, + 6592, 5, 1056, 0, 0, 6591, 6587, 1, 0, 0, 0, 6591, 6588, 1, 0, 0, 0, 6591, + 6589, 1, 0, 0, 0, 6592, 479, 1, 0, 0, 0, 6593, 6595, 5, 1206, 0, 0, 6594, + 6593, 1, 0, 0, 0, 6594, 6595, 1, 0, 0, 0, 6595, 6596, 1, 0, 0, 0, 6596, + 6601, 5, 781, 0, 0, 6597, 6602, 5, 22, 0, 0, 6598, 6602, 5, 274, 0, 0, + 6599, 6602, 3, 966, 483, 0, 6600, 6602, 5, 1212, 0, 0, 6601, 6597, 1, 0, + 0, 0, 6601, 6598, 1, 0, 0, 0, 6601, 6599, 1, 0, 0, 0, 6601, 6600, 1, 0, + 0, 0, 6602, 6611, 1, 0, 0, 0, 6603, 6604, 5, 1180, 0, 0, 6604, 6605, 5, + 1188, 0, 0, 6605, 6607, 3, 926, 463, 0, 6606, 6608, 5, 1208, 0, 0, 6607, + 6606, 1, 0, 0, 0, 6607, 6608, 1, 0, 0, 0, 6608, 6610, 1, 0, 0, 0, 6609, + 6603, 1, 0, 0, 0, 6610, 6613, 1, 0, 0, 0, 6611, 6609, 1, 0, 0, 0, 6611, + 6612, 1, 0, 0, 0, 6612, 6614, 1, 0, 0, 0, 6613, 6611, 1, 0, 0, 0, 6614, + 6615, 5, 380, 0, 0, 6615, 6621, 3, 1164, 582, 0, 6616, 6617, 5, 471, 0, + 0, 6617, 6618, 3, 1230, 615, 0, 6618, 6619, 5, 1074, 0, 0, 6619, 6620, + 3, 950, 475, 0, 6620, 6622, 1, 0, 0, 0, 6621, 6616, 1, 0, 0, 0, 6621, 6622, + 1, 0, 0, 0, 6622, 6624, 1, 0, 0, 0, 6623, 6625, 5, 1207, 0, 0, 6624, 6623, + 1, 0, 0, 0, 6624, 6625, 1, 0, 0, 0, 6625, 481, 1, 0, 0, 0, 6626, 6628, + 3, 942, 471, 0, 6627, 6626, 1, 0, 0, 0, 6627, 6628, 1, 0, 0, 0, 6628, 6629, + 1, 0, 0, 0, 6629, 6630, 3, 484, 242, 0, 6630, 483, 1, 0, 0, 0, 6631, 6633, + 3, 954, 477, 0, 6632, 6634, 3, 974, 487, 0, 6633, 6632, 1, 0, 0, 0, 6633, + 6634, 1, 0, 0, 0, 6634, 6636, 1, 0, 0, 0, 6635, 6637, 3, 976, 488, 0, 6636, + 6635, 1, 0, 0, 0, 6636, 6637, 1, 0, 0, 0, 6637, 6639, 1, 0, 0, 0, 6638, + 6640, 3, 986, 493, 0, 6639, 6638, 1, 0, 0, 0, 6639, 6640, 1, 0, 0, 0, 6640, + 6642, 1, 0, 0, 0, 6641, 6643, 5, 1209, 0, 0, 6642, 6641, 1, 0, 0, 0, 6642, + 6643, 1, 0, 0, 0, 6643, 485, 1, 0, 0, 0, 6644, 6647, 5, 1180, 0, 0, 6645, + 6647, 3, 1224, 612, 0, 6646, 6644, 1, 0, 0, 0, 6646, 6645, 1, 0, 0, 0, + 6647, 487, 1, 0, 0, 0, 6648, 6650, 3, 942, 471, 0, 6649, 6648, 1, 0, 0, + 0, 6649, 6650, 1, 0, 0, 0, 6650, 6651, 1, 0, 0, 0, 6651, 6659, 5, 1042, + 0, 0, 6652, 6653, 5, 1001, 0, 0, 6653, 6654, 5, 1206, 0, 0, 6654, 6655, + 3, 926, 463, 0, 6655, 6657, 5, 1207, 0, 0, 6656, 6658, 5, 708, 0, 0, 6657, + 6656, 1, 0, 0, 0, 6657, 6658, 1, 0, 0, 0, 6658, 6660, 1, 0, 0, 0, 6659, + 6652, 1, 0, 0, 0, 6659, 6660, 1, 0, 0, 0, 6660, 6663, 1, 0, 0, 0, 6661, + 6664, 3, 1180, 590, 0, 6662, 6664, 3, 728, 364, 0, 6663, 6661, 1, 0, 0, + 0, 6663, 6662, 1, 0, 0, 0, 6664, 6666, 1, 0, 0, 0, 6665, 6667, 3, 1108, + 554, 0, 6666, 6665, 1, 0, 0, 0, 6666, 6667, 1, 0, 0, 0, 6667, 6668, 1, + 0, 0, 0, 6668, 6669, 5, 900, 0, 0, 6669, 6674, 3, 946, 473, 0, 6670, 6671, + 5, 1208, 0, 0, 6671, 6673, 3, 946, 473, 0, 6672, 6670, 1, 0, 0, 0, 6673, + 6676, 1, 0, 0, 0, 6674, 6672, 1, 0, 0, 0, 6674, 6675, 1, 0, 0, 0, 6675, + 6678, 1, 0, 0, 0, 6676, 6674, 1, 0, 0, 0, 6677, 6679, 3, 490, 245, 0, 6678, + 6677, 1, 0, 0, 0, 6678, 6679, 1, 0, 0, 0, 6679, 6682, 1, 0, 0, 0, 6680, + 6681, 5, 380, 0, 0, 6681, 6683, 3, 1004, 502, 0, 6682, 6680, 1, 0, 0, 0, + 6682, 6683, 1, 0, 0, 0, 6683, 6697, 1, 0, 0, 0, 6684, 6695, 5, 1074, 0, + 0, 6685, 6696, 3, 950, 475, 0, 6686, 6687, 5, 206, 0, 0, 6687, 6693, 5, + 655, 0, 0, 6688, 6690, 5, 406, 0, 0, 6689, 6688, 1, 0, 0, 0, 6689, 6690, + 1, 0, 0, 0, 6690, 6691, 1, 0, 0, 0, 6691, 6694, 3, 1194, 597, 0, 6692, + 6694, 5, 1180, 0, 0, 6693, 6689, 1, 0, 0, 0, 6693, 6692, 1, 0, 0, 0, 6694, + 6696, 1, 0, 0, 0, 6695, 6685, 1, 0, 0, 0, 6695, 6686, 1, 0, 0, 0, 6696, + 6698, 1, 0, 0, 0, 6697, 6684, 1, 0, 0, 0, 6697, 6698, 1, 0, 0, 0, 6698, + 6700, 1, 0, 0, 0, 6699, 6701, 3, 976, 488, 0, 6700, 6699, 1, 0, 0, 0, 6700, + 6701, 1, 0, 0, 0, 6701, 6703, 1, 0, 0, 0, 6702, 6704, 3, 986, 493, 0, 6703, + 6702, 1, 0, 0, 0, 6703, 6704, 1, 0, 0, 0, 6704, 6706, 1, 0, 0, 0, 6705, + 6707, 5, 1209, 0, 0, 6706, 6705, 1, 0, 0, 0, 6706, 6707, 1, 0, 0, 0, 6707, + 489, 1, 0, 0, 0, 6708, 6709, 5, 684, 0, 0, 6709, 6714, 3, 492, 246, 0, + 6710, 6711, 5, 1208, 0, 0, 6711, 6713, 3, 492, 246, 0, 6712, 6710, 1, 0, + 0, 0, 6713, 6716, 1, 0, 0, 0, 6714, 6712, 1, 0, 0, 0, 6714, 6715, 1, 0, + 0, 0, 6715, 6728, 1, 0, 0, 0, 6716, 6714, 1, 0, 0, 0, 6717, 6720, 5, 471, + 0, 0, 6718, 6721, 5, 1180, 0, 0, 6719, 6721, 3, 1170, 585, 0, 6720, 6718, + 1, 0, 0, 0, 6720, 6719, 1, 0, 0, 0, 6721, 6726, 1, 0, 0, 0, 6722, 6723, + 5, 1206, 0, 0, 6723, 6724, 3, 1192, 596, 0, 6724, 6725, 5, 1207, 0, 0, + 6725, 6727, 1, 0, 0, 0, 6726, 6722, 1, 0, 0, 0, 6726, 6727, 1, 0, 0, 0, + 6727, 6729, 1, 0, 0, 0, 6728, 6717, 1, 0, 0, 0, 6728, 6729, 1, 0, 0, 0, + 6729, 491, 1, 0, 0, 0, 6730, 6733, 3, 926, 463, 0, 6731, 6733, 3, 996, + 498, 0, 6732, 6730, 1, 0, 0, 0, 6732, 6731, 1, 0, 0, 0, 6733, 6735, 1, + 0, 0, 0, 6734, 6736, 3, 1102, 551, 0, 6735, 6734, 1, 0, 0, 0, 6735, 6736, + 1, 0, 0, 0, 6736, 493, 1, 0, 0, 0, 6737, 6738, 5, 199, 0, 0, 6738, 6739, + 5, 219, 0, 0, 6739, 6743, 3, 1230, 615, 0, 6740, 6741, 5, 180, 0, 0, 6741, + 6742, 5, 1188, 0, 0, 6742, 6744, 7, 62, 0, 0, 6743, 6740, 1, 0, 0, 0, 6743, + 6744, 1, 0, 0, 0, 6744, 6757, 1, 0, 0, 0, 6745, 6747, 5, 662, 0, 0, 6746, + 6748, 5, 730, 0, 0, 6747, 6746, 1, 0, 0, 0, 6747, 6748, 1, 0, 0, 0, 6748, + 6749, 1, 0, 0, 0, 6749, 6754, 3, 1152, 576, 0, 6750, 6751, 5, 1208, 0, + 0, 6751, 6753, 3, 1152, 576, 0, 6752, 6750, 1, 0, 0, 0, 6753, 6756, 1, + 0, 0, 0, 6754, 6752, 1, 0, 0, 0, 6754, 6755, 1, 0, 0, 0, 6755, 6758, 1, + 0, 0, 0, 6756, 6754, 1, 0, 0, 0, 6757, 6745, 1, 0, 0, 0, 6757, 6758, 1, + 0, 0, 0, 6758, 6769, 1, 0, 0, 0, 6759, 6760, 5, 536, 0, 0, 6760, 6761, + 5, 662, 0, 0, 6761, 6766, 3, 1152, 576, 0, 6762, 6763, 5, 1208, 0, 0, 6763, + 6765, 3, 1152, 576, 0, 6764, 6762, 1, 0, 0, 0, 6765, 6768, 1, 0, 0, 0, + 6766, 6764, 1, 0, 0, 0, 6766, 6767, 1, 0, 0, 0, 6767, 6770, 1, 0, 0, 0, + 6768, 6766, 1, 0, 0, 0, 6769, 6759, 1, 0, 0, 0, 6769, 6770, 1, 0, 0, 0, + 6770, 6773, 1, 0, 0, 0, 6771, 6772, 5, 153, 0, 0, 6772, 6774, 3, 1230, + 615, 0, 6773, 6771, 1, 0, 0, 0, 6773, 6774, 1, 0, 0, 0, 6774, 6784, 1, + 0, 0, 0, 6775, 6776, 5, 1077, 0, 0, 6776, 6781, 3, 1148, 574, 0, 6777, + 6778, 5, 1208, 0, 0, 6778, 6780, 3, 1148, 574, 0, 6779, 6777, 1, 0, 0, + 0, 6780, 6783, 1, 0, 0, 0, 6781, 6779, 1, 0, 0, 0, 6781, 6782, 1, 0, 0, + 0, 6782, 6785, 1, 0, 0, 0, 6783, 6781, 1, 0, 0, 0, 6784, 6775, 1, 0, 0, + 0, 6784, 6785, 1, 0, 0, 0, 6785, 495, 1, 0, 0, 0, 6786, 6788, 5, 199, 0, + 0, 6787, 6789, 5, 1034, 0, 0, 6788, 6787, 1, 0, 0, 0, 6788, 6789, 1, 0, + 0, 0, 6789, 6791, 1, 0, 0, 0, 6790, 6792, 3, 1198, 599, 0, 6791, 6790, + 1, 0, 0, 0, 6791, 6792, 1, 0, 0, 0, 6792, 6793, 1, 0, 0, 0, 6793, 6794, + 5, 456, 0, 0, 6794, 6795, 3, 1230, 615, 0, 6795, 6796, 5, 662, 0, 0, 6796, + 6797, 3, 1170, 585, 0, 6797, 6798, 5, 1206, 0, 0, 6798, 6799, 3, 1184, + 592, 0, 6799, 6805, 5, 1207, 0, 0, 6800, 6801, 5, 452, 0, 0, 6801, 6802, + 5, 1206, 0, 0, 6802, 6803, 3, 1192, 596, 0, 6803, 6804, 5, 1207, 0, 0, + 6804, 6806, 1, 0, 0, 0, 6805, 6800, 1, 0, 0, 0, 6805, 6806, 1, 0, 0, 0, + 6806, 6809, 1, 0, 0, 0, 6807, 6808, 5, 1074, 0, 0, 6808, 6810, 3, 950, + 475, 0, 6809, 6807, 1, 0, 0, 0, 6809, 6810, 1, 0, 0, 0, 6810, 6812, 1, + 0, 0, 0, 6811, 6813, 3, 512, 256, 0, 6812, 6811, 1, 0, 0, 0, 6812, 6813, + 1, 0, 0, 0, 6813, 6816, 1, 0, 0, 0, 6814, 6815, 5, 662, 0, 0, 6815, 6817, + 3, 1230, 615, 0, 6816, 6814, 1, 0, 0, 0, 6816, 6817, 1, 0, 0, 0, 6817, + 6819, 1, 0, 0, 0, 6818, 6820, 5, 1209, 0, 0, 6819, 6818, 1, 0, 0, 0, 6819, + 6820, 1, 0, 0, 0, 6820, 497, 1, 0, 0, 0, 6821, 6822, 5, 199, 0, 0, 6822, + 6823, 5, 929, 0, 0, 6823, 6824, 5, 456, 0, 0, 6824, 6825, 3, 1230, 615, + 0, 6825, 6826, 5, 662, 0, 0, 6826, 6827, 3, 1170, 585, 0, 6827, 6828, 5, + 1206, 0, 0, 6828, 6829, 3, 1230, 615, 0, 6829, 6831, 5, 1207, 0, 0, 6830, + 6832, 3, 500, 250, 0, 6831, 6830, 1, 0, 0, 0, 6831, 6832, 1, 0, 0, 0, 6832, + 6834, 1, 0, 0, 0, 6833, 6835, 3, 502, 251, 0, 6834, 6833, 1, 0, 0, 0, 6834, + 6835, 1, 0, 0, 0, 6835, 6838, 1, 0, 0, 0, 6836, 6837, 5, 662, 0, 0, 6837, + 6839, 3, 1230, 615, 0, 6838, 6836, 1, 0, 0, 0, 6838, 6839, 1, 0, 0, 0, + 6839, 6841, 1, 0, 0, 0, 6840, 6842, 5, 1209, 0, 0, 6841, 6840, 1, 0, 0, + 0, 6841, 6842, 1, 0, 0, 0, 6842, 499, 1, 0, 0, 0, 6843, 6844, 5, 1052, + 0, 0, 6844, 6845, 7, 63, 0, 0, 6845, 501, 1, 0, 0, 0, 6846, 6847, 5, 1077, + 0, 0, 6847, 6848, 5, 1206, 0, 0, 6848, 6853, 3, 504, 252, 0, 6849, 6850, + 5, 1208, 0, 0, 6850, 6852, 3, 504, 252, 0, 6851, 6849, 1, 0, 0, 0, 6852, + 6855, 1, 0, 0, 0, 6853, 6851, 1, 0, 0, 0, 6853, 6854, 1, 0, 0, 0, 6854, + 6856, 1, 0, 0, 0, 6855, 6853, 1, 0, 0, 0, 6856, 6857, 5, 1207, 0, 0, 6857, + 503, 1, 0, 0, 0, 6858, 6859, 5, 102, 0, 0, 6859, 6860, 5, 1188, 0, 0, 6860, + 6861, 5, 1206, 0, 0, 6861, 6862, 3, 506, 253, 0, 6862, 6863, 5, 1208, 0, + 0, 6863, 6864, 3, 506, 253, 0, 6864, 6865, 5, 1208, 0, 0, 6865, 6866, 3, + 506, 253, 0, 6866, 6867, 5, 1208, 0, 0, 6867, 6868, 3, 506, 253, 0, 6868, + 6869, 5, 1207, 0, 0, 6869, 6888, 1, 0, 0, 0, 6870, 6871, 5, 396, 0, 0, + 6871, 6872, 5, 1188, 0, 0, 6872, 6873, 5, 1206, 0, 0, 6873, 6878, 3, 508, + 254, 0, 6874, 6875, 5, 1208, 0, 0, 6875, 6877, 3, 508, 254, 0, 6876, 6874, + 1, 0, 0, 0, 6877, 6880, 1, 0, 0, 0, 6878, 6876, 1, 0, 0, 0, 6878, 6879, + 1, 0, 0, 0, 6879, 6881, 1, 0, 0, 0, 6880, 6878, 1, 0, 0, 0, 6881, 6882, + 5, 1207, 0, 0, 6882, 6888, 1, 0, 0, 0, 6883, 6884, 5, 121, 0, 0, 6884, + 6885, 5, 1188, 0, 0, 6885, 6888, 5, 1182, 0, 0, 6886, 6888, 3, 536, 268, + 0, 6887, 6858, 1, 0, 0, 0, 6887, 6870, 1, 0, 0, 0, 6887, 6883, 1, 0, 0, + 0, 6887, 6886, 1, 0, 0, 0, 6888, 505, 1, 0, 0, 0, 6889, 6891, 5, 1216, + 0, 0, 6890, 6889, 1, 0, 0, 0, 6890, 6891, 1, 0, 0, 0, 6891, 6892, 1, 0, + 0, 0, 6892, 6893, 7, 64, 0, 0, 6893, 507, 1, 0, 0, 0, 6894, 6895, 5, 514, + 0, 0, 6895, 6896, 5, 1188, 0, 0, 6896, 6907, 3, 510, 255, 0, 6897, 6898, + 5, 515, 0, 0, 6898, 6899, 5, 1188, 0, 0, 6899, 6907, 3, 510, 255, 0, 6900, + 6901, 5, 516, 0, 0, 6901, 6902, 5, 1188, 0, 0, 6902, 6907, 3, 510, 255, + 0, 6903, 6904, 5, 517, 0, 0, 6904, 6905, 5, 1188, 0, 0, 6905, 6907, 3, + 510, 255, 0, 6906, 6894, 1, 0, 0, 0, 6906, 6897, 1, 0, 0, 0, 6906, 6900, + 1, 0, 0, 0, 6906, 6903, 1, 0, 0, 0, 6907, 509, 1, 0, 0, 0, 6908, 6909, + 7, 59, 0, 0, 6909, 511, 1, 0, 0, 0, 6910, 6911, 5, 1077, 0, 0, 6911, 6912, + 5, 1206, 0, 0, 6912, 6917, 3, 514, 257, 0, 6913, 6914, 5, 1208, 0, 0, 6914, + 6916, 3, 514, 257, 0, 6915, 6913, 1, 0, 0, 0, 6916, 6919, 1, 0, 0, 0, 6917, + 6915, 1, 0, 0, 0, 6917, 6918, 1, 0, 0, 0, 6918, 6920, 1, 0, 0, 0, 6919, + 6917, 1, 0, 0, 0, 6920, 6921, 5, 1207, 0, 0, 6921, 513, 1, 0, 0, 0, 6922, + 6930, 3, 536, 268, 0, 6923, 6924, 5, 284, 0, 0, 6924, 6925, 5, 1188, 0, + 0, 6925, 6930, 3, 1196, 598, 0, 6926, 6927, 5, 676, 0, 0, 6927, 6928, 5, + 1188, 0, 0, 6928, 6930, 3, 1196, 598, 0, 6929, 6922, 1, 0, 0, 0, 6929, + 6923, 1, 0, 0, 0, 6929, 6926, 1, 0, 0, 0, 6930, 515, 1, 0, 0, 0, 6931, + 6932, 5, 35, 0, 0, 6932, 6935, 5, 456, 0, 0, 6933, 6936, 3, 1230, 615, + 0, 6934, 6936, 5, 22, 0, 0, 6935, 6933, 1, 0, 0, 0, 6935, 6934, 1, 0, 0, + 0, 6936, 6937, 1, 0, 0, 0, 6937, 6938, 5, 662, 0, 0, 6938, 6949, 3, 1170, + 585, 0, 6939, 6950, 5, 270, 0, 0, 6940, 6950, 5, 706, 0, 0, 6941, 6950, + 5, 1, 0, 0, 6942, 6944, 5, 821, 0, 0, 6943, 6945, 3, 518, 259, 0, 6944, + 6943, 1, 0, 0, 0, 6944, 6945, 1, 0, 0, 0, 6945, 6950, 1, 0, 0, 0, 6946, + 6950, 3, 522, 261, 0, 6947, 6950, 3, 528, 264, 0, 6948, 6950, 3, 532, 266, + 0, 6949, 6939, 1, 0, 0, 0, 6949, 6940, 1, 0, 0, 0, 6949, 6941, 1, 0, 0, + 0, 6949, 6942, 1, 0, 0, 0, 6949, 6946, 1, 0, 0, 0, 6949, 6947, 1, 0, 0, + 0, 6949, 6948, 1, 0, 0, 0, 6950, 517, 1, 0, 0, 0, 6951, 6952, 5, 1077, + 0, 0, 6952, 6953, 5, 1206, 0, 0, 6953, 6958, 3, 520, 260, 0, 6954, 6955, + 5, 1208, 0, 0, 6955, 6957, 3, 520, 260, 0, 6956, 6954, 1, 0, 0, 0, 6957, + 6960, 1, 0, 0, 0, 6958, 6956, 1, 0, 0, 0, 6958, 6959, 1, 0, 0, 0, 6959, + 6961, 1, 0, 0, 0, 6960, 6958, 1, 0, 0, 0, 6961, 6962, 5, 1207, 0, 0, 6962, + 519, 1, 0, 0, 0, 6963, 6964, 5, 551, 0, 0, 6964, 6965, 5, 1188, 0, 0, 6965, + 6974, 5, 1182, 0, 0, 6966, 6967, 5, 559, 0, 0, 6967, 6968, 5, 1188, 0, + 0, 6968, 6970, 5, 1182, 0, 0, 6969, 6971, 5, 582, 0, 0, 6970, 6969, 1, + 0, 0, 0, 6970, 6971, 1, 0, 0, 0, 6971, 6974, 1, 0, 0, 0, 6972, 6974, 3, + 618, 309, 0, 6973, 6963, 1, 0, 0, 0, 6973, 6966, 1, 0, 0, 0, 6973, 6972, + 1, 0, 0, 0, 6974, 521, 1, 0, 0, 0, 6975, 6979, 5, 795, 0, 0, 6976, 6977, + 5, 700, 0, 0, 6977, 6978, 5, 1188, 0, 0, 6978, 6980, 5, 1182, 0, 0, 6979, + 6976, 1, 0, 0, 0, 6979, 6980, 1, 0, 0, 0, 6980, 6982, 1, 0, 0, 0, 6981, + 6983, 3, 524, 262, 0, 6982, 6981, 1, 0, 0, 0, 6982, 6983, 1, 0, 0, 0, 6983, + 523, 1, 0, 0, 0, 6984, 6985, 5, 1077, 0, 0, 6985, 6986, 5, 1206, 0, 0, + 6986, 6991, 3, 526, 263, 0, 6987, 6988, 5, 1208, 0, 0, 6988, 6990, 3, 526, + 263, 0, 6989, 6987, 1, 0, 0, 0, 6990, 6993, 1, 0, 0, 0, 6991, 6989, 1, + 0, 0, 0, 6991, 6992, 1, 0, 0, 0, 6992, 6994, 1, 0, 0, 0, 6993, 6991, 1, + 0, 0, 0, 6994, 6995, 5, 1207, 0, 0, 6995, 525, 1, 0, 0, 0, 6996, 6997, + 5, 530, 0, 0, 6997, 6998, 5, 1188, 0, 0, 6998, 7003, 3, 1196, 598, 0, 6999, + 7000, 5, 170, 0, 0, 7000, 7001, 5, 1188, 0, 0, 7001, 7003, 3, 1196, 598, + 0, 7002, 6996, 1, 0, 0, 0, 7002, 6999, 1, 0, 0, 0, 7003, 527, 1, 0, 0, + 0, 7004, 7005, 5, 900, 0, 0, 7005, 7006, 5, 1206, 0, 0, 7006, 7011, 3, + 530, 265, 0, 7007, 7008, 5, 1208, 0, 0, 7008, 7010, 3, 530, 265, 0, 7009, + 7007, 1, 0, 0, 0, 7010, 7013, 1, 0, 0, 0, 7011, 7009, 1, 0, 0, 0, 7011, + 7012, 1, 0, 0, 0, 7012, 7014, 1, 0, 0, 0, 7013, 7011, 1, 0, 0, 0, 7014, + 7015, 5, 1207, 0, 0, 7015, 529, 1, 0, 0, 0, 7016, 7017, 5, 28, 0, 0, 7017, + 7018, 5, 1188, 0, 0, 7018, 7038, 3, 1196, 598, 0, 7019, 7020, 5, 27, 0, + 0, 7020, 7021, 5, 1188, 0, 0, 7021, 7038, 3, 1196, 598, 0, 7022, 7023, + 5, 676, 0, 0, 7023, 7024, 5, 1188, 0, 0, 7024, 7038, 3, 1196, 598, 0, 7025, + 7026, 5, 442, 0, 0, 7026, 7027, 5, 1188, 0, 0, 7027, 7038, 3, 1196, 598, + 0, 7028, 7029, 5, 947, 0, 0, 7029, 7030, 5, 1188, 0, 0, 7030, 7038, 3, + 1196, 598, 0, 7031, 7032, 5, 169, 0, 0, 7032, 7033, 5, 1188, 0, 0, 7033, + 7035, 5, 1182, 0, 0, 7034, 7036, 5, 582, 0, 0, 7035, 7034, 1, 0, 0, 0, + 7035, 7036, 1, 0, 0, 0, 7036, 7038, 1, 0, 0, 0, 7037, 7016, 1, 0, 0, 0, + 7037, 7019, 1, 0, 0, 0, 7037, 7022, 1, 0, 0, 0, 7037, 7025, 1, 0, 0, 0, + 7037, 7028, 1, 0, 0, 0, 7037, 7031, 1, 0, 0, 0, 7038, 531, 1, 0, 0, 0, + 7039, 7043, 5, 780, 0, 0, 7040, 7041, 5, 700, 0, 0, 7041, 7042, 5, 1188, + 0, 0, 7042, 7044, 5, 22, 0, 0, 7043, 7040, 1, 0, 0, 0, 7043, 7044, 1, 0, + 0, 0, 7044, 7046, 1, 0, 0, 0, 7045, 7047, 3, 534, 267, 0, 7046, 7045, 1, + 0, 0, 0, 7046, 7047, 1, 0, 0, 0, 7047, 7056, 1, 0, 0, 0, 7048, 7049, 5, + 780, 0, 0, 7049, 7050, 5, 700, 0, 0, 7050, 7051, 5, 1188, 0, 0, 7051, 7053, + 5, 1182, 0, 0, 7052, 7054, 3, 538, 269, 0, 7053, 7052, 1, 0, 0, 0, 7053, + 7054, 1, 0, 0, 0, 7054, 7056, 1, 0, 0, 0, 7055, 7039, 1, 0, 0, 0, 7055, + 7048, 1, 0, 0, 0, 7056, 533, 1, 0, 0, 0, 7057, 7058, 5, 1077, 0, 0, 7058, + 7059, 5, 1206, 0, 0, 7059, 7064, 3, 536, 268, 0, 7060, 7061, 5, 1208, 0, + 0, 7061, 7063, 3, 536, 268, 0, 7062, 7060, 1, 0, 0, 0, 7063, 7066, 1, 0, + 0, 0, 7064, 7062, 1, 0, 0, 0, 7064, 7065, 1, 0, 0, 0, 7065, 7067, 1, 0, + 0, 0, 7066, 7064, 1, 0, 0, 0, 7067, 7068, 5, 1207, 0, 0, 7068, 535, 1, + 0, 0, 0, 7069, 7070, 5, 689, 0, 0, 7070, 7071, 5, 1188, 0, 0, 7071, 7130, + 3, 1196, 598, 0, 7072, 7073, 5, 359, 0, 0, 7073, 7074, 5, 1188, 0, 0, 7074, + 7130, 5, 1182, 0, 0, 7075, 7076, 5, 924, 0, 0, 7076, 7077, 5, 1188, 0, + 0, 7077, 7130, 3, 1196, 598, 0, 7078, 7079, 5, 442, 0, 0, 7079, 7080, 5, + 1188, 0, 0, 7080, 7130, 3, 1196, 598, 0, 7081, 7082, 5, 947, 0, 0, 7082, + 7083, 5, 1188, 0, 0, 7083, 7130, 3, 1196, 598, 0, 7084, 7085, 5, 946, 0, + 0, 7085, 7086, 5, 1188, 0, 0, 7086, 7130, 3, 1196, 598, 0, 7087, 7088, + 5, 663, 0, 0, 7088, 7097, 5, 1188, 0, 0, 7089, 7094, 5, 662, 0, 0, 7090, + 7091, 5, 1206, 0, 0, 7091, 7092, 3, 618, 309, 0, 7092, 7093, 5, 1207, 0, + 0, 7093, 7095, 1, 0, 0, 0, 7094, 7090, 1, 0, 0, 0, 7094, 7095, 1, 0, 0, + 0, 7095, 7098, 1, 0, 0, 0, 7096, 7098, 5, 656, 0, 0, 7097, 7089, 1, 0, + 0, 0, 7097, 7096, 1, 0, 0, 0, 7098, 7130, 1, 0, 0, 0, 7099, 7100, 5, 820, + 0, 0, 7100, 7101, 5, 1188, 0, 0, 7101, 7130, 3, 1196, 598, 0, 7102, 7103, + 5, 559, 0, 0, 7103, 7104, 5, 1188, 0, 0, 7104, 7106, 5, 1182, 0, 0, 7105, + 7107, 5, 582, 0, 0, 7106, 7105, 1, 0, 0, 0, 7106, 7107, 1, 0, 0, 0, 7107, + 7130, 1, 0, 0, 0, 7108, 7109, 5, 28, 0, 0, 7109, 7110, 5, 1188, 0, 0, 7110, + 7130, 3, 1196, 598, 0, 7111, 7112, 5, 27, 0, 0, 7112, 7113, 5, 1188, 0, + 0, 7113, 7130, 3, 1196, 598, 0, 7114, 7115, 5, 551, 0, 0, 7115, 7116, 5, + 1188, 0, 0, 7116, 7130, 5, 1182, 0, 0, 7117, 7118, 5, 225, 0, 0, 7118, + 7119, 5, 1188, 0, 0, 7119, 7121, 7, 65, 0, 0, 7120, 7122, 3, 542, 271, + 0, 7121, 7120, 1, 0, 0, 0, 7121, 7122, 1, 0, 0, 0, 7122, 7130, 1, 0, 0, + 0, 7123, 7124, 5, 1092, 0, 0, 7124, 7125, 5, 1188, 0, 0, 7125, 7127, 3, + 1196, 598, 0, 7126, 7128, 3, 542, 271, 0, 7127, 7126, 1, 0, 0, 0, 7127, + 7128, 1, 0, 0, 0, 7128, 7130, 1, 0, 0, 0, 7129, 7069, 1, 0, 0, 0, 7129, + 7072, 1, 0, 0, 0, 7129, 7075, 1, 0, 0, 0, 7129, 7078, 1, 0, 0, 0, 7129, + 7081, 1, 0, 0, 0, 7129, 7084, 1, 0, 0, 0, 7129, 7087, 1, 0, 0, 0, 7129, + 7099, 1, 0, 0, 0, 7129, 7102, 1, 0, 0, 0, 7129, 7108, 1, 0, 0, 0, 7129, + 7111, 1, 0, 0, 0, 7129, 7114, 1, 0, 0, 0, 7129, 7117, 1, 0, 0, 0, 7129, + 7123, 1, 0, 0, 0, 7130, 537, 1, 0, 0, 0, 7131, 7132, 5, 1077, 0, 0, 7132, + 7133, 5, 1206, 0, 0, 7133, 7138, 3, 540, 270, 0, 7134, 7135, 5, 1208, 0, + 0, 7135, 7137, 3, 540, 270, 0, 7136, 7134, 1, 0, 0, 0, 7137, 7140, 1, 0, + 0, 0, 7138, 7136, 1, 0, 0, 0, 7138, 7139, 1, 0, 0, 0, 7139, 7141, 1, 0, + 0, 0, 7140, 7138, 1, 0, 0, 0, 7141, 7142, 5, 1207, 0, 0, 7142, 539, 1, + 0, 0, 0, 7143, 7144, 5, 924, 0, 0, 7144, 7145, 5, 1188, 0, 0, 7145, 7177, + 3, 1196, 598, 0, 7146, 7147, 5, 551, 0, 0, 7147, 7148, 5, 1188, 0, 0, 7148, + 7177, 5, 1182, 0, 0, 7149, 7150, 5, 820, 0, 0, 7150, 7151, 5, 1188, 0, + 0, 7151, 7177, 3, 1196, 598, 0, 7152, 7153, 5, 225, 0, 0, 7153, 7154, 5, + 1188, 0, 0, 7154, 7156, 7, 65, 0, 0, 7155, 7157, 3, 542, 271, 0, 7156, + 7155, 1, 0, 0, 0, 7156, 7157, 1, 0, 0, 0, 7157, 7177, 1, 0, 0, 0, 7158, + 7159, 5, 1092, 0, 0, 7159, 7160, 5, 1188, 0, 0, 7160, 7162, 3, 1196, 598, + 0, 7161, 7163, 3, 542, 271, 0, 7162, 7161, 1, 0, 0, 0, 7162, 7163, 1, 0, + 0, 0, 7163, 7177, 1, 0, 0, 0, 7164, 7165, 5, 663, 0, 0, 7165, 7174, 5, + 1188, 0, 0, 7166, 7171, 5, 662, 0, 0, 7167, 7168, 5, 1206, 0, 0, 7168, + 7169, 3, 618, 309, 0, 7169, 7170, 5, 1207, 0, 0, 7170, 7172, 1, 0, 0, 0, + 7171, 7167, 1, 0, 0, 0, 7171, 7172, 1, 0, 0, 0, 7172, 7175, 1, 0, 0, 0, + 7173, 7175, 5, 656, 0, 0, 7174, 7166, 1, 0, 0, 0, 7174, 7173, 1, 0, 0, + 0, 7175, 7177, 1, 0, 0, 0, 7176, 7143, 1, 0, 0, 0, 7176, 7146, 1, 0, 0, + 0, 7176, 7149, 1, 0, 0, 0, 7176, 7152, 1, 0, 0, 0, 7176, 7158, 1, 0, 0, + 0, 7176, 7164, 1, 0, 0, 0, 7177, 541, 1, 0, 0, 0, 7178, 7179, 5, 662, 0, + 0, 7179, 7180, 5, 701, 0, 0, 7180, 7181, 5, 1206, 0, 0, 7181, 7184, 5, + 1182, 0, 0, 7182, 7183, 5, 1000, 0, 0, 7183, 7185, 5, 1182, 0, 0, 7184, + 7182, 1, 0, 0, 0, 7184, 7185, 1, 0, 0, 0, 7185, 7194, 1, 0, 0, 0, 7186, + 7187, 5, 1208, 0, 0, 7187, 7190, 5, 1182, 0, 0, 7188, 7189, 5, 1000, 0, + 0, 7189, 7191, 5, 1182, 0, 0, 7190, 7188, 1, 0, 0, 0, 7190, 7191, 1, 0, + 0, 0, 7191, 7193, 1, 0, 0, 0, 7192, 7186, 1, 0, 0, 0, 7193, 7196, 1, 0, + 0, 0, 7194, 7192, 1, 0, 0, 0, 7194, 7195, 1, 0, 0, 0, 7195, 7197, 1, 0, + 0, 0, 7196, 7194, 1, 0, 0, 0, 7197, 7198, 5, 1207, 0, 0, 7198, 543, 1, + 0, 0, 0, 7199, 7200, 5, 199, 0, 0, 7200, 7201, 5, 151, 0, 0, 7201, 7202, + 5, 158, 0, 0, 7202, 7203, 5, 456, 0, 0, 7203, 7204, 3, 1230, 615, 0, 7204, + 7205, 5, 662, 0, 0, 7205, 7207, 3, 1170, 585, 0, 7206, 7208, 3, 546, 273, + 0, 7207, 7206, 1, 0, 0, 0, 7207, 7208, 1, 0, 0, 0, 7208, 7211, 1, 0, 0, + 0, 7209, 7210, 5, 662, 0, 0, 7210, 7212, 3, 1230, 615, 0, 7211, 7209, 1, + 0, 0, 0, 7211, 7212, 1, 0, 0, 0, 7212, 7214, 1, 0, 0, 0, 7213, 7215, 5, + 1209, 0, 0, 7214, 7213, 1, 0, 0, 0, 7214, 7215, 1, 0, 0, 0, 7215, 545, + 1, 0, 0, 0, 7216, 7217, 5, 1077, 0, 0, 7217, 7218, 5, 1206, 0, 0, 7218, + 7223, 3, 548, 274, 0, 7219, 7220, 5, 1208, 0, 0, 7220, 7222, 3, 548, 274, + 0, 7221, 7219, 1, 0, 0, 0, 7222, 7225, 1, 0, 0, 0, 7223, 7221, 1, 0, 0, + 0, 7223, 7224, 1, 0, 0, 0, 7224, 7226, 1, 0, 0, 0, 7225, 7223, 1, 0, 0, + 0, 7226, 7227, 5, 1207, 0, 0, 7227, 547, 1, 0, 0, 0, 7228, 7229, 5, 284, + 0, 0, 7229, 7230, 5, 1188, 0, 0, 7230, 7250, 3, 1196, 598, 0, 7231, 7232, + 5, 551, 0, 0, 7232, 7233, 5, 1188, 0, 0, 7233, 7250, 5, 1182, 0, 0, 7234, + 7235, 5, 663, 0, 0, 7235, 7236, 5, 1188, 0, 0, 7236, 7250, 3, 1196, 598, + 0, 7237, 7238, 5, 169, 0, 0, 7238, 7239, 5, 1188, 0, 0, 7239, 7241, 5, + 1182, 0, 0, 7240, 7242, 5, 582, 0, 0, 7241, 7240, 1, 0, 0, 0, 7241, 7242, + 1, 0, 0, 0, 7242, 7250, 1, 0, 0, 0, 7243, 7244, 5, 225, 0, 0, 7244, 7245, + 5, 1188, 0, 0, 7245, 7247, 7, 66, 0, 0, 7246, 7248, 3, 542, 271, 0, 7247, + 7246, 1, 0, 0, 0, 7247, 7248, 1, 0, 0, 0, 7248, 7250, 1, 0, 0, 0, 7249, + 7228, 1, 0, 0, 0, 7249, 7231, 1, 0, 0, 0, 7249, 7234, 1, 0, 0, 0, 7249, + 7237, 1, 0, 0, 0, 7249, 7243, 1, 0, 0, 0, 7250, 549, 1, 0, 0, 0, 7251, + 7253, 5, 199, 0, 0, 7252, 7254, 5, 620, 0, 0, 7253, 7252, 1, 0, 0, 0, 7253, + 7254, 1, 0, 0, 0, 7254, 7255, 1, 0, 0, 0, 7255, 7256, 5, 158, 0, 0, 7256, + 7257, 5, 456, 0, 0, 7257, 7258, 3, 1230, 615, 0, 7258, 7259, 5, 662, 0, + 0, 7259, 7260, 3, 1170, 585, 0, 7260, 7261, 5, 1206, 0, 0, 7261, 7262, + 3, 1184, 592, 0, 7262, 7265, 5, 1207, 0, 0, 7263, 7264, 5, 1074, 0, 0, + 7264, 7266, 3, 950, 475, 0, 7265, 7263, 1, 0, 0, 0, 7265, 7266, 1, 0, 0, + 0, 7266, 7268, 1, 0, 0, 0, 7267, 7269, 3, 546, 273, 0, 7268, 7267, 1, 0, + 0, 0, 7268, 7269, 1, 0, 0, 0, 7269, 7272, 1, 0, 0, 0, 7270, 7271, 5, 662, + 0, 0, 7271, 7273, 3, 1230, 615, 0, 7272, 7270, 1, 0, 0, 0, 7272, 7273, + 1, 0, 0, 0, 7273, 7275, 1, 0, 0, 0, 7274, 7276, 5, 1209, 0, 0, 7275, 7274, + 1, 0, 0, 0, 7275, 7276, 1, 0, 0, 0, 7276, 551, 1, 0, 0, 0, 7277, 7279, + 5, 199, 0, 0, 7278, 7280, 5, 730, 0, 0, 7279, 7278, 1, 0, 0, 0, 7279, 7280, + 1, 0, 0, 0, 7280, 7281, 1, 0, 0, 0, 7281, 7282, 5, 1088, 0, 0, 7282, 7283, + 5, 456, 0, 0, 7283, 7284, 3, 1230, 615, 0, 7284, 7285, 5, 662, 0, 0, 7285, + 7286, 3, 1170, 585, 0, 7286, 7287, 5, 1206, 0, 0, 7287, 7288, 3, 1230, + 615, 0, 7288, 7299, 5, 1207, 0, 0, 7289, 7290, 5, 1052, 0, 0, 7290, 7291, + 5, 1088, 0, 0, 7291, 7292, 5, 456, 0, 0, 7292, 7297, 3, 1230, 615, 0, 7293, + 7295, 5, 365, 0, 0, 7294, 7296, 7, 67, 0, 0, 7295, 7294, 1, 0, 0, 0, 7295, + 7296, 1, 0, 0, 0, 7296, 7298, 1, 0, 0, 0, 7297, 7293, 1, 0, 0, 0, 7297, + 7298, 1, 0, 0, 0, 7298, 7300, 1, 0, 0, 0, 7299, 7289, 1, 0, 0, 0, 7299, + 7300, 1, 0, 0, 0, 7300, 7302, 1, 0, 0, 0, 7301, 7303, 3, 554, 277, 0, 7302, + 7301, 1, 0, 0, 0, 7302, 7303, 1, 0, 0, 0, 7303, 7305, 1, 0, 0, 0, 7304, + 7306, 5, 1209, 0, 0, 7305, 7304, 1, 0, 0, 0, 7305, 7306, 1, 0, 0, 0, 7306, + 553, 1, 0, 0, 0, 7307, 7308, 5, 1077, 0, 0, 7308, 7309, 5, 1206, 0, 0, + 7309, 7314, 3, 556, 278, 0, 7310, 7311, 5, 1208, 0, 0, 7311, 7313, 3, 556, + 278, 0, 7312, 7310, 1, 0, 0, 0, 7313, 7316, 1, 0, 0, 0, 7314, 7312, 1, + 0, 0, 0, 7314, 7315, 1, 0, 0, 0, 7315, 7317, 1, 0, 0, 0, 7316, 7314, 1, + 0, 0, 0, 7317, 7318, 5, 1207, 0, 0, 7318, 555, 1, 0, 0, 0, 7319, 7320, + 5, 689, 0, 0, 7320, 7321, 5, 1188, 0, 0, 7321, 7359, 3, 1196, 598, 0, 7322, + 7323, 5, 359, 0, 0, 7323, 7324, 5, 1188, 0, 0, 7324, 7359, 5, 1182, 0, + 0, 7325, 7326, 5, 924, 0, 0, 7326, 7327, 5, 1188, 0, 0, 7327, 7359, 3, + 1196, 598, 0, 7328, 7329, 5, 442, 0, 0, 7329, 7330, 5, 1188, 0, 0, 7330, + 7359, 3, 1196, 598, 0, 7331, 7332, 5, 284, 0, 0, 7332, 7333, 5, 1188, 0, + 0, 7333, 7359, 3, 1196, 598, 0, 7334, 7335, 5, 663, 0, 0, 7335, 7344, 5, + 1188, 0, 0, 7336, 7341, 5, 662, 0, 0, 7337, 7338, 5, 1206, 0, 0, 7338, + 7339, 3, 618, 309, 0, 7339, 7340, 5, 1207, 0, 0, 7340, 7342, 1, 0, 0, 0, + 7341, 7337, 1, 0, 0, 0, 7341, 7342, 1, 0, 0, 0, 7342, 7345, 1, 0, 0, 0, + 7343, 7345, 5, 656, 0, 0, 7344, 7336, 1, 0, 0, 0, 7344, 7343, 1, 0, 0, + 0, 7345, 7359, 1, 0, 0, 0, 7346, 7347, 5, 28, 0, 0, 7347, 7348, 5, 1188, + 0, 0, 7348, 7359, 3, 1196, 598, 0, 7349, 7350, 5, 27, 0, 0, 7350, 7351, + 5, 1188, 0, 0, 7351, 7359, 3, 1196, 598, 0, 7352, 7353, 5, 551, 0, 0, 7353, + 7354, 5, 1188, 0, 0, 7354, 7359, 5, 1182, 0, 0, 7355, 7356, 5, 1092, 0, + 0, 7356, 7357, 5, 1188, 0, 0, 7357, 7359, 3, 1196, 598, 0, 7358, 7319, + 1, 0, 0, 0, 7358, 7322, 1, 0, 0, 0, 7358, 7325, 1, 0, 0, 0, 7358, 7328, + 1, 0, 0, 0, 7358, 7331, 1, 0, 0, 0, 7358, 7334, 1, 0, 0, 0, 7358, 7346, + 1, 0, 0, 0, 7358, 7349, 1, 0, 0, 0, 7358, 7352, 1, 0, 0, 0, 7358, 7355, + 1, 0, 0, 0, 7359, 557, 1, 0, 0, 0, 7360, 7363, 5, 199, 0, 0, 7361, 7362, + 5, 678, 0, 0, 7362, 7364, 7, 68, 0, 0, 7363, 7361, 1, 0, 0, 0, 7363, 7364, + 1, 0, 0, 0, 7364, 7367, 1, 0, 0, 0, 7365, 7367, 5, 35, 0, 0, 7366, 7360, + 1, 0, 0, 0, 7366, 7365, 1, 0, 0, 0, 7367, 7368, 1, 0, 0, 0, 7368, 7369, + 7, 69, 0, 0, 7369, 7372, 3, 1174, 587, 0, 7370, 7371, 5, 1209, 0, 0, 7371, + 7373, 5, 1182, 0, 0, 7372, 7370, 1, 0, 0, 0, 7372, 7373, 1, 0, 0, 0, 7373, + 7388, 1, 0, 0, 0, 7374, 7376, 5, 1206, 0, 0, 7375, 7374, 1, 0, 0, 0, 7375, + 7376, 1, 0, 0, 0, 7376, 7377, 1, 0, 0, 0, 7377, 7382, 3, 584, 292, 0, 7378, + 7379, 5, 1208, 0, 0, 7379, 7381, 3, 584, 292, 0, 7380, 7378, 1, 0, 0, 0, + 7381, 7384, 1, 0, 0, 0, 7382, 7380, 1, 0, 0, 0, 7382, 7383, 1, 0, 0, 0, + 7383, 7386, 1, 0, 0, 0, 7384, 7382, 1, 0, 0, 0, 7385, 7387, 5, 1207, 0, + 0, 7386, 7385, 1, 0, 0, 0, 7386, 7387, 1, 0, 0, 0, 7387, 7389, 1, 0, 0, + 0, 7388, 7375, 1, 0, 0, 0, 7388, 7389, 1, 0, 0, 0, 7389, 7399, 1, 0, 0, + 0, 7390, 7391, 5, 1077, 0, 0, 7391, 7396, 3, 586, 293, 0, 7392, 7393, 5, + 1208, 0, 0, 7393, 7395, 3, 586, 293, 0, 7394, 7392, 1, 0, 0, 0, 7395, 7398, + 1, 0, 0, 0, 7396, 7394, 1, 0, 0, 0, 7396, 7397, 1, 0, 0, 0, 7397, 7400, + 1, 0, 0, 0, 7398, 7396, 1, 0, 0, 0, 7399, 7390, 1, 0, 0, 0, 7399, 7400, + 1, 0, 0, 0, 7400, 7403, 1, 0, 0, 0, 7401, 7402, 5, 365, 0, 0, 7402, 7404, + 5, 804, 0, 0, 7403, 7401, 1, 0, 0, 0, 7403, 7404, 1, 0, 0, 0, 7404, 7405, + 1, 0, 0, 0, 7405, 7413, 5, 56, 0, 0, 7406, 7414, 3, 560, 280, 0, 7407, + 7409, 3, 6, 3, 0, 7408, 7407, 1, 0, 0, 0, 7409, 7412, 1, 0, 0, 0, 7410, + 7408, 1, 0, 0, 0, 7410, 7411, 1, 0, 0, 0, 7411, 7414, 1, 0, 0, 0, 7412, + 7410, 1, 0, 0, 0, 7413, 7406, 1, 0, 0, 0, 7413, 7410, 1, 0, 0, 0, 7414, + 559, 1, 0, 0, 0, 7415, 7416, 5, 331, 0, 0, 7416, 7417, 5, 597, 0, 0, 7417, + 7418, 3, 1230, 615, 0, 7418, 7419, 5, 1201, 0, 0, 7419, 7420, 3, 1230, + 615, 0, 7420, 7421, 5, 1201, 0, 0, 7421, 7422, 3, 1230, 615, 0, 7422, 561, + 1, 0, 0, 0, 7423, 7426, 3, 564, 282, 0, 7424, 7426, 3, 570, 285, 0, 7425, + 7423, 1, 0, 0, 0, 7425, 7424, 1, 0, 0, 0, 7426, 563, 1, 0, 0, 0, 7427, + 7430, 5, 199, 0, 0, 7428, 7429, 5, 678, 0, 0, 7429, 7431, 7, 68, 0, 0, + 7430, 7428, 1, 0, 0, 0, 7430, 7431, 1, 0, 0, 0, 7431, 7434, 1, 0, 0, 0, + 7432, 7434, 5, 35, 0, 0, 7433, 7427, 1, 0, 0, 0, 7433, 7432, 1, 0, 0, 0, + 7434, 7435, 1, 0, 0, 0, 7435, 7436, 5, 1013, 0, 0, 7436, 7437, 3, 1172, + 586, 0, 7437, 7438, 5, 662, 0, 0, 7438, 7448, 3, 1170, 585, 0, 7439, 7440, + 5, 1077, 0, 0, 7440, 7445, 3, 566, 283, 0, 7441, 7442, 5, 1208, 0, 0, 7442, + 7444, 3, 566, 283, 0, 7443, 7441, 1, 0, 0, 0, 7444, 7447, 1, 0, 0, 0, 7445, + 7443, 1, 0, 0, 0, 7445, 7446, 1, 0, 0, 0, 7446, 7449, 1, 0, 0, 0, 7447, + 7445, 1, 0, 0, 0, 7448, 7439, 1, 0, 0, 0, 7448, 7449, 1, 0, 0, 0, 7449, + 7454, 1, 0, 0, 0, 7450, 7455, 5, 365, 0, 0, 7451, 7455, 5, 19, 0, 0, 7452, + 7453, 5, 468, 0, 0, 7453, 7455, 5, 655, 0, 0, 7454, 7450, 1, 0, 0, 0, 7454, + 7451, 1, 0, 0, 0, 7454, 7452, 1, 0, 0, 0, 7455, 7456, 1, 0, 0, 0, 7456, + 7461, 3, 568, 284, 0, 7457, 7458, 5, 1208, 0, 0, 7458, 7460, 3, 568, 284, + 0, 7459, 7457, 1, 0, 0, 0, 7460, 7463, 1, 0, 0, 0, 7461, 7459, 1, 0, 0, + 0, 7461, 7462, 1, 0, 0, 0, 7462, 7466, 1, 0, 0, 0, 7463, 7461, 1, 0, 0, + 0, 7464, 7465, 5, 1077, 0, 0, 7465, 7467, 5, 47, 0, 0, 7466, 7464, 1, 0, + 0, 0, 7466, 7467, 1, 0, 0, 0, 7467, 7471, 1, 0, 0, 0, 7468, 7469, 5, 627, + 0, 0, 7469, 7470, 5, 365, 0, 0, 7470, 7472, 5, 804, 0, 0, 7471, 7468, 1, + 0, 0, 0, 7471, 7472, 1, 0, 0, 0, 7472, 7473, 1, 0, 0, 0, 7473, 7475, 5, + 56, 0, 0, 7474, 7476, 3, 6, 3, 0, 7475, 7474, 1, 0, 0, 0, 7476, 7477, 1, + 0, 0, 0, 7477, 7475, 1, 0, 0, 0, 7477, 7478, 1, 0, 0, 0, 7478, 565, 1, + 0, 0, 0, 7479, 7482, 5, 297, 0, 0, 7480, 7482, 3, 864, 432, 0, 7481, 7479, + 1, 0, 0, 0, 7481, 7480, 1, 0, 0, 0, 7482, 567, 1, 0, 0, 0, 7483, 7484, + 7, 70, 0, 0, 7484, 569, 1, 0, 0, 0, 7485, 7488, 5, 199, 0, 0, 7486, 7487, + 5, 678, 0, 0, 7487, 7489, 7, 68, 0, 0, 7488, 7486, 1, 0, 0, 0, 7488, 7489, + 1, 0, 0, 0, 7489, 7492, 1, 0, 0, 0, 7490, 7492, 5, 35, 0, 0, 7491, 7485, + 1, 0, 0, 0, 7491, 7490, 1, 0, 0, 0, 7492, 7493, 1, 0, 0, 0, 7493, 7494, + 5, 1013, 0, 0, 7494, 7495, 3, 1172, 586, 0, 7495, 7499, 5, 662, 0, 0, 7496, + 7497, 5, 22, 0, 0, 7497, 7500, 5, 889, 0, 0, 7498, 7500, 5, 219, 0, 0, + 7499, 7496, 1, 0, 0, 0, 7499, 7498, 1, 0, 0, 0, 7500, 7510, 1, 0, 0, 0, + 7501, 7502, 5, 1077, 0, 0, 7502, 7507, 3, 566, 283, 0, 7503, 7504, 5, 1208, + 0, 0, 7504, 7506, 3, 566, 283, 0, 7505, 7503, 1, 0, 0, 0, 7506, 7509, 1, + 0, 0, 0, 7507, 7505, 1, 0, 0, 0, 7507, 7508, 1, 0, 0, 0, 7508, 7511, 1, + 0, 0, 0, 7509, 7507, 1, 0, 0, 0, 7510, 7501, 1, 0, 0, 0, 7510, 7511, 1, + 0, 0, 0, 7511, 7512, 1, 0, 0, 0, 7512, 7513, 7, 71, 0, 0, 7513, 7518, 3, + 572, 286, 0, 7514, 7515, 5, 1208, 0, 0, 7515, 7517, 3, 572, 286, 0, 7516, + 7514, 1, 0, 0, 0, 7517, 7520, 1, 0, 0, 0, 7518, 7516, 1, 0, 0, 0, 7518, + 7519, 1, 0, 0, 0, 7519, 7521, 1, 0, 0, 0, 7520, 7518, 1, 0, 0, 0, 7521, + 7523, 5, 56, 0, 0, 7522, 7524, 3, 6, 3, 0, 7523, 7522, 1, 0, 0, 0, 7524, + 7525, 1, 0, 0, 0, 7525, 7523, 1, 0, 0, 0, 7525, 7526, 1, 0, 0, 0, 7526, + 571, 1, 0, 0, 0, 7527, 7528, 3, 1232, 616, 0, 7528, 573, 1, 0, 0, 0, 7529, + 7532, 5, 199, 0, 0, 7530, 7531, 5, 678, 0, 0, 7531, 7533, 5, 35, 0, 0, + 7532, 7530, 1, 0, 0, 0, 7532, 7533, 1, 0, 0, 0, 7533, 7536, 1, 0, 0, 0, + 7534, 7536, 5, 35, 0, 0, 7535, 7529, 1, 0, 0, 0, 7535, 7534, 1, 0, 0, 0, + 7536, 7537, 1, 0, 0, 0, 7537, 7538, 5, 386, 0, 0, 7538, 7552, 3, 1174, + 587, 0, 7539, 7540, 5, 1206, 0, 0, 7540, 7545, 3, 584, 292, 0, 7541, 7542, + 5, 1208, 0, 0, 7542, 7544, 3, 584, 292, 0, 7543, 7541, 1, 0, 0, 0, 7544, + 7547, 1, 0, 0, 0, 7545, 7543, 1, 0, 0, 0, 7545, 7546, 1, 0, 0, 0, 7546, + 7548, 1, 0, 0, 0, 7547, 7545, 1, 0, 0, 0, 7548, 7549, 5, 1207, 0, 0, 7549, + 7553, 1, 0, 0, 0, 7550, 7551, 5, 1206, 0, 0, 7551, 7553, 5, 1207, 0, 0, + 7552, 7539, 1, 0, 0, 0, 7552, 7550, 1, 0, 0, 0, 7553, 7557, 1, 0, 0, 0, + 7554, 7558, 3, 576, 288, 0, 7555, 7558, 3, 578, 289, 0, 7556, 7558, 3, + 580, 290, 0, 7557, 7554, 1, 0, 0, 0, 7557, 7555, 1, 0, 0, 0, 7557, 7556, + 1, 0, 0, 0, 7558, 7560, 1, 0, 0, 0, 7559, 7561, 5, 1209, 0, 0, 7560, 7559, + 1, 0, 0, 0, 7560, 7561, 1, 0, 0, 0, 7561, 575, 1, 0, 0, 0, 7562, 7563, + 5, 825, 0, 0, 7563, 7573, 5, 980, 0, 0, 7564, 7565, 5, 1077, 0, 0, 7565, + 7570, 3, 588, 294, 0, 7566, 7567, 5, 1208, 0, 0, 7567, 7569, 3, 588, 294, + 0, 7568, 7566, 1, 0, 0, 0, 7569, 7572, 1, 0, 0, 0, 7570, 7568, 1, 0, 0, + 0, 7570, 7571, 1, 0, 0, 0, 7571, 7574, 1, 0, 0, 0, 7572, 7570, 1, 0, 0, + 0, 7573, 7564, 1, 0, 0, 0, 7573, 7574, 1, 0, 0, 0, 7574, 7576, 1, 0, 0, + 0, 7575, 7577, 5, 56, 0, 0, 7576, 7575, 1, 0, 0, 0, 7576, 7577, 1, 0, 0, + 0, 7577, 7587, 1, 0, 0, 0, 7578, 7588, 3, 560, 280, 0, 7579, 7585, 5, 824, + 0, 0, 7580, 7581, 5, 1206, 0, 0, 7581, 7582, 3, 482, 241, 0, 7582, 7583, + 5, 1207, 0, 0, 7583, 7586, 1, 0, 0, 0, 7584, 7586, 3, 482, 241, 0, 7585, + 7580, 1, 0, 0, 0, 7585, 7584, 1, 0, 0, 0, 7586, 7588, 1, 0, 0, 0, 7587, + 7578, 1, 0, 0, 0, 7587, 7579, 1, 0, 0, 0, 7588, 577, 1, 0, 0, 0, 7589, + 7590, 5, 825, 0, 0, 7590, 7591, 5, 1180, 0, 0, 7591, 7601, 3, 868, 434, + 0, 7592, 7593, 5, 1077, 0, 0, 7593, 7598, 3, 588, 294, 0, 7594, 7595, 5, + 1208, 0, 0, 7595, 7597, 3, 588, 294, 0, 7596, 7594, 1, 0, 0, 0, 7597, 7600, + 1, 0, 0, 0, 7598, 7596, 1, 0, 0, 0, 7598, 7599, 1, 0, 0, 0, 7599, 7602, + 1, 0, 0, 0, 7600, 7598, 1, 0, 0, 0, 7601, 7592, 1, 0, 0, 0, 7601, 7602, + 1, 0, 0, 0, 7602, 7604, 1, 0, 0, 0, 7603, 7605, 5, 56, 0, 0, 7604, 7603, + 1, 0, 0, 0, 7604, 7605, 1, 0, 0, 0, 7605, 7622, 1, 0, 0, 0, 7606, 7623, + 3, 560, 280, 0, 7607, 7611, 5, 90, 0, 0, 7608, 7610, 3, 6, 3, 0, 7609, + 7608, 1, 0, 0, 0, 7610, 7613, 1, 0, 0, 0, 7611, 7609, 1, 0, 0, 0, 7611, + 7612, 1, 0, 0, 0, 7612, 7614, 1, 0, 0, 0, 7613, 7611, 1, 0, 0, 0, 7614, + 7616, 5, 824, 0, 0, 7615, 7617, 5, 1209, 0, 0, 7616, 7615, 1, 0, 0, 0, + 7616, 7617, 1, 0, 0, 0, 7617, 7618, 1, 0, 0, 0, 7618, 7620, 5, 299, 0, + 0, 7619, 7621, 5, 1209, 0, 0, 7620, 7619, 1, 0, 0, 0, 7620, 7621, 1, 0, + 0, 0, 7621, 7623, 1, 0, 0, 0, 7622, 7606, 1, 0, 0, 0, 7622, 7607, 1, 0, + 0, 0, 7623, 579, 1, 0, 0, 0, 7624, 7625, 5, 825, 0, 0, 7625, 7635, 3, 1222, + 611, 0, 7626, 7627, 5, 1077, 0, 0, 7627, 7632, 3, 588, 294, 0, 7628, 7629, + 5, 1208, 0, 0, 7629, 7631, 3, 588, 294, 0, 7630, 7628, 1, 0, 0, 0, 7631, + 7634, 1, 0, 0, 0, 7632, 7630, 1, 0, 0, 0, 7632, 7633, 1, 0, 0, 0, 7633, + 7636, 1, 0, 0, 0, 7634, 7632, 1, 0, 0, 0, 7635, 7626, 1, 0, 0, 0, 7635, + 7636, 1, 0, 0, 0, 7636, 7638, 1, 0, 0, 0, 7637, 7639, 5, 56, 0, 0, 7638, + 7637, 1, 0, 0, 0, 7638, 7639, 1, 0, 0, 0, 7639, 7655, 1, 0, 0, 0, 7640, + 7656, 3, 560, 280, 0, 7641, 7645, 5, 90, 0, 0, 7642, 7644, 3, 6, 3, 0, + 7643, 7642, 1, 0, 0, 0, 7644, 7647, 1, 0, 0, 0, 7645, 7643, 1, 0, 0, 0, + 7645, 7646, 1, 0, 0, 0, 7646, 7648, 1, 0, 0, 0, 7647, 7645, 1, 0, 0, 0, + 7648, 7649, 5, 824, 0, 0, 7649, 7651, 3, 926, 463, 0, 7650, 7652, 5, 1209, + 0, 0, 7651, 7650, 1, 0, 0, 0, 7651, 7652, 1, 0, 0, 0, 7652, 7653, 1, 0, + 0, 0, 7653, 7654, 5, 299, 0, 0, 7654, 7656, 1, 0, 0, 0, 7655, 7640, 1, + 0, 0, 0, 7655, 7641, 1, 0, 0, 0, 7656, 581, 1, 0, 0, 0, 7657, 7662, 5, + 643, 0, 0, 7658, 7662, 5, 245, 0, 0, 7659, 7662, 3, 1224, 612, 0, 7660, + 7662, 5, 1180, 0, 0, 7661, 7657, 1, 0, 0, 0, 7661, 7658, 1, 0, 0, 0, 7661, + 7659, 1, 0, 0, 0, 7661, 7660, 1, 0, 0, 0, 7662, 583, 1, 0, 0, 0, 7663, + 7665, 5, 1180, 0, 0, 7664, 7666, 5, 56, 0, 0, 7665, 7664, 1, 0, 0, 0, 7665, + 7666, 1, 0, 0, 0, 7666, 7670, 1, 0, 0, 0, 7667, 7668, 3, 1230, 615, 0, + 7668, 7669, 5, 1201, 0, 0, 7669, 7671, 1, 0, 0, 0, 7670, 7667, 1, 0, 0, + 0, 7670, 7671, 1, 0, 0, 0, 7671, 7672, 1, 0, 0, 0, 7672, 7674, 3, 1222, + 611, 0, 7673, 7675, 5, 1061, 0, 0, 7674, 7673, 1, 0, 0, 0, 7674, 7675, + 1, 0, 0, 0, 7675, 7678, 1, 0, 0, 0, 7676, 7677, 5, 1188, 0, 0, 7677, 7679, + 3, 582, 291, 0, 7678, 7676, 1, 0, 0, 0, 7678, 7679, 1, 0, 0, 0, 7679, 7681, + 1, 0, 0, 0, 7680, 7682, 7, 72, 0, 0, 7681, 7680, 1, 0, 0, 0, 7681, 7682, + 1, 0, 0, 0, 7682, 585, 1, 0, 0, 0, 7683, 7687, 5, 297, 0, 0, 7684, 7687, + 5, 782, 0, 0, 7685, 7687, 3, 864, 432, 0, 7686, 7683, 1, 0, 0, 0, 7686, + 7684, 1, 0, 0, 0, 7686, 7685, 1, 0, 0, 0, 7687, 587, 1, 0, 0, 0, 7688, + 7701, 5, 297, 0, 0, 7689, 7701, 5, 858, 0, 0, 7690, 7691, 5, 825, 0, 0, + 7691, 7692, 5, 643, 0, 0, 7692, 7693, 5, 662, 0, 0, 7693, 7694, 5, 643, + 0, 0, 7694, 7701, 5, 464, 0, 0, 7695, 7696, 5, 113, 0, 0, 7696, 7697, 5, + 662, 0, 0, 7697, 7698, 5, 643, 0, 0, 7698, 7701, 5, 464, 0, 0, 7699, 7701, + 3, 864, 432, 0, 7700, 7688, 1, 0, 0, 0, 7700, 7689, 1, 0, 0, 0, 7700, 7690, + 1, 0, 0, 0, 7700, 7695, 1, 0, 0, 0, 7700, 7699, 1, 0, 0, 0, 7701, 589, + 1, 0, 0, 0, 7702, 7703, 5, 199, 0, 0, 7703, 7704, 5, 945, 0, 0, 7704, 7705, + 3, 1230, 615, 0, 7705, 7706, 5, 662, 0, 0, 7706, 7707, 3, 1170, 585, 0, + 7707, 7708, 5, 1206, 0, 0, 7708, 7709, 3, 1192, 596, 0, 7709, 7728, 5, + 1207, 0, 0, 7710, 7716, 5, 1077, 0, 0, 7711, 7717, 5, 382, 0, 0, 7712, + 7713, 5, 854, 0, 0, 7713, 7714, 5, 1182, 0, 0, 7714, 7717, 7, 73, 0, 0, + 7715, 7717, 5, 950, 0, 0, 7716, 7711, 1, 0, 0, 0, 7716, 7712, 1, 0, 0, + 0, 7716, 7715, 1, 0, 0, 0, 7717, 7720, 1, 0, 0, 0, 7718, 7719, 5, 1208, + 0, 0, 7719, 7721, 5, 623, 0, 0, 7720, 7718, 1, 0, 0, 0, 7720, 7721, 1, + 0, 0, 0, 7721, 7726, 1, 0, 0, 0, 7722, 7723, 5, 1208, 0, 0, 7723, 7724, + 5, 455, 0, 0, 7724, 7725, 5, 1188, 0, 0, 7725, 7727, 3, 1196, 598, 0, 7726, + 7722, 1, 0, 0, 0, 7726, 7727, 1, 0, 0, 0, 7727, 7729, 1, 0, 0, 0, 7728, + 7710, 1, 0, 0, 0, 7728, 7729, 1, 0, 0, 0, 7729, 7731, 1, 0, 0, 0, 7730, + 7732, 5, 1209, 0, 0, 7731, 7730, 1, 0, 0, 0, 7731, 7732, 1, 0, 0, 0, 7732, + 591, 1, 0, 0, 0, 7733, 7734, 5, 1042, 0, 0, 7734, 7735, 5, 945, 0, 0, 7735, + 7748, 3, 1164, 582, 0, 7736, 7749, 3, 1230, 615, 0, 7737, 7738, 5, 1206, + 0, 0, 7738, 7743, 3, 1230, 615, 0, 7739, 7740, 5, 1208, 0, 0, 7740, 7742, + 3, 1230, 615, 0, 7741, 7739, 1, 0, 0, 0, 7742, 7745, 1, 0, 0, 0, 7743, + 7741, 1, 0, 0, 0, 7743, 7744, 1, 0, 0, 0, 7744, 7746, 1, 0, 0, 0, 7745, + 7743, 1, 0, 0, 0, 7746, 7747, 5, 1207, 0, 0, 7747, 7749, 1, 0, 0, 0, 7748, + 7736, 1, 0, 0, 0, 7748, 7737, 1, 0, 0, 0, 7748, 7749, 1, 0, 0, 0, 7749, + 7751, 1, 0, 0, 0, 7750, 7752, 3, 594, 297, 0, 7751, 7750, 1, 0, 0, 0, 7751, + 7752, 1, 0, 0, 0, 7752, 593, 1, 0, 0, 0, 7753, 7754, 5, 1077, 0, 0, 7754, + 7759, 3, 596, 298, 0, 7755, 7756, 5, 1208, 0, 0, 7756, 7758, 3, 596, 298, + 0, 7757, 7755, 1, 0, 0, 0, 7758, 7761, 1, 0, 0, 0, 7759, 7757, 1, 0, 0, + 0, 7759, 7760, 1, 0, 0, 0, 7760, 595, 1, 0, 0, 0, 7761, 7759, 1, 0, 0, + 0, 7762, 7769, 5, 382, 0, 0, 7763, 7765, 5, 1208, 0, 0, 7764, 7763, 1, + 0, 0, 0, 7764, 7765, 1, 0, 0, 0, 7765, 7766, 1, 0, 0, 0, 7766, 7767, 5, + 715, 0, 0, 7767, 7768, 5, 1188, 0, 0, 7768, 7770, 3, 1196, 598, 0, 7769, + 7764, 1, 0, 0, 0, 7769, 7770, 1, 0, 0, 0, 7770, 7809, 1, 0, 0, 0, 7771, + 7772, 5, 854, 0, 0, 7772, 7773, 5, 1182, 0, 0, 7773, 7780, 7, 73, 0, 0, + 7774, 7776, 5, 1208, 0, 0, 7775, 7774, 1, 0, 0, 0, 7775, 7776, 1, 0, 0, + 0, 7776, 7777, 1, 0, 0, 0, 7777, 7778, 5, 715, 0, 0, 7778, 7779, 5, 1188, + 0, 0, 7779, 7781, 3, 1196, 598, 0, 7780, 7775, 1, 0, 0, 0, 7780, 7781, + 1, 0, 0, 0, 7781, 7809, 1, 0, 0, 0, 7782, 7784, 5, 810, 0, 0, 7783, 7785, + 3, 542, 271, 0, 7784, 7783, 1, 0, 0, 0, 7784, 7785, 1, 0, 0, 0, 7785, 7809, + 1, 0, 0, 0, 7786, 7787, 5, 950, 0, 0, 7787, 7788, 5, 1188, 0, 0, 7788, + 7809, 3, 926, 463, 0, 7789, 7790, 5, 838, 0, 0, 7790, 7791, 5, 1188, 0, + 0, 7791, 7809, 5, 1182, 0, 0, 7792, 7793, 5, 691, 0, 0, 7793, 7794, 5, + 1188, 0, 0, 7794, 7809, 5, 1182, 0, 0, 7795, 7809, 5, 22, 0, 0, 7796, 7809, + 5, 157, 0, 0, 7797, 7809, 5, 456, 0, 0, 7798, 7809, 5, 623, 0, 0, 7799, + 7800, 5, 455, 0, 0, 7800, 7801, 5, 1188, 0, 0, 7801, 7809, 3, 1196, 598, + 0, 7802, 7803, 5, 551, 0, 0, 7803, 7804, 5, 1188, 0, 0, 7804, 7809, 5, + 1182, 0, 0, 7805, 7806, 5, 77, 0, 0, 7806, 7807, 5, 1188, 0, 0, 7807, 7809, + 3, 1196, 598, 0, 7808, 7762, 1, 0, 0, 0, 7808, 7771, 1, 0, 0, 0, 7808, + 7782, 1, 0, 0, 0, 7808, 7786, 1, 0, 0, 0, 7808, 7789, 1, 0, 0, 0, 7808, + 7792, 1, 0, 0, 0, 7808, 7795, 1, 0, 0, 0, 7808, 7796, 1, 0, 0, 0, 7808, + 7797, 1, 0, 0, 0, 7808, 7798, 1, 0, 0, 0, 7808, 7799, 1, 0, 0, 0, 7808, + 7802, 1, 0, 0, 0, 7808, 7805, 1, 0, 0, 0, 7809, 597, 1, 0, 0, 0, 7810, + 7811, 5, 199, 0, 0, 7811, 7812, 5, 980, 0, 0, 7812, 7813, 3, 1170, 585, + 0, 7813, 7814, 5, 1206, 0, 0, 7814, 7821, 3, 876, 438, 0, 7815, 7817, 5, + 1208, 0, 0, 7816, 7815, 1, 0, 0, 0, 7816, 7817, 1, 0, 0, 0, 7817, 7818, + 1, 0, 0, 0, 7818, 7820, 3, 600, 300, 0, 7819, 7816, 1, 0, 0, 0, 7820, 7823, + 1, 0, 0, 0, 7821, 7819, 1, 0, 0, 0, 7821, 7822, 1, 0, 0, 0, 7822, 7825, + 1, 0, 0, 0, 7823, 7821, 1, 0, 0, 0, 7824, 7826, 5, 1208, 0, 0, 7825, 7824, + 1, 0, 0, 0, 7825, 7826, 1, 0, 0, 0, 7826, 7827, 1, 0, 0, 0, 7827, 7830, + 5, 1207, 0, 0, 7828, 7829, 5, 534, 0, 0, 7829, 7831, 3, 1232, 616, 0, 7830, + 7828, 1, 0, 0, 0, 7830, 7831, 1, 0, 0, 0, 7831, 7835, 1, 0, 0, 0, 7832, + 7834, 3, 602, 301, 0, 7833, 7832, 1, 0, 0, 0, 7834, 7837, 1, 0, 0, 0, 7835, + 7833, 1, 0, 0, 0, 7835, 7836, 1, 0, 0, 0, 7836, 7842, 1, 0, 0, 0, 7837, + 7835, 1, 0, 0, 0, 7838, 7839, 5, 662, 0, 0, 7839, 7843, 3, 1230, 615, 0, + 7840, 7843, 5, 245, 0, 0, 7841, 7843, 3, 892, 446, 0, 7842, 7838, 1, 0, + 0, 0, 7842, 7840, 1, 0, 0, 0, 7842, 7841, 1, 0, 0, 0, 7842, 7843, 1, 0, + 0, 0, 7843, 7847, 1, 0, 0, 0, 7844, 7845, 5, 991, 0, 0, 7845, 7848, 3, + 1230, 615, 0, 7846, 7848, 5, 245, 0, 0, 7847, 7844, 1, 0, 0, 0, 7847, 7846, + 1, 0, 0, 0, 7847, 7848, 1, 0, 0, 0, 7848, 7850, 1, 0, 0, 0, 7849, 7851, + 5, 1209, 0, 0, 7850, 7849, 1, 0, 0, 0, 7850, 7851, 1, 0, 0, 0, 7851, 599, + 1, 0, 0, 0, 7852, 7853, 5, 456, 0, 0, 7853, 7855, 3, 1230, 615, 0, 7854, + 7856, 5, 1034, 0, 0, 7855, 7854, 1, 0, 0, 0, 7855, 7856, 1, 0, 0, 0, 7856, + 7858, 1, 0, 0, 0, 7857, 7859, 3, 1198, 599, 0, 7858, 7857, 1, 0, 0, 0, + 7858, 7859, 1, 0, 0, 0, 7859, 7860, 1, 0, 0, 0, 7860, 7861, 5, 1206, 0, + 0, 7861, 7862, 3, 1184, 592, 0, 7862, 7863, 5, 1207, 0, 0, 7863, 7886, + 1, 0, 0, 0, 7864, 7865, 5, 456, 0, 0, 7865, 7866, 3, 1230, 615, 0, 7866, + 7867, 5, 151, 0, 0, 7867, 7868, 5, 158, 0, 0, 7868, 7886, 1, 0, 0, 0, 7869, + 7870, 5, 456, 0, 0, 7870, 7872, 3, 1230, 615, 0, 7871, 7873, 5, 620, 0, + 0, 7872, 7871, 1, 0, 0, 0, 7872, 7873, 1, 0, 0, 0, 7873, 7874, 1, 0, 0, + 0, 7874, 7875, 5, 158, 0, 0, 7875, 7876, 5, 1206, 0, 0, 7876, 7877, 3, + 1192, 596, 0, 7877, 7879, 5, 1207, 0, 0, 7878, 7880, 3, 606, 303, 0, 7879, + 7878, 1, 0, 0, 0, 7879, 7880, 1, 0, 0, 0, 7880, 7883, 1, 0, 0, 0, 7881, + 7882, 5, 662, 0, 0, 7882, 7884, 3, 1230, 615, 0, 7883, 7881, 1, 0, 0, 0, + 7883, 7884, 1, 0, 0, 0, 7884, 7886, 1, 0, 0, 0, 7885, 7852, 1, 0, 0, 0, + 7885, 7864, 1, 0, 0, 0, 7885, 7869, 1, 0, 0, 0, 7886, 601, 1, 0, 0, 0, + 7887, 7907, 5, 1077, 0, 0, 7888, 7889, 5, 1206, 0, 0, 7889, 7894, 3, 604, + 302, 0, 7890, 7891, 5, 1208, 0, 0, 7891, 7893, 3, 604, 302, 0, 7892, 7890, + 1, 0, 0, 0, 7893, 7896, 1, 0, 0, 0, 7894, 7892, 1, 0, 0, 0, 7894, 7895, + 1, 0, 0, 0, 7895, 7897, 1, 0, 0, 0, 7896, 7894, 1, 0, 0, 0, 7897, 7898, + 5, 1207, 0, 0, 7898, 7908, 1, 0, 0, 0, 7899, 7904, 3, 604, 302, 0, 7900, + 7901, 5, 1208, 0, 0, 7901, 7903, 3, 604, 302, 0, 7902, 7900, 1, 0, 0, 0, + 7903, 7906, 1, 0, 0, 0, 7904, 7902, 1, 0, 0, 0, 7904, 7905, 1, 0, 0, 0, + 7905, 7908, 1, 0, 0, 0, 7906, 7904, 1, 0, 0, 0, 7907, 7888, 1, 0, 0, 0, + 7907, 7899, 1, 0, 0, 0, 7908, 603, 1, 0, 0, 0, 7909, 7912, 3, 1232, 616, + 0, 7910, 7912, 3, 1228, 614, 0, 7911, 7909, 1, 0, 0, 0, 7911, 7910, 1, + 0, 0, 0, 7912, 7913, 1, 0, 0, 0, 7913, 7918, 5, 1188, 0, 0, 7914, 7919, + 3, 1232, 616, 0, 7915, 7919, 3, 1228, 614, 0, 7916, 7919, 3, 1196, 598, + 0, 7917, 7919, 5, 1182, 0, 0, 7918, 7914, 1, 0, 0, 0, 7918, 7915, 1, 0, + 0, 0, 7918, 7916, 1, 0, 0, 0, 7918, 7917, 1, 0, 0, 0, 7919, 7966, 1, 0, + 0, 0, 7920, 7921, 5, 151, 0, 0, 7921, 7922, 5, 158, 0, 0, 7922, 7966, 5, + 456, 0, 0, 7923, 7966, 5, 424, 0, 0, 7924, 7925, 5, 359, 0, 0, 7925, 7926, + 5, 1188, 0, 0, 7926, 7966, 5, 1182, 0, 0, 7927, 7928, 5, 276, 0, 0, 7928, + 7929, 5, 1188, 0, 0, 7929, 7930, 5, 417, 0, 0, 7930, 7931, 5, 1206, 0, + 0, 7931, 7932, 3, 1230, 615, 0, 7932, 7933, 5, 1207, 0, 0, 7933, 7966, + 1, 0, 0, 0, 7934, 7935, 5, 151, 0, 0, 7935, 7936, 5, 456, 0, 0, 7936, 7937, + 5, 1206, 0, 0, 7937, 7939, 3, 1230, 615, 0, 7938, 7940, 7, 74, 0, 0, 7939, + 7938, 1, 0, 0, 0, 7939, 7940, 1, 0, 0, 0, 7940, 7948, 1, 0, 0, 0, 7941, + 7942, 5, 1208, 0, 0, 7942, 7944, 3, 1230, 615, 0, 7943, 7945, 7, 74, 0, + 0, 7944, 7943, 1, 0, 0, 0, 7944, 7945, 1, 0, 0, 0, 7945, 7947, 1, 0, 0, + 0, 7946, 7941, 1, 0, 0, 0, 7947, 7950, 1, 0, 0, 0, 7948, 7946, 1, 0, 0, + 0, 7948, 7949, 1, 0, 0, 0, 7949, 7951, 1, 0, 0, 0, 7950, 7948, 1, 0, 0, + 0, 7951, 7952, 5, 1207, 0, 0, 7952, 7966, 1, 0, 0, 0, 7953, 7954, 5, 225, + 0, 0, 7954, 7955, 5, 1188, 0, 0, 7955, 7957, 7, 75, 0, 0, 7956, 7958, 3, + 542, 271, 0, 7957, 7956, 1, 0, 0, 0, 7957, 7958, 1, 0, 0, 0, 7958, 7966, + 1, 0, 0, 0, 7959, 7960, 5, 1092, 0, 0, 7960, 7961, 5, 1188, 0, 0, 7961, + 7963, 3, 1196, 598, 0, 7962, 7964, 3, 542, 271, 0, 7963, 7962, 1, 0, 0, + 0, 7963, 7964, 1, 0, 0, 0, 7964, 7966, 1, 0, 0, 0, 7965, 7911, 1, 0, 0, + 0, 7965, 7920, 1, 0, 0, 0, 7965, 7923, 1, 0, 0, 0, 7965, 7924, 1, 0, 0, + 0, 7965, 7927, 1, 0, 0, 0, 7965, 7934, 1, 0, 0, 0, 7965, 7953, 1, 0, 0, + 0, 7965, 7959, 1, 0, 0, 0, 7966, 605, 1, 0, 0, 0, 7967, 7968, 5, 1077, + 0, 0, 7968, 7969, 5, 1206, 0, 0, 7969, 7974, 3, 608, 304, 0, 7970, 7971, + 5, 1208, 0, 0, 7971, 7973, 3, 608, 304, 0, 7972, 7970, 1, 0, 0, 0, 7973, + 7976, 1, 0, 0, 0, 7974, 7972, 1, 0, 0, 0, 7974, 7975, 1, 0, 0, 0, 7975, + 7977, 1, 0, 0, 0, 7976, 7974, 1, 0, 0, 0, 7977, 7978, 5, 1207, 0, 0, 7978, + 607, 1, 0, 0, 0, 7979, 7980, 5, 689, 0, 0, 7980, 7981, 5, 1188, 0, 0, 7981, + 8016, 3, 1196, 598, 0, 7982, 7983, 5, 359, 0, 0, 7983, 7984, 5, 1188, 0, + 0, 7984, 8016, 5, 1182, 0, 0, 7985, 7986, 5, 442, 0, 0, 7986, 7987, 5, + 1188, 0, 0, 7987, 8016, 3, 1196, 598, 0, 7988, 7989, 5, 947, 0, 0, 7989, + 7990, 5, 1188, 0, 0, 7990, 8016, 3, 1196, 598, 0, 7991, 7992, 5, 946, 0, + 0, 7992, 7993, 5, 1188, 0, 0, 7993, 8016, 3, 1196, 598, 0, 7994, 7995, + 5, 28, 0, 0, 7995, 7996, 5, 1188, 0, 0, 7996, 8016, 3, 1196, 598, 0, 7997, + 7998, 5, 27, 0, 0, 7998, 7999, 5, 1188, 0, 0, 7999, 8016, 3, 1196, 598, + 0, 8000, 8001, 5, 676, 0, 0, 8001, 8002, 5, 1188, 0, 0, 8002, 8016, 3, + 1196, 598, 0, 8003, 8004, 5, 225, 0, 0, 8004, 8005, 5, 1188, 0, 0, 8005, + 8007, 7, 65, 0, 0, 8006, 8008, 3, 542, 271, 0, 8007, 8006, 1, 0, 0, 0, + 8007, 8008, 1, 0, 0, 0, 8008, 8016, 1, 0, 0, 0, 8009, 8010, 5, 1092, 0, + 0, 8010, 8011, 5, 1188, 0, 0, 8011, 8013, 3, 1196, 598, 0, 8012, 8014, + 3, 542, 271, 0, 8013, 8012, 1, 0, 0, 0, 8013, 8014, 1, 0, 0, 0, 8014, 8016, + 1, 0, 0, 0, 8015, 7979, 1, 0, 0, 0, 8015, 7982, 1, 0, 0, 0, 8015, 7985, + 1, 0, 0, 0, 8015, 7988, 1, 0, 0, 0, 8015, 7991, 1, 0, 0, 0, 8015, 7994, + 1, 0, 0, 0, 8015, 7997, 1, 0, 0, 0, 8015, 8000, 1, 0, 0, 0, 8015, 8003, + 1, 0, 0, 0, 8015, 8009, 1, 0, 0, 0, 8016, 609, 1, 0, 0, 0, 8017, 8020, + 5, 199, 0, 0, 8018, 8019, 5, 678, 0, 0, 8019, 8021, 7, 68, 0, 0, 8020, + 8018, 1, 0, 0, 0, 8020, 8021, 1, 0, 0, 0, 8021, 8024, 1, 0, 0, 0, 8022, + 8024, 5, 35, 0, 0, 8023, 8017, 1, 0, 0, 0, 8023, 8022, 1, 0, 0, 0, 8024, + 8025, 1, 0, 0, 0, 8025, 8026, 5, 1065, 0, 0, 8026, 8031, 3, 1172, 586, + 0, 8027, 8028, 5, 1206, 0, 0, 8028, 8029, 3, 1192, 596, 0, 8029, 8030, + 5, 1207, 0, 0, 8030, 8032, 1, 0, 0, 0, 8031, 8027, 1, 0, 0, 0, 8031, 8032, + 1, 0, 0, 0, 8032, 8042, 1, 0, 0, 0, 8033, 8034, 5, 1077, 0, 0, 8034, 8039, + 3, 612, 306, 0, 8035, 8036, 5, 1208, 0, 0, 8036, 8038, 3, 612, 306, 0, + 8037, 8035, 1, 0, 0, 0, 8038, 8041, 1, 0, 0, 0, 8039, 8037, 1, 0, 0, 0, + 8039, 8040, 1, 0, 0, 0, 8040, 8043, 1, 0, 0, 0, 8041, 8039, 1, 0, 0, 0, + 8042, 8033, 1, 0, 0, 0, 8042, 8043, 1, 0, 0, 0, 8043, 8044, 1, 0, 0, 0, + 8044, 8045, 5, 56, 0, 0, 8045, 8049, 3, 482, 241, 0, 8046, 8047, 5, 1077, + 0, 0, 8047, 8048, 5, 133, 0, 0, 8048, 8050, 5, 677, 0, 0, 8049, 8046, 1, + 0, 0, 0, 8049, 8050, 1, 0, 0, 0, 8050, 8052, 1, 0, 0, 0, 8051, 8053, 5, + 1209, 0, 0, 8052, 8051, 1, 0, 0, 0, 8052, 8053, 1, 0, 0, 0, 8053, 611, + 1, 0, 0, 0, 8054, 8055, 7, 76, 0, 0, 8055, 613, 1, 0, 0, 0, 8056, 8057, + 5, 35, 0, 0, 8057, 8058, 5, 980, 0, 0, 8058, 8132, 3, 1170, 585, 0, 8059, + 8060, 5, 900, 0, 0, 8060, 8061, 5, 1206, 0, 0, 8061, 8062, 5, 535, 0, 0, + 8062, 8063, 5, 1188, 0, 0, 8063, 8064, 7, 77, 0, 0, 8064, 8133, 5, 1207, + 0, 0, 8065, 8066, 5, 11, 0, 0, 8066, 8133, 3, 876, 438, 0, 8067, 8068, + 5, 35, 0, 0, 8068, 8071, 5, 155, 0, 0, 8069, 8072, 3, 880, 440, 0, 8070, + 8072, 3, 884, 442, 0, 8071, 8069, 1, 0, 0, 0, 8071, 8070, 1, 0, 0, 0, 8072, + 8133, 1, 0, 0, 0, 8073, 8074, 5, 282, 0, 0, 8074, 8075, 5, 155, 0, 0, 8075, + 8080, 3, 1230, 615, 0, 8076, 8077, 5, 1208, 0, 0, 8077, 8079, 3, 1230, + 615, 0, 8078, 8076, 1, 0, 0, 0, 8079, 8082, 1, 0, 0, 0, 8080, 8078, 1, + 0, 0, 0, 8080, 8081, 1, 0, 0, 0, 8081, 8133, 1, 0, 0, 0, 8082, 8080, 1, + 0, 0, 0, 8083, 8084, 5, 282, 0, 0, 8084, 8085, 5, 179, 0, 0, 8085, 8133, + 3, 1230, 615, 0, 8086, 8087, 5, 1077, 0, 0, 8087, 8088, 7, 78, 0, 0, 8088, + 8091, 5, 11, 0, 0, 8089, 8090, 5, 179, 0, 0, 8090, 8092, 3, 1230, 615, + 0, 8091, 8089, 1, 0, 0, 0, 8091, 8092, 1, 0, 0, 0, 8092, 8118, 1, 0, 0, + 0, 8093, 8094, 5, 373, 0, 0, 8094, 8095, 5, 498, 0, 0, 8095, 8096, 5, 1206, + 0, 0, 8096, 8097, 3, 1192, 596, 0, 8097, 8098, 5, 1207, 0, 0, 8098, 8099, + 5, 786, 0, 0, 8099, 8104, 3, 1170, 585, 0, 8100, 8101, 5, 1206, 0, 0, 8101, + 8102, 3, 1192, 596, 0, 8102, 8103, 5, 1207, 0, 0, 8103, 8105, 1, 0, 0, + 0, 8104, 8100, 1, 0, 0, 0, 8104, 8105, 1, 0, 0, 0, 8105, 8110, 1, 0, 0, + 0, 8106, 8109, 3, 904, 452, 0, 8107, 8109, 3, 906, 453, 0, 8108, 8106, + 1, 0, 0, 0, 8108, 8107, 1, 0, 0, 0, 8109, 8112, 1, 0, 0, 0, 8110, 8108, + 1, 0, 0, 0, 8110, 8111, 1, 0, 0, 0, 8111, 8119, 1, 0, 0, 0, 8112, 8110, + 1, 0, 0, 0, 8113, 8114, 5, 133, 0, 0, 8114, 8115, 5, 1206, 0, 0, 8115, + 8116, 3, 950, 475, 0, 8116, 8117, 5, 1207, 0, 0, 8117, 8119, 1, 0, 0, 0, + 8118, 8093, 1, 0, 0, 0, 8118, 8113, 1, 0, 0, 0, 8119, 8133, 1, 0, 0, 0, + 8120, 8121, 7, 78, 0, 0, 8121, 8122, 5, 179, 0, 0, 8122, 8133, 3, 1230, + 615, 0, 8123, 8124, 7, 25, 0, 0, 8124, 8126, 5, 1013, 0, 0, 8125, 8127, + 3, 1230, 615, 0, 8126, 8125, 1, 0, 0, 0, 8126, 8127, 1, 0, 0, 0, 8127, + 8133, 1, 0, 0, 0, 8128, 8129, 5, 780, 0, 0, 8129, 8133, 3, 602, 301, 0, + 8130, 8131, 5, 974, 0, 0, 8131, 8133, 3, 616, 308, 0, 8132, 8059, 1, 0, + 0, 0, 8132, 8065, 1, 0, 0, 0, 8132, 8067, 1, 0, 0, 0, 8132, 8073, 1, 0, + 0, 0, 8132, 8083, 1, 0, 0, 0, 8132, 8086, 1, 0, 0, 0, 8132, 8120, 1, 0, + 0, 0, 8132, 8123, 1, 0, 0, 0, 8132, 8128, 1, 0, 0, 0, 8132, 8130, 1, 0, + 0, 0, 8133, 8135, 1, 0, 0, 0, 8134, 8136, 5, 1209, 0, 0, 8135, 8134, 1, + 0, 0, 0, 8135, 8136, 1, 0, 0, 0, 8136, 615, 1, 0, 0, 0, 8137, 8139, 5, + 700, 0, 0, 8138, 8137, 1, 0, 0, 0, 8138, 8139, 1, 0, 0, 0, 8139, 8140, + 1, 0, 0, 0, 8140, 8142, 3, 926, 463, 0, 8141, 8138, 1, 0, 0, 0, 8141, 8142, + 1, 0, 0, 0, 8142, 8143, 1, 0, 0, 0, 8143, 8144, 5, 1000, 0, 0, 8144, 8147, + 3, 1170, 585, 0, 8145, 8146, 5, 700, 0, 0, 8146, 8148, 3, 926, 463, 0, + 8147, 8145, 1, 0, 0, 0, 8147, 8148, 1, 0, 0, 0, 8148, 8151, 1, 0, 0, 0, + 8149, 8150, 5, 1077, 0, 0, 8150, 8152, 3, 618, 309, 0, 8151, 8149, 1, 0, + 0, 0, 8151, 8152, 1, 0, 0, 0, 8152, 617, 1, 0, 0, 0, 8153, 8154, 5, 1071, + 0, 0, 8154, 8155, 5, 1206, 0, 0, 8155, 8156, 5, 559, 0, 0, 8156, 8157, + 5, 1188, 0, 0, 8157, 8159, 3, 486, 243, 0, 8158, 8160, 5, 582, 0, 0, 8159, + 8158, 1, 0, 0, 0, 8159, 8160, 1, 0, 0, 0, 8160, 8161, 1, 0, 0, 0, 8161, + 8162, 5, 1208, 0, 0, 8162, 8163, 5, 2, 0, 0, 8163, 8164, 5, 1188, 0, 0, + 8164, 8165, 7, 79, 0, 0, 8165, 8166, 5, 1207, 0, 0, 8166, 619, 1, 0, 0, + 0, 8167, 8168, 5, 35, 0, 0, 8168, 8171, 5, 219, 0, 0, 8169, 8172, 3, 1230, + 615, 0, 8170, 8172, 5, 206, 0, 0, 8171, 8169, 1, 0, 0, 0, 8171, 8170, 1, + 0, 0, 0, 8172, 8187, 1, 0, 0, 0, 8173, 8174, 5, 592, 0, 0, 8174, 8175, + 5, 597, 0, 0, 8175, 8176, 5, 1188, 0, 0, 8176, 8188, 3, 1230, 615, 0, 8177, + 8178, 5, 153, 0, 0, 8178, 8188, 3, 1230, 615, 0, 8179, 8180, 5, 900, 0, + 0, 8180, 8183, 3, 630, 315, 0, 8181, 8182, 5, 1077, 0, 0, 8182, 8184, 3, + 700, 350, 0, 8183, 8181, 1, 0, 0, 0, 8183, 8184, 1, 0, 0, 0, 8184, 8188, + 1, 0, 0, 0, 8185, 8188, 3, 622, 311, 0, 8186, 8188, 3, 626, 313, 0, 8187, + 8173, 1, 0, 0, 0, 8187, 8177, 1, 0, 0, 0, 8187, 8179, 1, 0, 0, 0, 8187, + 8185, 1, 0, 0, 0, 8187, 8186, 1, 0, 0, 0, 8188, 8190, 1, 0, 0, 0, 8189, + 8191, 5, 1209, 0, 0, 8190, 8189, 1, 0, 0, 0, 8190, 8191, 1, 0, 0, 0, 8191, + 621, 1, 0, 0, 0, 8192, 8193, 5, 11, 0, 0, 8193, 8194, 5, 343, 0, 0, 8194, + 8199, 3, 624, 312, 0, 8195, 8196, 5, 1208, 0, 0, 8196, 8198, 3, 624, 312, + 0, 8197, 8195, 1, 0, 0, 0, 8198, 8201, 1, 0, 0, 0, 8199, 8197, 1, 0, 0, + 0, 8199, 8200, 1, 0, 0, 0, 8200, 8205, 1, 0, 0, 0, 8201, 8199, 1, 0, 0, + 0, 8202, 8203, 5, 1000, 0, 0, 8203, 8204, 5, 344, 0, 0, 8204, 8206, 3, + 1230, 615, 0, 8205, 8202, 1, 0, 0, 0, 8205, 8206, 1, 0, 0, 0, 8206, 8225, + 1, 0, 0, 0, 8207, 8208, 5, 11, 0, 0, 8208, 8209, 5, 536, 0, 0, 8209, 8210, + 5, 343, 0, 0, 8210, 8215, 3, 624, 312, 0, 8211, 8212, 5, 1208, 0, 0, 8212, + 8214, 3, 624, 312, 0, 8213, 8211, 1, 0, 0, 0, 8214, 8217, 1, 0, 0, 0, 8215, + 8213, 1, 0, 0, 0, 8215, 8216, 1, 0, 0, 0, 8216, 8225, 1, 0, 0, 0, 8217, + 8215, 1, 0, 0, 0, 8218, 8219, 5, 794, 0, 0, 8219, 8220, 5, 343, 0, 0, 8220, + 8225, 3, 1230, 615, 0, 8221, 8222, 5, 592, 0, 0, 8222, 8223, 5, 343, 0, + 0, 8223, 8225, 3, 624, 312, 0, 8224, 8192, 1, 0, 0, 0, 8224, 8207, 1, 0, + 0, 0, 8224, 8218, 1, 0, 0, 0, 8224, 8221, 1, 0, 0, 0, 8225, 623, 1, 0, + 0, 0, 8226, 8227, 5, 1206, 0, 0, 8227, 8228, 5, 597, 0, 0, 8228, 8229, + 5, 1188, 0, 0, 8229, 8234, 3, 1234, 617, 0, 8230, 8231, 5, 1208, 0, 0, + 8231, 8232, 5, 603, 0, 0, 8232, 8233, 5, 1188, 0, 0, 8233, 8235, 3, 1234, + 617, 0, 8234, 8230, 1, 0, 0, 0, 8234, 8235, 1, 0, 0, 0, 8235, 8240, 1, + 0, 0, 0, 8236, 8237, 5, 1208, 0, 0, 8237, 8238, 5, 349, 0, 0, 8238, 8239, + 5, 1188, 0, 0, 8239, 8241, 5, 1184, 0, 0, 8240, 8236, 1, 0, 0, 0, 8240, + 8241, 1, 0, 0, 0, 8241, 8246, 1, 0, 0, 0, 8242, 8243, 5, 1208, 0, 0, 8243, + 8244, 5, 918, 0, 0, 8244, 8245, 5, 1188, 0, 0, 8245, 8247, 3, 1240, 620, + 0, 8246, 8242, 1, 0, 0, 0, 8246, 8247, 1, 0, 0, 0, 8247, 8253, 1, 0, 0, + 0, 8248, 8249, 5, 1208, 0, 0, 8249, 8250, 5, 553, 0, 0, 8250, 8251, 5, + 1188, 0, 0, 8251, 8254, 3, 1240, 620, 0, 8252, 8254, 5, 1036, 0, 0, 8253, + 8248, 1, 0, 0, 0, 8253, 8252, 1, 0, 0, 0, 8253, 8254, 1, 0, 0, 0, 8254, + 8259, 1, 0, 0, 0, 8255, 8256, 5, 1208, 0, 0, 8256, 8257, 5, 348, 0, 0, + 8257, 8258, 5, 1188, 0, 0, 8258, 8260, 3, 1240, 620, 0, 8259, 8255, 1, + 0, 0, 0, 8259, 8260, 1, 0, 0, 0, 8260, 8263, 1, 0, 0, 0, 8261, 8262, 5, + 1208, 0, 0, 8262, 8264, 5, 657, 0, 0, 8263, 8261, 1, 0, 0, 0, 8263, 8264, + 1, 0, 0, 0, 8264, 8265, 1, 0, 0, 0, 8265, 8266, 5, 1207, 0, 0, 8266, 625, + 1, 0, 0, 0, 8267, 8268, 5, 11, 0, 0, 8268, 8269, 5, 344, 0, 0, 8269, 8274, + 3, 1230, 615, 0, 8270, 8271, 5, 181, 0, 0, 8271, 8275, 5, 353, 0, 0, 8272, + 8273, 5, 181, 0, 0, 8273, 8275, 5, 575, 0, 0, 8274, 8270, 1, 0, 0, 0, 8274, + 8272, 1, 0, 0, 0, 8274, 8275, 1, 0, 0, 0, 8275, 8292, 1, 0, 0, 0, 8276, + 8277, 5, 794, 0, 0, 8277, 8278, 5, 344, 0, 0, 8278, 8292, 3, 1230, 615, + 0, 8279, 8280, 5, 592, 0, 0, 8280, 8281, 5, 344, 0, 0, 8281, 8289, 3, 1230, + 615, 0, 8282, 8290, 3, 628, 314, 0, 8283, 8290, 5, 245, 0, 0, 8284, 8285, + 5, 597, 0, 0, 8285, 8286, 5, 1188, 0, 0, 8286, 8290, 3, 1230, 615, 0, 8287, + 8290, 5, 71, 0, 0, 8288, 8290, 5, 70, 0, 0, 8289, 8282, 1, 0, 0, 0, 8289, + 8283, 1, 0, 0, 0, 8289, 8284, 1, 0, 0, 0, 8289, 8287, 1, 0, 0, 0, 8289, + 8288, 1, 0, 0, 0, 8290, 8292, 1, 0, 0, 0, 8291, 8267, 1, 0, 0, 0, 8291, + 8276, 1, 0, 0, 0, 8291, 8279, 1, 0, 0, 0, 8292, 627, 1, 0, 0, 0, 8293, + 8294, 7, 80, 0, 0, 8294, 629, 1, 0, 0, 0, 8295, 8319, 3, 632, 316, 0, 8296, + 8319, 3, 634, 317, 0, 8297, 8319, 3, 638, 319, 0, 8298, 8319, 3, 640, 320, + 0, 8299, 8319, 3, 644, 322, 0, 8300, 8319, 3, 670, 335, 0, 8301, 8319, + 3, 672, 336, 0, 8302, 8319, 3, 674, 337, 0, 8303, 8319, 3, 676, 338, 0, + 8304, 8319, 3, 678, 339, 0, 8305, 8319, 3, 680, 340, 0, 8306, 8319, 3, + 682, 341, 0, 8307, 8308, 5, 353, 0, 0, 8308, 8319, 3, 1150, 575, 0, 8309, + 8319, 3, 684, 342, 0, 8310, 8319, 3, 686, 343, 0, 8311, 8319, 3, 688, 344, + 0, 8312, 8319, 3, 690, 345, 0, 8313, 8319, 3, 692, 346, 0, 8314, 8319, + 3, 694, 347, 0, 8315, 8319, 3, 696, 348, 0, 8316, 8319, 3, 698, 349, 0, + 8317, 8319, 3, 700, 350, 0, 8318, 8295, 1, 0, 0, 0, 8318, 8296, 1, 0, 0, + 0, 8318, 8297, 1, 0, 0, 0, 8318, 8298, 1, 0, 0, 0, 8318, 8299, 1, 0, 0, + 0, 8318, 8300, 1, 0, 0, 0, 8318, 8301, 1, 0, 0, 0, 8318, 8302, 1, 0, 0, + 0, 8318, 8303, 1, 0, 0, 0, 8318, 8304, 1, 0, 0, 0, 8318, 8305, 1, 0, 0, + 0, 8318, 8306, 1, 0, 0, 0, 8318, 8307, 1, 0, 0, 0, 8318, 8309, 1, 0, 0, + 0, 8318, 8310, 1, 0, 0, 0, 8318, 8311, 1, 0, 0, 0, 8318, 8312, 1, 0, 0, + 0, 8318, 8313, 1, 0, 0, 0, 8318, 8314, 1, 0, 0, 0, 8318, 8315, 1, 0, 0, + 0, 8318, 8316, 1, 0, 0, 0, 8318, 8317, 1, 0, 0, 0, 8319, 631, 1, 0, 0, + 0, 8320, 8321, 5, 75, 0, 0, 8321, 8338, 3, 1196, 598, 0, 8322, 8323, 5, + 76, 0, 0, 8323, 8338, 5, 656, 0, 0, 8324, 8329, 5, 662, 0, 0, 8325, 8326, + 5, 455, 0, 0, 8326, 8327, 5, 1188, 0, 0, 8327, 8330, 5, 662, 0, 0, 8328, + 8330, 5, 656, 0, 0, 8329, 8325, 1, 0, 0, 0, 8329, 8328, 1, 0, 0, 0, 8330, + 8338, 1, 0, 0, 0, 8331, 8332, 5, 78, 0, 0, 8332, 8338, 3, 1196, 598, 0, + 8333, 8334, 5, 79, 0, 0, 8334, 8338, 3, 1196, 598, 0, 8335, 8336, 5, 80, + 0, 0, 8336, 8338, 7, 17, 0, 0, 8337, 8320, 1, 0, 0, 0, 8337, 8322, 1, 0, + 0, 0, 8337, 8324, 1, 0, 0, 0, 8337, 8331, 1, 0, 0, 0, 8337, 8333, 1, 0, + 0, 0, 8337, 8335, 1, 0, 0, 0, 8338, 633, 1, 0, 0, 0, 8339, 8340, 5, 130, + 0, 0, 8340, 8358, 5, 1188, 0, 0, 8341, 8359, 5, 656, 0, 0, 8342, 8343, + 5, 662, 0, 0, 8343, 8354, 5, 1206, 0, 0, 8344, 8349, 3, 636, 318, 0, 8345, + 8346, 5, 1208, 0, 0, 8346, 8348, 3, 636, 318, 0, 8347, 8345, 1, 0, 0, 0, + 8348, 8351, 1, 0, 0, 0, 8349, 8347, 1, 0, 0, 0, 8349, 8350, 1, 0, 0, 0, + 8350, 8353, 1, 0, 0, 0, 8351, 8349, 1, 0, 0, 0, 8352, 8344, 1, 0, 0, 0, + 8353, 8356, 1, 0, 0, 0, 8354, 8352, 1, 0, 0, 0, 8354, 8355, 1, 0, 0, 0, + 8355, 8357, 1, 0, 0, 0, 8356, 8354, 1, 0, 0, 0, 8357, 8359, 5, 1207, 0, + 0, 8358, 8341, 1, 0, 0, 0, 8358, 8342, 1, 0, 0, 0, 8359, 635, 1, 0, 0, + 0, 8360, 8361, 5, 74, 0, 0, 8361, 8362, 5, 1188, 0, 0, 8362, 8368, 3, 1196, + 598, 0, 8363, 8364, 5, 129, 0, 0, 8364, 8365, 5, 1188, 0, 0, 8365, 8366, + 5, 1182, 0, 0, 8366, 8368, 7, 81, 0, 0, 8367, 8360, 1, 0, 0, 0, 8367, 8363, + 1, 0, 0, 0, 8368, 637, 1, 0, 0, 0, 8369, 8370, 5, 180, 0, 0, 8370, 8371, + 5, 1188, 0, 0, 8371, 8372, 7, 62, 0, 0, 8372, 639, 1, 0, 0, 0, 8373, 8374, + 5, 214, 0, 0, 8374, 8378, 3, 1196, 598, 0, 8375, 8376, 5, 215, 0, 0, 8376, + 8378, 7, 82, 0, 0, 8377, 8373, 1, 0, 0, 0, 8377, 8375, 1, 0, 0, 0, 8378, + 641, 1, 0, 0, 0, 8379, 8380, 5, 35, 0, 0, 8380, 8381, 5, 300, 0, 0, 8381, + 8384, 3, 1230, 615, 0, 8382, 8383, 5, 68, 0, 0, 8383, 8385, 3, 1230, 615, + 0, 8384, 8382, 1, 0, 0, 0, 8384, 8385, 1, 0, 0, 0, 8385, 8389, 1, 0, 0, + 0, 8386, 8387, 5, 943, 0, 0, 8387, 8388, 5, 1188, 0, 0, 8388, 8390, 7, + 26, 0, 0, 8389, 8386, 1, 0, 0, 0, 8389, 8390, 1, 0, 0, 0, 8390, 8391, 1, + 0, 0, 0, 8391, 8392, 5, 56, 0, 0, 8392, 8393, 5, 990, 0, 0, 8393, 8394, + 5, 1206, 0, 0, 8394, 8395, 3, 300, 150, 0, 8395, 8446, 5, 1207, 0, 0, 8396, + 8397, 5, 365, 0, 0, 8397, 8398, 5, 1022, 0, 0, 8398, 8399, 5, 1206, 0, + 0, 8399, 8447, 5, 1207, 0, 0, 8400, 8401, 5, 365, 0, 0, 8401, 8402, 5, + 893, 0, 0, 8402, 8403, 5, 1206, 0, 0, 8403, 8408, 3, 298, 149, 0, 8404, + 8406, 5, 1208, 0, 0, 8405, 8404, 1, 0, 0, 0, 8405, 8406, 1, 0, 0, 0, 8406, + 8407, 1, 0, 0, 0, 8407, 8409, 3, 296, 148, 0, 8408, 8405, 1, 0, 0, 0, 8408, + 8409, 1, 0, 0, 0, 8409, 8416, 1, 0, 0, 0, 8410, 8412, 5, 1208, 0, 0, 8411, + 8410, 1, 0, 0, 0, 8411, 8412, 1, 0, 0, 0, 8412, 8413, 1, 0, 0, 0, 8413, + 8414, 5, 579, 0, 0, 8414, 8415, 5, 1188, 0, 0, 8415, 8417, 7, 27, 0, 0, + 8416, 8411, 1, 0, 0, 0, 8416, 8417, 1, 0, 0, 0, 8417, 8424, 1, 0, 0, 0, + 8418, 8420, 5, 1208, 0, 0, 8419, 8418, 1, 0, 0, 0, 8419, 8420, 1, 0, 0, + 0, 8420, 8421, 1, 0, 0, 0, 8421, 8422, 5, 580, 0, 0, 8422, 8423, 5, 1188, + 0, 0, 8423, 8425, 5, 1182, 0, 0, 8424, 8419, 1, 0, 0, 0, 8424, 8425, 1, + 0, 0, 0, 8425, 8426, 1, 0, 0, 0, 8426, 8427, 5, 1207, 0, 0, 8427, 8447, + 1, 0, 0, 0, 8428, 8429, 5, 365, 0, 0, 8429, 8430, 5, 221, 0, 0, 8430, 8431, + 5, 1206, 0, 0, 8431, 8436, 3, 298, 149, 0, 8432, 8434, 5, 1208, 0, 0, 8433, + 8432, 1, 0, 0, 0, 8433, 8434, 1, 0, 0, 0, 8434, 8435, 1, 0, 0, 0, 8435, + 8437, 3, 296, 148, 0, 8436, 8433, 1, 0, 0, 0, 8436, 8437, 1, 0, 0, 0, 8437, + 8439, 1, 0, 0, 0, 8438, 8440, 5, 1208, 0, 0, 8439, 8438, 1, 0, 0, 0, 8439, + 8440, 1, 0, 0, 0, 8440, 8441, 1, 0, 0, 0, 8441, 8442, 5, 832, 0, 0, 8442, + 8443, 5, 1188, 0, 0, 8443, 8444, 7, 28, 0, 0, 8444, 8445, 5, 1207, 0, 0, + 8445, 8447, 1, 0, 0, 0, 8446, 8396, 1, 0, 0, 0, 8446, 8400, 1, 0, 0, 0, + 8446, 8428, 1, 0, 0, 0, 8447, 643, 1, 0, 0, 0, 8448, 8449, 3, 646, 323, + 0, 8449, 645, 1, 0, 0, 0, 8450, 8451, 3, 648, 324, 0, 8451, 8452, 3, 654, + 327, 0, 8452, 8457, 1, 0, 0, 0, 8453, 8454, 3, 650, 325, 0, 8454, 8455, + 3, 656, 328, 0, 8455, 8457, 1, 0, 0, 0, 8456, 8450, 1, 0, 0, 0, 8456, 8453, + 1, 0, 0, 0, 8457, 647, 1, 0, 0, 0, 8458, 8459, 5, 702, 0, 0, 8459, 649, + 1, 0, 0, 0, 8460, 8461, 5, 1081, 0, 0, 8461, 651, 1, 0, 0, 0, 8462, 8463, + 5, 1188, 0, 0, 8463, 653, 1, 0, 0, 0, 8464, 8465, 3, 652, 326, 0, 8465, + 8466, 3, 660, 330, 0, 8466, 8477, 1, 0, 0, 0, 8467, 8477, 5, 333, 0, 0, + 8468, 8477, 5, 372, 0, 0, 8469, 8477, 5, 656, 0, 0, 8470, 8477, 5, 821, + 0, 0, 8471, 8472, 5, 853, 0, 0, 8472, 8477, 7, 83, 0, 0, 8473, 8477, 5, + 973, 0, 0, 8474, 8475, 5, 997, 0, 0, 8475, 8477, 5, 1182, 0, 0, 8476, 8464, + 1, 0, 0, 0, 8476, 8467, 1, 0, 0, 0, 8476, 8468, 1, 0, 0, 0, 8476, 8469, + 1, 0, 0, 0, 8476, 8470, 1, 0, 0, 0, 8476, 8471, 1, 0, 0, 0, 8476, 8473, + 1, 0, 0, 0, 8476, 8474, 1, 0, 0, 0, 8477, 655, 1, 0, 0, 0, 8478, 8479, + 3, 652, 326, 0, 8479, 8480, 3, 658, 329, 0, 8480, 8483, 1, 0, 0, 0, 8481, + 8483, 5, 656, 0, 0, 8482, 8478, 1, 0, 0, 0, 8482, 8481, 1, 0, 0, 0, 8483, + 657, 1, 0, 0, 0, 8484, 8485, 3, 660, 330, 0, 8485, 659, 1, 0, 0, 0, 8486, + 8487, 3, 664, 332, 0, 8487, 8488, 3, 668, 334, 0, 8488, 8489, 3, 662, 331, + 0, 8489, 8490, 3, 666, 333, 0, 8490, 661, 1, 0, 0, 0, 8491, 8492, 5, 1210, + 0, 0, 8492, 663, 1, 0, 0, 0, 8493, 8494, 5, 990, 0, 0, 8494, 8495, 5, 1210, + 0, 0, 8495, 8496, 5, 281, 0, 0, 8496, 665, 1, 0, 0, 0, 8497, 8498, 5, 1182, + 0, 0, 8498, 667, 1, 0, 0, 0, 8499, 8500, 3, 1230, 615, 0, 8500, 8501, 5, + 1201, 0, 0, 8501, 8502, 3, 668, 334, 0, 8502, 8510, 1, 0, 0, 0, 8503, 8504, + 3, 1230, 615, 0, 8504, 8505, 5, 1201, 0, 0, 8505, 8508, 1, 0, 0, 0, 8506, + 8508, 3, 1230, 615, 0, 8507, 8503, 1, 0, 0, 0, 8507, 8506, 1, 0, 0, 0, + 8508, 8510, 1, 0, 0, 0, 8509, 8499, 1, 0, 0, 0, 8509, 8507, 1, 0, 0, 0, + 8510, 669, 1, 0, 0, 0, 8511, 8512, 5, 232, 0, 0, 8512, 8513, 3, 1196, 598, + 0, 8513, 671, 1, 0, 0, 0, 8514, 8515, 5, 297, 0, 0, 8515, 8516, 3, 1196, + 598, 0, 8516, 673, 1, 0, 0, 0, 8517, 8518, 7, 84, 0, 0, 8518, 675, 1, 0, + 0, 0, 8519, 8520, 7, 85, 0, 0, 8520, 677, 1, 0, 0, 0, 8521, 8522, 7, 86, + 0, 0, 8522, 679, 1, 0, 0, 0, 8523, 8524, 5, 253, 0, 0, 8524, 8525, 5, 1188, + 0, 0, 8525, 8526, 7, 87, 0, 0, 8526, 681, 1, 0, 0, 0, 8527, 8528, 5, 236, + 0, 0, 8528, 8553, 3, 1196, 598, 0, 8529, 8530, 5, 1018, 0, 0, 8530, 8553, + 3, 1196, 598, 0, 8531, 8532, 5, 249, 0, 0, 8532, 8535, 5, 1188, 0, 0, 8533, + 8536, 3, 1230, 615, 0, 8534, 8536, 5, 1184, 0, 0, 8535, 8533, 1, 0, 0, + 0, 8535, 8534, 1, 0, 0, 0, 8536, 8553, 1, 0, 0, 0, 8537, 8538, 5, 248, + 0, 0, 8538, 8541, 5, 1188, 0, 0, 8539, 8542, 3, 1230, 615, 0, 8540, 8542, + 5, 1184, 0, 0, 8541, 8539, 1, 0, 0, 0, 8541, 8540, 1, 0, 0, 0, 8542, 8553, + 1, 0, 0, 0, 8543, 8544, 5, 601, 0, 0, 8544, 8545, 5, 1188, 0, 0, 8545, + 8553, 7, 17, 0, 0, 8546, 8547, 5, 1011, 0, 0, 8547, 8548, 5, 1188, 0, 0, + 8548, 8553, 7, 17, 0, 0, 8549, 8550, 5, 1023, 0, 0, 8550, 8551, 5, 1188, + 0, 0, 8551, 8553, 5, 1182, 0, 0, 8552, 8527, 1, 0, 0, 0, 8552, 8529, 1, + 0, 0, 0, 8552, 8531, 1, 0, 0, 0, 8552, 8537, 1, 0, 0, 0, 8552, 8543, 1, + 0, 0, 0, 8552, 8546, 1, 0, 0, 0, 8552, 8549, 1, 0, 0, 0, 8553, 683, 1, + 0, 0, 0, 8554, 8563, 5, 416, 0, 0, 8555, 8556, 5, 81, 0, 0, 8556, 8557, + 5, 412, 0, 0, 8557, 8558, 5, 1188, 0, 0, 8558, 8561, 3, 1230, 615, 0, 8559, + 8561, 5, 656, 0, 0, 8560, 8555, 1, 0, 0, 0, 8560, 8559, 1, 0, 0, 0, 8561, + 8564, 1, 0, 0, 0, 8562, 8564, 7, 88, 0, 0, 8563, 8560, 1, 0, 0, 0, 8563, + 8562, 1, 0, 0, 0, 8564, 685, 1, 0, 0, 0, 8565, 8566, 5, 590, 0, 0, 8566, + 8567, 7, 17, 0, 0, 8567, 687, 1, 0, 0, 0, 8568, 8569, 5, 694, 0, 0, 8569, + 8570, 7, 89, 0, 0, 8570, 689, 1, 0, 0, 0, 8571, 8572, 5, 784, 0, 0, 8572, + 8581, 7, 90, 0, 0, 8573, 8574, 5, 1002, 0, 0, 8574, 8581, 3, 1196, 598, + 0, 8575, 8576, 5, 5, 0, 0, 8576, 8577, 5, 1188, 0, 0, 8577, 8581, 3, 1196, + 598, 0, 8578, 8579, 5, 692, 0, 0, 8579, 8581, 7, 91, 0, 0, 8580, 8571, + 1, 0, 0, 0, 8580, 8573, 1, 0, 0, 0, 8580, 8575, 1, 0, 0, 0, 8580, 8578, + 1, 0, 0, 0, 8581, 691, 1, 0, 0, 0, 8582, 8589, 5, 294, 0, 0, 8583, 8589, + 5, 272, 0, 0, 8584, 8589, 5, 606, 0, 0, 8585, 8589, 5, 304, 0, 0, 8586, + 8587, 5, 429, 0, 0, 8587, 8589, 3, 1196, 598, 0, 8588, 8582, 1, 0, 0, 0, + 8588, 8583, 1, 0, 0, 0, 8588, 8584, 1, 0, 0, 0, 8588, 8585, 1, 0, 0, 0, + 8588, 8586, 1, 0, 0, 0, 8589, 693, 1, 0, 0, 0, 8590, 8591, 5, 30, 0, 0, + 8591, 8596, 3, 1196, 598, 0, 8592, 8593, 5, 775, 0, 0, 8593, 8596, 7, 17, + 0, 0, 8594, 8596, 7, 17, 0, 0, 8595, 8590, 1, 0, 0, 0, 8595, 8592, 1, 0, + 0, 0, 8595, 8594, 1, 0, 0, 0, 8596, 695, 1, 0, 0, 0, 8597, 8598, 5, 41, + 0, 0, 8598, 8619, 3, 1196, 598, 0, 8599, 8600, 5, 40, 0, 0, 8600, 8619, + 3, 1196, 598, 0, 8601, 8602, 5, 44, 0, 0, 8602, 8619, 3, 1196, 598, 0, + 8603, 8604, 5, 45, 0, 0, 8604, 8619, 3, 1196, 598, 0, 8605, 8606, 5, 54, + 0, 0, 8606, 8619, 3, 1196, 598, 0, 8607, 8608, 5, 166, 0, 0, 8608, 8609, + 5, 1188, 0, 0, 8609, 8619, 5, 1182, 0, 0, 8610, 8611, 5, 173, 0, 0, 8611, + 8619, 3, 1196, 598, 0, 8612, 8613, 5, 647, 0, 0, 8613, 8619, 3, 1196, 598, + 0, 8614, 8615, 5, 756, 0, 0, 8615, 8619, 3, 1196, 598, 0, 8616, 8617, 5, + 785, 0, 0, 8617, 8619, 3, 1196, 598, 0, 8618, 8597, 1, 0, 0, 0, 8618, 8599, + 1, 0, 0, 0, 8618, 8601, 1, 0, 0, 0, 8618, 8603, 1, 0, 0, 0, 8618, 8605, + 1, 0, 0, 0, 8618, 8607, 1, 0, 0, 0, 8618, 8610, 1, 0, 0, 0, 8618, 8612, + 1, 0, 0, 0, 8618, 8614, 1, 0, 0, 0, 8618, 8616, 1, 0, 0, 0, 8619, 697, + 1, 0, 0, 0, 8620, 8621, 5, 988, 0, 0, 8621, 8622, 5, 1188, 0, 0, 8622, + 8623, 5, 1182, 0, 0, 8623, 8624, 7, 92, 0, 0, 8624, 699, 1, 0, 0, 0, 8625, + 8626, 5, 833, 0, 0, 8626, 8627, 5, 19, 0, 0, 8627, 8632, 5, 1182, 0, 0, + 8628, 8629, 5, 833, 0, 0, 8629, 8632, 5, 447, 0, 0, 8630, 8632, 5, 639, + 0, 0, 8631, 8625, 1, 0, 0, 0, 8631, 8628, 1, 0, 0, 0, 8631, 8630, 1, 0, + 0, 0, 8632, 701, 1, 0, 0, 0, 8633, 8634, 5, 282, 0, 0, 8634, 8637, 5, 456, + 0, 0, 8635, 8636, 5, 440, 0, 0, 8636, 8638, 5, 322, 0, 0, 8637, 8635, 1, + 0, 0, 0, 8637, 8638, 1, 0, 0, 0, 8638, 8655, 1, 0, 0, 0, 8639, 8644, 3, + 704, 352, 0, 8640, 8641, 5, 1208, 0, 0, 8641, 8643, 3, 704, 352, 0, 8642, + 8640, 1, 0, 0, 0, 8643, 8646, 1, 0, 0, 0, 8644, 8642, 1, 0, 0, 0, 8644, + 8645, 1, 0, 0, 0, 8645, 8656, 1, 0, 0, 0, 8646, 8644, 1, 0, 0, 0, 8647, + 8652, 3, 706, 353, 0, 8648, 8649, 5, 1208, 0, 0, 8649, 8651, 3, 706, 353, + 0, 8650, 8648, 1, 0, 0, 0, 8651, 8654, 1, 0, 0, 0, 8652, 8650, 1, 0, 0, + 0, 8652, 8653, 1, 0, 0, 0, 8653, 8656, 1, 0, 0, 0, 8654, 8652, 1, 0, 0, + 0, 8655, 8639, 1, 0, 0, 0, 8655, 8647, 1, 0, 0, 0, 8656, 8658, 1, 0, 0, + 0, 8657, 8659, 5, 1209, 0, 0, 8658, 8657, 1, 0, 0, 0, 8658, 8659, 1, 0, + 0, 0, 8659, 703, 1, 0, 0, 0, 8660, 8661, 3, 1230, 615, 0, 8661, 8662, 5, + 662, 0, 0, 8662, 8663, 3, 1164, 582, 0, 8663, 705, 1, 0, 0, 0, 8664, 8665, + 3, 1230, 615, 0, 8665, 8666, 5, 1201, 0, 0, 8666, 8668, 1, 0, 0, 0, 8667, + 8664, 1, 0, 0, 0, 8667, 8668, 1, 0, 0, 0, 8668, 8669, 1, 0, 0, 0, 8669, + 8670, 3, 1230, 615, 0, 8670, 8671, 5, 1201, 0, 0, 8671, 8672, 3, 1230, + 615, 0, 8672, 707, 1, 0, 0, 0, 8673, 8674, 5, 282, 0, 0, 8674, 8677, 7, + 69, 0, 0, 8675, 8676, 5, 440, 0, 0, 8676, 8678, 5, 322, 0, 0, 8677, 8675, + 1, 0, 0, 0, 8677, 8678, 1, 0, 0, 0, 8678, 8679, 1, 0, 0, 0, 8679, 8684, + 3, 1174, 587, 0, 8680, 8681, 5, 1208, 0, 0, 8681, 8683, 3, 1174, 587, 0, + 8682, 8680, 1, 0, 0, 0, 8683, 8686, 1, 0, 0, 0, 8684, 8682, 1, 0, 0, 0, + 8684, 8685, 1, 0, 0, 0, 8685, 8688, 1, 0, 0, 0, 8686, 8684, 1, 0, 0, 0, + 8687, 8689, 5, 1209, 0, 0, 8688, 8687, 1, 0, 0, 0, 8688, 8689, 1, 0, 0, + 0, 8689, 709, 1, 0, 0, 0, 8690, 8693, 3, 712, 356, 0, 8691, 8693, 3, 714, + 357, 0, 8692, 8690, 1, 0, 0, 0, 8692, 8691, 1, 0, 0, 0, 8693, 711, 1, 0, + 0, 0, 8694, 8695, 5, 282, 0, 0, 8695, 8698, 5, 1013, 0, 0, 8696, 8697, + 5, 440, 0, 0, 8697, 8699, 5, 322, 0, 0, 8698, 8696, 1, 0, 0, 0, 8698, 8699, + 1, 0, 0, 0, 8699, 8700, 1, 0, 0, 0, 8700, 8705, 3, 1172, 586, 0, 8701, + 8702, 5, 1208, 0, 0, 8702, 8704, 3, 1172, 586, 0, 8703, 8701, 1, 0, 0, + 0, 8704, 8707, 1, 0, 0, 0, 8705, 8703, 1, 0, 0, 0, 8705, 8706, 1, 0, 0, + 0, 8706, 8709, 1, 0, 0, 0, 8707, 8705, 1, 0, 0, 0, 8708, 8710, 5, 1209, + 0, 0, 8709, 8708, 1, 0, 0, 0, 8709, 8710, 1, 0, 0, 0, 8710, 713, 1, 0, + 0, 0, 8711, 8712, 5, 282, 0, 0, 8712, 8715, 5, 1013, 0, 0, 8713, 8714, + 5, 440, 0, 0, 8714, 8716, 5, 322, 0, 0, 8715, 8713, 1, 0, 0, 0, 8715, 8716, + 1, 0, 0, 0, 8716, 8717, 1, 0, 0, 0, 8717, 8722, 3, 1172, 586, 0, 8718, + 8719, 5, 1208, 0, 0, 8719, 8721, 3, 1172, 586, 0, 8720, 8718, 1, 0, 0, + 0, 8721, 8724, 1, 0, 0, 0, 8722, 8720, 1, 0, 0, 0, 8722, 8723, 1, 0, 0, + 0, 8723, 8725, 1, 0, 0, 0, 8724, 8722, 1, 0, 0, 0, 8725, 8729, 5, 662, + 0, 0, 8726, 8730, 5, 219, 0, 0, 8727, 8728, 5, 22, 0, 0, 8728, 8730, 5, + 889, 0, 0, 8729, 8726, 1, 0, 0, 0, 8729, 8727, 1, 0, 0, 0, 8730, 8732, + 1, 0, 0, 0, 8731, 8733, 5, 1209, 0, 0, 8732, 8731, 1, 0, 0, 0, 8732, 8733, + 1, 0, 0, 0, 8733, 715, 1, 0, 0, 0, 8734, 8735, 5, 282, 0, 0, 8735, 8738, + 5, 386, 0, 0, 8736, 8737, 5, 440, 0, 0, 8737, 8739, 5, 322, 0, 0, 8738, + 8736, 1, 0, 0, 0, 8738, 8739, 1, 0, 0, 0, 8739, 8740, 1, 0, 0, 0, 8740, + 8745, 3, 1174, 587, 0, 8741, 8742, 5, 1208, 0, 0, 8742, 8744, 3, 1174, + 587, 0, 8743, 8741, 1, 0, 0, 0, 8744, 8747, 1, 0, 0, 0, 8745, 8743, 1, + 0, 0, 0, 8745, 8746, 1, 0, 0, 0, 8746, 8749, 1, 0, 0, 0, 8747, 8745, 1, + 0, 0, 0, 8748, 8750, 5, 1209, 0, 0, 8749, 8748, 1, 0, 0, 0, 8749, 8750, + 1, 0, 0, 0, 8750, 717, 1, 0, 0, 0, 8751, 8752, 5, 282, 0, 0, 8752, 8762, + 5, 945, 0, 0, 8753, 8755, 5, 1208, 0, 0, 8754, 8753, 1, 0, 0, 0, 8754, + 8755, 1, 0, 0, 0, 8755, 8759, 1, 0, 0, 0, 8756, 8757, 3, 1170, 585, 0, + 8757, 8758, 5, 1201, 0, 0, 8758, 8760, 1, 0, 0, 0, 8759, 8756, 1, 0, 0, + 0, 8759, 8760, 1, 0, 0, 0, 8760, 8761, 1, 0, 0, 0, 8761, 8763, 3, 1230, + 615, 0, 8762, 8754, 1, 0, 0, 0, 8763, 8764, 1, 0, 0, 0, 8764, 8762, 1, + 0, 0, 0, 8764, 8765, 1, 0, 0, 0, 8765, 8766, 1, 0, 0, 0, 8766, 8767, 5, + 1209, 0, 0, 8767, 719, 1, 0, 0, 0, 8768, 8769, 5, 282, 0, 0, 8769, 8772, + 5, 980, 0, 0, 8770, 8771, 5, 440, 0, 0, 8771, 8773, 5, 322, 0, 0, 8772, + 8770, 1, 0, 0, 0, 8772, 8773, 1, 0, 0, 0, 8773, 8774, 1, 0, 0, 0, 8774, + 8779, 3, 1170, 585, 0, 8775, 8776, 5, 1208, 0, 0, 8776, 8778, 3, 1170, + 585, 0, 8777, 8775, 1, 0, 0, 0, 8778, 8781, 1, 0, 0, 0, 8779, 8777, 1, + 0, 0, 0, 8779, 8780, 1, 0, 0, 0, 8780, 8783, 1, 0, 0, 0, 8781, 8779, 1, + 0, 0, 0, 8782, 8784, 5, 1209, 0, 0, 8783, 8782, 1, 0, 0, 0, 8783, 8784, + 1, 0, 0, 0, 8784, 721, 1, 0, 0, 0, 8785, 8786, 5, 282, 0, 0, 8786, 8789, + 5, 1065, 0, 0, 8787, 8788, 5, 440, 0, 0, 8788, 8790, 5, 322, 0, 0, 8789, + 8787, 1, 0, 0, 0, 8789, 8790, 1, 0, 0, 0, 8790, 8791, 1, 0, 0, 0, 8791, + 8796, 3, 1172, 586, 0, 8792, 8793, 5, 1208, 0, 0, 8793, 8795, 3, 1172, + 586, 0, 8794, 8792, 1, 0, 0, 0, 8795, 8798, 1, 0, 0, 0, 8796, 8794, 1, + 0, 0, 0, 8796, 8797, 1, 0, 0, 0, 8797, 8800, 1, 0, 0, 0, 8798, 8796, 1, + 0, 0, 0, 8799, 8801, 5, 1209, 0, 0, 8800, 8799, 1, 0, 0, 0, 8800, 8801, + 1, 0, 0, 0, 8801, 723, 1, 0, 0, 0, 8802, 8803, 5, 199, 0, 0, 8803, 8804, + 5, 1024, 0, 0, 8804, 8810, 3, 1172, 586, 0, 8805, 8806, 5, 380, 0, 0, 8806, + 8808, 3, 1222, 611, 0, 8807, 8809, 3, 1200, 600, 0, 8808, 8807, 1, 0, 0, + 0, 8808, 8809, 1, 0, 0, 0, 8809, 8811, 1, 0, 0, 0, 8810, 8805, 1, 0, 0, + 0, 8810, 8811, 1, 0, 0, 0, 8811, 8818, 1, 0, 0, 0, 8812, 8813, 5, 56, 0, + 0, 8813, 8814, 5, 980, 0, 0, 8814, 8815, 5, 1206, 0, 0, 8815, 8816, 3, + 876, 438, 0, 8816, 8817, 5, 1207, 0, 0, 8817, 8819, 1, 0, 0, 0, 8818, 8812, + 1, 0, 0, 0, 8818, 8819, 1, 0, 0, 0, 8819, 725, 1, 0, 0, 0, 8820, 8821, + 5, 282, 0, 0, 8821, 8824, 5, 1024, 0, 0, 8822, 8823, 5, 440, 0, 0, 8823, + 8825, 5, 322, 0, 0, 8824, 8822, 1, 0, 0, 0, 8824, 8825, 1, 0, 0, 0, 8825, + 8826, 1, 0, 0, 0, 8826, 8827, 3, 1172, 586, 0, 8827, 727, 1, 0, 0, 0, 8828, + 8831, 3, 730, 365, 0, 8829, 8831, 3, 732, 366, 0, 8830, 8828, 1, 0, 0, + 0, 8830, 8829, 1, 0, 0, 0, 8831, 729, 1, 0, 0, 0, 8832, 8833, 5, 669, 0, + 0, 8833, 8834, 5, 1206, 0, 0, 8834, 8835, 3, 1230, 615, 0, 8835, 8836, + 5, 1208, 0, 0, 8836, 8837, 5, 1184, 0, 0, 8837, 8838, 5, 1207, 0, 0, 8838, + 731, 1, 0, 0, 0, 8839, 8840, 5, 667, 0, 0, 8840, 8841, 5, 1206, 0, 0, 8841, + 8842, 5, 1184, 0, 0, 8842, 8843, 5, 1208, 0, 0, 8843, 8844, 5, 1184, 0, + 0, 8844, 8845, 5, 1207, 0, 0, 8845, 8847, 5, 1201, 0, 0, 8846, 8848, 3, + 1230, 615, 0, 8847, 8846, 1, 0, 0, 0, 8847, 8848, 1, 0, 0, 0, 8848, 8849, + 1, 0, 0, 0, 8849, 8851, 5, 1201, 0, 0, 8850, 8852, 3, 1230, 615, 0, 8851, + 8850, 1, 0, 0, 0, 8851, 8852, 1, 0, 0, 0, 8852, 8853, 1, 0, 0, 0, 8853, + 8854, 5, 1201, 0, 0, 8854, 8855, 3, 1230, 615, 0, 8855, 733, 1, 0, 0, 0, + 8856, 8857, 5, 242, 0, 0, 8857, 8859, 5, 1180, 0, 0, 8858, 8860, 5, 56, + 0, 0, 8859, 8858, 1, 0, 0, 0, 8859, 8860, 1, 0, 0, 0, 8860, 8864, 1, 0, + 0, 0, 8861, 8865, 3, 1222, 611, 0, 8862, 8865, 3, 868, 434, 0, 8863, 8865, + 3, 1170, 585, 0, 8864, 8861, 1, 0, 0, 0, 8864, 8862, 1, 0, 0, 0, 8864, + 8863, 1, 0, 0, 0, 8865, 8895, 1, 0, 0, 0, 8866, 8867, 5, 242, 0, 0, 8867, + 8872, 3, 866, 433, 0, 8868, 8869, 5, 1208, 0, 0, 8869, 8871, 3, 866, 433, + 0, 8870, 8868, 1, 0, 0, 0, 8871, 8874, 1, 0, 0, 0, 8872, 8870, 1, 0, 0, + 0, 8872, 8873, 1, 0, 0, 0, 8873, 8895, 1, 0, 0, 0, 8874, 8872, 1, 0, 0, + 0, 8875, 8876, 5, 242, 0, 0, 8876, 8878, 5, 1180, 0, 0, 8877, 8879, 5, + 56, 0, 0, 8878, 8877, 1, 0, 0, 0, 8878, 8879, 1, 0, 0, 0, 8879, 8880, 1, + 0, 0, 0, 8880, 8895, 3, 872, 436, 0, 8881, 8882, 5, 1077, 0, 0, 8882, 8883, + 5, 1090, 0, 0, 8883, 8884, 5, 1206, 0, 0, 8884, 8889, 3, 736, 368, 0, 8885, + 8886, 5, 1208, 0, 0, 8886, 8888, 3, 736, 368, 0, 8887, 8885, 1, 0, 0, 0, + 8888, 8891, 1, 0, 0, 0, 8889, 8887, 1, 0, 0, 0, 8889, 8890, 1, 0, 0, 0, + 8890, 8892, 1, 0, 0, 0, 8891, 8889, 1, 0, 0, 0, 8892, 8893, 5, 1207, 0, + 0, 8893, 8895, 1, 0, 0, 0, 8894, 8856, 1, 0, 0, 0, 8894, 8866, 1, 0, 0, + 0, 8894, 8875, 1, 0, 0, 0, 8894, 8881, 1, 0, 0, 0, 8895, 735, 1, 0, 0, + 0, 8896, 8897, 5, 1184, 0, 0, 8897, 8898, 5, 56, 0, 0, 8898, 8902, 3, 1230, + 615, 0, 8899, 8900, 5, 245, 0, 0, 8900, 8902, 5, 1184, 0, 0, 8901, 8896, + 1, 0, 0, 0, 8901, 8899, 1, 0, 0, 0, 8902, 737, 1, 0, 0, 0, 8903, 8905, + 5, 149, 0, 0, 8904, 8906, 5, 406, 0, 0, 8905, 8904, 1, 0, 0, 0, 8905, 8906, + 1, 0, 0, 0, 8906, 8907, 1, 0, 0, 0, 8907, 8909, 3, 1194, 597, 0, 8908, + 8910, 5, 1209, 0, 0, 8909, 8908, 1, 0, 0, 0, 8909, 8910, 1, 0, 0, 0, 8910, + 8933, 1, 0, 0, 0, 8911, 8913, 5, 241, 0, 0, 8912, 8914, 5, 406, 0, 0, 8913, + 8912, 1, 0, 0, 0, 8913, 8914, 1, 0, 0, 0, 8914, 8916, 1, 0, 0, 0, 8915, + 8917, 5, 213, 0, 0, 8916, 8915, 1, 0, 0, 0, 8916, 8917, 1, 0, 0, 0, 8917, + 8918, 1, 0, 0, 0, 8918, 8920, 3, 1194, 597, 0, 8919, 8921, 5, 1209, 0, + 0, 8920, 8919, 1, 0, 0, 0, 8920, 8921, 1, 0, 0, 0, 8921, 8933, 1, 0, 0, + 0, 8922, 8933, 3, 912, 456, 0, 8923, 8933, 3, 918, 459, 0, 8924, 8926, + 5, 666, 0, 0, 8925, 8927, 5, 406, 0, 0, 8926, 8925, 1, 0, 0, 0, 8926, 8927, + 1, 0, 0, 0, 8927, 8928, 1, 0, 0, 0, 8928, 8930, 3, 1194, 597, 0, 8929, + 8931, 5, 1209, 0, 0, 8930, 8929, 1, 0, 0, 0, 8930, 8931, 1, 0, 0, 0, 8931, + 8933, 1, 0, 0, 0, 8932, 8903, 1, 0, 0, 0, 8932, 8911, 1, 0, 0, 0, 8932, + 8922, 1, 0, 0, 0, 8932, 8923, 1, 0, 0, 0, 8932, 8924, 1, 0, 0, 0, 8933, + 739, 1, 0, 0, 0, 8934, 8935, 5, 85, 0, 0, 8935, 8936, 5, 219, 0, 0, 8936, + 8949, 3, 1230, 615, 0, 8937, 8946, 5, 779, 0, 0, 8938, 8940, 5, 1208, 0, + 0, 8939, 8938, 1, 0, 0, 0, 8939, 8940, 1, 0, 0, 0, 8940, 8941, 1, 0, 0, + 0, 8941, 8942, 7, 93, 0, 0, 8942, 8943, 5, 1188, 0, 0, 8943, 8945, 5, 1184, + 0, 0, 8944, 8939, 1, 0, 0, 0, 8945, 8948, 1, 0, 0, 0, 8946, 8944, 1, 0, + 0, 0, 8946, 8947, 1, 0, 0, 0, 8947, 8950, 1, 0, 0, 0, 8948, 8946, 1, 0, + 0, 0, 8949, 8937, 1, 0, 0, 0, 8949, 8950, 1, 0, 0, 0, 8950, 8959, 1, 0, + 0, 0, 8951, 8953, 5, 1208, 0, 0, 8952, 8951, 1, 0, 0, 0, 8952, 8953, 1, + 0, 0, 0, 8953, 8954, 1, 0, 0, 0, 8954, 8955, 7, 93, 0, 0, 8955, 8956, 5, + 1188, 0, 0, 8956, 8958, 5, 1184, 0, 0, 8957, 8952, 1, 0, 0, 0, 8958, 8961, + 1, 0, 0, 0, 8959, 8957, 1, 0, 0, 0, 8959, 8960, 1, 0, 0, 0, 8960, 8985, + 1, 0, 0, 0, 8961, 8959, 1, 0, 0, 0, 8962, 8967, 5, 1000, 0, 0, 8963, 8965, + 5, 1208, 0, 0, 8964, 8963, 1, 0, 0, 0, 8964, 8965, 1, 0, 0, 0, 8965, 8966, + 1, 0, 0, 0, 8966, 8968, 3, 1230, 615, 0, 8967, 8964, 1, 0, 0, 0, 8968, + 8969, 1, 0, 0, 0, 8969, 8967, 1, 0, 0, 0, 8969, 8970, 1, 0, 0, 0, 8970, + 8986, 1, 0, 0, 0, 8971, 8981, 5, 1000, 0, 0, 8972, 8974, 5, 1208, 0, 0, + 8973, 8972, 1, 0, 0, 0, 8973, 8974, 1, 0, 0, 0, 8974, 8975, 1, 0, 0, 0, + 8975, 8976, 7, 94, 0, 0, 8976, 8979, 5, 1188, 0, 0, 8977, 8980, 5, 1184, + 0, 0, 8978, 8980, 3, 1230, 615, 0, 8979, 8977, 1, 0, 0, 0, 8979, 8978, + 1, 0, 0, 0, 8980, 8982, 1, 0, 0, 0, 8981, 8973, 1, 0, 0, 0, 8982, 8983, + 1, 0, 0, 0, 8983, 8981, 1, 0, 0, 0, 8983, 8984, 1, 0, 0, 0, 8984, 8986, + 1, 0, 0, 0, 8985, 8962, 1, 0, 0, 0, 8985, 8971, 1, 0, 0, 0, 8986, 9020, + 1, 0, 0, 0, 8987, 8988, 5, 588, 0, 0, 8988, 8993, 5, 1000, 0, 0, 8989, + 8991, 5, 1208, 0, 0, 8990, 8989, 1, 0, 0, 0, 8990, 8991, 1, 0, 0, 0, 8991, + 8992, 1, 0, 0, 0, 8992, 8994, 3, 1230, 615, 0, 8993, 8990, 1, 0, 0, 0, + 8994, 8995, 1, 0, 0, 0, 8995, 8993, 1, 0, 0, 0, 8995, 8996, 1, 0, 0, 0, + 8996, 8998, 1, 0, 0, 0, 8997, 8987, 1, 0, 0, 0, 8998, 8999, 1, 0, 0, 0, + 8999, 8997, 1, 0, 0, 0, 8999, 9000, 1, 0, 0, 0, 9000, 9021, 1, 0, 0, 0, + 9001, 9002, 5, 588, 0, 0, 9002, 9012, 5, 1000, 0, 0, 9003, 9005, 5, 1208, + 0, 0, 9004, 9003, 1, 0, 0, 0, 9004, 9005, 1, 0, 0, 0, 9005, 9006, 1, 0, + 0, 0, 9006, 9007, 7, 94, 0, 0, 9007, 9010, 5, 1188, 0, 0, 9008, 9011, 5, + 1184, 0, 0, 9009, 9011, 3, 1230, 615, 0, 9010, 9008, 1, 0, 0, 0, 9010, + 9009, 1, 0, 0, 0, 9011, 9013, 1, 0, 0, 0, 9012, 9004, 1, 0, 0, 0, 9013, + 9014, 1, 0, 0, 0, 9014, 9012, 1, 0, 0, 0, 9014, 9015, 1, 0, 0, 0, 9015, + 9017, 1, 0, 0, 0, 9016, 9001, 1, 0, 0, 0, 9017, 9018, 1, 0, 0, 0, 9018, + 9016, 1, 0, 0, 0, 9018, 9019, 1, 0, 0, 0, 9019, 9021, 1, 0, 0, 0, 9020, + 8997, 1, 0, 0, 0, 9020, 9016, 1, 0, 0, 0, 9020, 9021, 1, 0, 0, 0, 9021, + 9182, 1, 0, 0, 0, 9022, 9179, 5, 1077, 0, 0, 9023, 9025, 5, 1208, 0, 0, + 9024, 9023, 1, 0, 0, 0, 9024, 9025, 1, 0, 0, 0, 9025, 9026, 1, 0, 0, 0, + 9026, 9178, 5, 268, 0, 0, 9027, 9029, 5, 1208, 0, 0, 9028, 9027, 1, 0, + 0, 0, 9028, 9029, 1, 0, 0, 0, 9029, 9030, 1, 0, 0, 0, 9030, 9178, 5, 194, + 0, 0, 9031, 9033, 5, 1208, 0, 0, 9032, 9031, 1, 0, 0, 0, 9032, 9033, 1, + 0, 0, 0, 9033, 9034, 1, 0, 0, 0, 9034, 9178, 7, 95, 0, 0, 9035, 9037, 5, + 1208, 0, 0, 9036, 9035, 1, 0, 0, 0, 9036, 9037, 1, 0, 0, 0, 9037, 9038, + 1, 0, 0, 0, 9038, 9039, 5, 261, 0, 0, 9039, 9042, 5, 1188, 0, 0, 9040, + 9043, 5, 1184, 0, 0, 9041, 9043, 3, 1230, 615, 0, 9042, 9040, 1, 0, 0, + 0, 9042, 9041, 1, 0, 0, 0, 9043, 9178, 1, 0, 0, 0, 9044, 9046, 5, 1208, + 0, 0, 9045, 9044, 1, 0, 0, 0, 9045, 9046, 1, 0, 0, 0, 9046, 9047, 1, 0, + 0, 0, 9047, 9048, 5, 597, 0, 0, 9048, 9049, 5, 1188, 0, 0, 9049, 9178, + 3, 1230, 615, 0, 9050, 9052, 5, 1208, 0, 0, 9051, 9050, 1, 0, 0, 0, 9051, + 9052, 1, 0, 0, 0, 9052, 9053, 1, 0, 0, 0, 9053, 9178, 5, 202, 0, 0, 9054, + 9056, 5, 1208, 0, 0, 9055, 9054, 1, 0, 0, 0, 9055, 9056, 1, 0, 0, 0, 9056, + 9057, 1, 0, 0, 0, 9057, 9178, 5, 358, 0, 0, 9058, 9060, 5, 1208, 0, 0, + 9059, 9058, 1, 0, 0, 0, 9059, 9060, 1, 0, 0, 0, 9060, 9073, 1, 0, 0, 0, + 9061, 9062, 5, 326, 0, 0, 9062, 9065, 5, 1188, 0, 0, 9063, 9066, 5, 1184, + 0, 0, 9064, 9066, 3, 1230, 615, 0, 9065, 9063, 1, 0, 0, 0, 9065, 9064, + 1, 0, 0, 0, 9066, 9074, 1, 0, 0, 0, 9067, 9068, 5, 822, 0, 0, 9068, 9071, + 5, 1188, 0, 0, 9069, 9072, 5, 1182, 0, 0, 9070, 9072, 3, 1230, 615, 0, + 9071, 9069, 1, 0, 0, 0, 9071, 9070, 1, 0, 0, 0, 9072, 9074, 1, 0, 0, 0, + 9073, 9061, 1, 0, 0, 0, 9073, 9067, 1, 0, 0, 0, 9074, 9178, 1, 0, 0, 0, + 9075, 9077, 5, 1208, 0, 0, 9076, 9075, 1, 0, 0, 0, 9076, 9077, 1, 0, 0, + 0, 9077, 9078, 1, 0, 0, 0, 9078, 9178, 7, 96, 0, 0, 9079, 9081, 5, 1208, + 0, 0, 9080, 9079, 1, 0, 0, 0, 9080, 9081, 1, 0, 0, 0, 9081, 9082, 1, 0, + 0, 0, 9082, 9178, 7, 97, 0, 0, 9083, 9085, 5, 1208, 0, 0, 9084, 9083, 1, + 0, 0, 0, 9084, 9085, 1, 0, 0, 0, 9085, 9086, 1, 0, 0, 0, 9086, 9178, 7, + 98, 0, 0, 9087, 9089, 5, 1208, 0, 0, 9088, 9087, 1, 0, 0, 0, 9088, 9089, + 1, 0, 0, 0, 9089, 9090, 1, 0, 0, 0, 9090, 9091, 5, 571, 0, 0, 9091, 9094, + 5, 1188, 0, 0, 9092, 9095, 5, 1184, 0, 0, 9093, 9095, 3, 1230, 615, 0, + 9094, 9092, 1, 0, 0, 0, 9094, 9093, 1, 0, 0, 0, 9095, 9178, 1, 0, 0, 0, + 9096, 9098, 5, 1208, 0, 0, 9097, 9096, 1, 0, 0, 0, 9097, 9098, 1, 0, 0, + 0, 9098, 9099, 1, 0, 0, 0, 9099, 9100, 5, 572, 0, 0, 9100, 9101, 5, 1188, + 0, 0, 9101, 9178, 5, 1184, 0, 0, 9102, 9104, 5, 1208, 0, 0, 9103, 9102, + 1, 0, 0, 0, 9103, 9104, 1, 0, 0, 0, 9104, 9105, 1, 0, 0, 0, 9105, 9106, + 5, 101, 0, 0, 9106, 9109, 5, 1188, 0, 0, 9107, 9110, 5, 1182, 0, 0, 9108, + 9110, 3, 1230, 615, 0, 9109, 9107, 1, 0, 0, 0, 9109, 9108, 1, 0, 0, 0, + 9110, 9178, 1, 0, 0, 0, 9111, 9113, 5, 1208, 0, 0, 9112, 9111, 1, 0, 0, + 0, 9112, 9113, 1, 0, 0, 0, 9113, 9114, 1, 0, 0, 0, 9114, 9115, 5, 108, + 0, 0, 9115, 9118, 5, 1188, 0, 0, 9116, 9119, 5, 1182, 0, 0, 9117, 9119, + 3, 1230, 615, 0, 9118, 9116, 1, 0, 0, 0, 9118, 9117, 1, 0, 0, 0, 9119, + 9178, 1, 0, 0, 0, 9120, 9122, 5, 1208, 0, 0, 9121, 9120, 1, 0, 0, 0, 9121, + 9122, 1, 0, 0, 0, 9122, 9123, 1, 0, 0, 0, 9123, 9124, 5, 554, 0, 0, 9124, + 9127, 5, 1188, 0, 0, 9125, 9128, 5, 1182, 0, 0, 9126, 9128, 3, 1230, 615, + 0, 9127, 9125, 1, 0, 0, 0, 9127, 9126, 1, 0, 0, 0, 9128, 9178, 1, 0, 0, + 0, 9129, 9131, 5, 1208, 0, 0, 9130, 9129, 1, 0, 0, 0, 9130, 9131, 1, 0, + 0, 0, 9131, 9132, 1, 0, 0, 0, 9132, 9178, 7, 99, 0, 0, 9133, 9135, 5, 1208, + 0, 0, 9134, 9133, 1, 0, 0, 0, 9134, 9135, 1, 0, 0, 0, 9135, 9136, 1, 0, + 0, 0, 9136, 9178, 7, 100, 0, 0, 9137, 9139, 5, 1208, 0, 0, 9138, 9137, + 1, 0, 0, 0, 9138, 9139, 1, 0, 0, 0, 9139, 9140, 1, 0, 0, 0, 9140, 9178, + 5, 816, 0, 0, 9141, 9143, 5, 1208, 0, 0, 9142, 9141, 1, 0, 0, 0, 9142, + 9143, 1, 0, 0, 0, 9143, 9144, 1, 0, 0, 0, 9144, 9147, 5, 948, 0, 0, 9145, + 9146, 5, 1188, 0, 0, 9146, 9148, 5, 1182, 0, 0, 9147, 9145, 1, 0, 0, 0, + 9147, 9148, 1, 0, 0, 0, 9148, 9178, 1, 0, 0, 0, 9149, 9151, 5, 1208, 0, + 0, 9150, 9149, 1, 0, 0, 0, 9150, 9151, 1, 0, 0, 0, 9151, 9152, 1, 0, 0, + 0, 9152, 9178, 7, 101, 0, 0, 9153, 9155, 5, 1208, 0, 0, 9154, 9153, 1, + 0, 0, 0, 9154, 9155, 1, 0, 0, 0, 9155, 9156, 1, 0, 0, 0, 9156, 9178, 7, + 102, 0, 0, 9157, 9159, 5, 1208, 0, 0, 9158, 9157, 1, 0, 0, 0, 9158, 9159, + 1, 0, 0, 0, 9159, 9160, 1, 0, 0, 0, 9160, 9161, 5, 297, 0, 0, 9161, 9162, + 5, 1206, 0, 0, 9162, 9163, 5, 21, 0, 0, 9163, 9164, 5, 1188, 0, 0, 9164, + 9165, 7, 103, 0, 0, 9165, 9166, 5, 1208, 0, 0, 9166, 9167, 5, 889, 0, 0, + 9167, 9168, 5, 123, 0, 0, 9168, 9175, 5, 1188, 0, 0, 9169, 9176, 3, 1230, + 615, 0, 9170, 9171, 5, 889, 0, 0, 9171, 9172, 5, 61, 0, 0, 9172, 9173, + 5, 498, 0, 0, 9173, 9174, 5, 1188, 0, 0, 9174, 9176, 3, 1230, 615, 0, 9175, + 9169, 1, 0, 0, 0, 9175, 9170, 1, 0, 0, 0, 9176, 9178, 1, 0, 0, 0, 9177, + 9024, 1, 0, 0, 0, 9177, 9028, 1, 0, 0, 0, 9177, 9032, 1, 0, 0, 0, 9177, + 9036, 1, 0, 0, 0, 9177, 9045, 1, 0, 0, 0, 9177, 9051, 1, 0, 0, 0, 9177, + 9055, 1, 0, 0, 0, 9177, 9059, 1, 0, 0, 0, 9177, 9076, 1, 0, 0, 0, 9177, + 9080, 1, 0, 0, 0, 9177, 9084, 1, 0, 0, 0, 9177, 9088, 1, 0, 0, 0, 9177, + 9097, 1, 0, 0, 0, 9177, 9103, 1, 0, 0, 0, 9177, 9112, 1, 0, 0, 0, 9177, + 9121, 1, 0, 0, 0, 9177, 9130, 1, 0, 0, 0, 9177, 9134, 1, 0, 0, 0, 9177, + 9138, 1, 0, 0, 0, 9177, 9142, 1, 0, 0, 0, 9177, 9150, 1, 0, 0, 0, 9177, + 9154, 1, 0, 0, 0, 9177, 9158, 1, 0, 0, 0, 9178, 9181, 1, 0, 0, 0, 9179, + 9177, 1, 0, 0, 0, 9179, 9180, 1, 0, 0, 0, 9180, 9183, 1, 0, 0, 0, 9181, + 9179, 1, 0, 0, 0, 9182, 9022, 1, 0, 0, 0, 9182, 9183, 1, 0, 0, 0, 9183, + 741, 1, 0, 0, 0, 9184, 9185, 5, 85, 0, 0, 9185, 9186, 5, 536, 0, 0, 9186, + 9210, 3, 1230, 615, 0, 9187, 9192, 5, 1000, 0, 0, 9188, 9190, 5, 1208, + 0, 0, 9189, 9188, 1, 0, 0, 0, 9189, 9190, 1, 0, 0, 0, 9190, 9191, 1, 0, + 0, 0, 9191, 9193, 3, 1230, 615, 0, 9192, 9189, 1, 0, 0, 0, 9193, 9194, + 1, 0, 0, 0, 9194, 9192, 1, 0, 0, 0, 9194, 9195, 1, 0, 0, 0, 9195, 9211, + 1, 0, 0, 0, 9196, 9206, 5, 1000, 0, 0, 9197, 9199, 5, 1208, 0, 0, 9198, + 9197, 1, 0, 0, 0, 9198, 9199, 1, 0, 0, 0, 9199, 9200, 1, 0, 0, 0, 9200, + 9201, 7, 94, 0, 0, 9201, 9204, 5, 1188, 0, 0, 9202, 9205, 5, 1184, 0, 0, + 9203, 9205, 3, 1230, 615, 0, 9204, 9202, 1, 0, 0, 0, 9204, 9203, 1, 0, + 0, 0, 9205, 9207, 1, 0, 0, 0, 9206, 9198, 1, 0, 0, 0, 9207, 9208, 1, 0, + 0, 0, 9208, 9206, 1, 0, 0, 0, 9208, 9209, 1, 0, 0, 0, 9209, 9211, 1, 0, + 0, 0, 9210, 9187, 1, 0, 0, 0, 9210, 9196, 1, 0, 0, 0, 9211, 9245, 1, 0, + 0, 0, 9212, 9213, 5, 588, 0, 0, 9213, 9218, 5, 1000, 0, 0, 9214, 9216, + 5, 1208, 0, 0, 9215, 9214, 1, 0, 0, 0, 9215, 9216, 1, 0, 0, 0, 9216, 9217, + 1, 0, 0, 0, 9217, 9219, 3, 1230, 615, 0, 9218, 9215, 1, 0, 0, 0, 9219, + 9220, 1, 0, 0, 0, 9220, 9218, 1, 0, 0, 0, 9220, 9221, 1, 0, 0, 0, 9221, + 9223, 1, 0, 0, 0, 9222, 9212, 1, 0, 0, 0, 9223, 9224, 1, 0, 0, 0, 9224, + 9222, 1, 0, 0, 0, 9224, 9225, 1, 0, 0, 0, 9225, 9246, 1, 0, 0, 0, 9226, + 9227, 5, 588, 0, 0, 9227, 9237, 5, 1000, 0, 0, 9228, 9230, 5, 1208, 0, + 0, 9229, 9228, 1, 0, 0, 0, 9229, 9230, 1, 0, 0, 0, 9230, 9231, 1, 0, 0, + 0, 9231, 9232, 7, 94, 0, 0, 9232, 9235, 5, 1188, 0, 0, 9233, 9236, 5, 1184, + 0, 0, 9234, 9236, 3, 1230, 615, 0, 9235, 9233, 1, 0, 0, 0, 9235, 9234, + 1, 0, 0, 0, 9236, 9238, 1, 0, 0, 0, 9237, 9229, 1, 0, 0, 0, 9238, 9239, + 1, 0, 0, 0, 9239, 9237, 1, 0, 0, 0, 9239, 9240, 1, 0, 0, 0, 9240, 9242, + 1, 0, 0, 0, 9241, 9226, 1, 0, 0, 0, 9242, 9243, 1, 0, 0, 0, 9243, 9241, + 1, 0, 0, 0, 9243, 9244, 1, 0, 0, 0, 9244, 9246, 1, 0, 0, 0, 9245, 9222, + 1, 0, 0, 0, 9245, 9241, 1, 0, 0, 0, 9245, 9246, 1, 0, 0, 0, 9246, 9420, + 1, 0, 0, 0, 9247, 9417, 5, 1077, 0, 0, 9248, 9250, 5, 1208, 0, 0, 9249, + 9248, 1, 0, 0, 0, 9249, 9250, 1, 0, 0, 0, 9250, 9251, 1, 0, 0, 0, 9251, + 9416, 5, 268, 0, 0, 9252, 9254, 5, 1208, 0, 0, 9253, 9252, 1, 0, 0, 0, + 9253, 9254, 1, 0, 0, 0, 9254, 9255, 1, 0, 0, 0, 9255, 9416, 5, 194, 0, + 0, 9256, 9258, 5, 1208, 0, 0, 9257, 9256, 1, 0, 0, 0, 9257, 9258, 1, 0, + 0, 0, 9258, 9259, 1, 0, 0, 0, 9259, 9416, 7, 95, 0, 0, 9260, 9262, 5, 1208, + 0, 0, 9261, 9260, 1, 0, 0, 0, 9261, 9262, 1, 0, 0, 0, 9262, 9263, 1, 0, + 0, 0, 9263, 9264, 5, 261, 0, 0, 9264, 9267, 5, 1188, 0, 0, 9265, 9268, + 5, 1184, 0, 0, 9266, 9268, 3, 1230, 615, 0, 9267, 9265, 1, 0, 0, 0, 9267, + 9266, 1, 0, 0, 0, 9268, 9416, 1, 0, 0, 0, 9269, 9271, 5, 1208, 0, 0, 9270, + 9269, 1, 0, 0, 0, 9270, 9271, 1, 0, 0, 0, 9271, 9272, 1, 0, 0, 0, 9272, + 9273, 5, 597, 0, 0, 9273, 9274, 5, 1188, 0, 0, 9274, 9416, 3, 1230, 615, + 0, 9275, 9277, 5, 1208, 0, 0, 9276, 9275, 1, 0, 0, 0, 9276, 9277, 1, 0, + 0, 0, 9277, 9278, 1, 0, 0, 0, 9278, 9416, 5, 202, 0, 0, 9279, 9281, 5, + 1208, 0, 0, 9280, 9279, 1, 0, 0, 0, 9280, 9281, 1, 0, 0, 0, 9281, 9282, + 1, 0, 0, 0, 9282, 9416, 5, 358, 0, 0, 9283, 9285, 5, 1208, 0, 0, 9284, + 9283, 1, 0, 0, 0, 9284, 9285, 1, 0, 0, 0, 9285, 9298, 1, 0, 0, 0, 9286, + 9287, 5, 326, 0, 0, 9287, 9290, 5, 1188, 0, 0, 9288, 9291, 5, 1184, 0, + 0, 9289, 9291, 3, 1230, 615, 0, 9290, 9288, 1, 0, 0, 0, 9290, 9289, 1, + 0, 0, 0, 9291, 9299, 1, 0, 0, 0, 9292, 9293, 5, 822, 0, 0, 9293, 9296, + 5, 1188, 0, 0, 9294, 9297, 5, 1182, 0, 0, 9295, 9297, 3, 1230, 615, 0, + 9296, 9294, 1, 0, 0, 0, 9296, 9295, 1, 0, 0, 0, 9297, 9299, 1, 0, 0, 0, + 9298, 9286, 1, 0, 0, 0, 9298, 9292, 1, 0, 0, 0, 9299, 9416, 1, 0, 0, 0, + 9300, 9302, 5, 1208, 0, 0, 9301, 9300, 1, 0, 0, 0, 9301, 9302, 1, 0, 0, + 0, 9302, 9303, 1, 0, 0, 0, 9303, 9416, 7, 96, 0, 0, 9304, 9306, 5, 1208, + 0, 0, 9305, 9304, 1, 0, 0, 0, 9305, 9306, 1, 0, 0, 0, 9306, 9307, 1, 0, + 0, 0, 9307, 9416, 7, 97, 0, 0, 9308, 9310, 5, 1208, 0, 0, 9309, 9308, 1, + 0, 0, 0, 9309, 9310, 1, 0, 0, 0, 9310, 9311, 1, 0, 0, 0, 9311, 9416, 7, + 98, 0, 0, 9312, 9314, 5, 1208, 0, 0, 9313, 9312, 1, 0, 0, 0, 9313, 9314, + 1, 0, 0, 0, 9314, 9315, 1, 0, 0, 0, 9315, 9316, 5, 571, 0, 0, 9316, 9319, + 5, 1188, 0, 0, 9317, 9320, 5, 1184, 0, 0, 9318, 9320, 3, 1230, 615, 0, + 9319, 9317, 1, 0, 0, 0, 9319, 9318, 1, 0, 0, 0, 9320, 9416, 1, 0, 0, 0, + 9321, 9323, 5, 1208, 0, 0, 9322, 9321, 1, 0, 0, 0, 9322, 9323, 1, 0, 0, + 0, 9323, 9324, 1, 0, 0, 0, 9324, 9325, 5, 572, 0, 0, 9325, 9326, 5, 1188, + 0, 0, 9326, 9416, 5, 1184, 0, 0, 9327, 9329, 5, 1208, 0, 0, 9328, 9327, + 1, 0, 0, 0, 9328, 9329, 1, 0, 0, 0, 9329, 9330, 1, 0, 0, 0, 9330, 9331, + 5, 101, 0, 0, 9331, 9334, 5, 1188, 0, 0, 9332, 9335, 5, 1182, 0, 0, 9333, + 9335, 3, 1230, 615, 0, 9334, 9332, 1, 0, 0, 0, 9334, 9333, 1, 0, 0, 0, + 9335, 9416, 1, 0, 0, 0, 9336, 9338, 5, 1208, 0, 0, 9337, 9336, 1, 0, 0, + 0, 9337, 9338, 1, 0, 0, 0, 9338, 9339, 1, 0, 0, 0, 9339, 9340, 5, 108, + 0, 0, 9340, 9343, 5, 1188, 0, 0, 9341, 9344, 5, 1182, 0, 0, 9342, 9344, + 3, 1230, 615, 0, 9343, 9341, 1, 0, 0, 0, 9343, 9342, 1, 0, 0, 0, 9344, + 9416, 1, 0, 0, 0, 9345, 9347, 5, 1208, 0, 0, 9346, 9345, 1, 0, 0, 0, 9346, + 9347, 1, 0, 0, 0, 9347, 9348, 1, 0, 0, 0, 9348, 9349, 5, 554, 0, 0, 9349, + 9352, 5, 1188, 0, 0, 9350, 9353, 5, 1182, 0, 0, 9351, 9353, 3, 1230, 615, + 0, 9352, 9350, 1, 0, 0, 0, 9352, 9351, 1, 0, 0, 0, 9353, 9416, 1, 0, 0, + 0, 9354, 9356, 5, 1208, 0, 0, 9355, 9354, 1, 0, 0, 0, 9355, 9356, 1, 0, + 0, 0, 9356, 9357, 1, 0, 0, 0, 9357, 9416, 7, 99, 0, 0, 9358, 9360, 5, 1208, + 0, 0, 9359, 9358, 1, 0, 0, 0, 9359, 9360, 1, 0, 0, 0, 9360, 9361, 1, 0, + 0, 0, 9361, 9416, 7, 100, 0, 0, 9362, 9364, 5, 1208, 0, 0, 9363, 9362, + 1, 0, 0, 0, 9363, 9364, 1, 0, 0, 0, 9364, 9365, 1, 0, 0, 0, 9365, 9416, + 5, 816, 0, 0, 9366, 9368, 5, 1208, 0, 0, 9367, 9366, 1, 0, 0, 0, 9367, + 9368, 1, 0, 0, 0, 9368, 9369, 1, 0, 0, 0, 9369, 9372, 5, 948, 0, 0, 9370, + 9371, 5, 1188, 0, 0, 9371, 9373, 5, 1182, 0, 0, 9372, 9370, 1, 0, 0, 0, + 9372, 9373, 1, 0, 0, 0, 9373, 9416, 1, 0, 0, 0, 9374, 9376, 5, 1208, 0, + 0, 9375, 9374, 1, 0, 0, 0, 9375, 9376, 1, 0, 0, 0, 9376, 9377, 1, 0, 0, + 0, 9377, 9416, 7, 101, 0, 0, 9378, 9380, 5, 1208, 0, 0, 9379, 9378, 1, + 0, 0, 0, 9379, 9380, 1, 0, 0, 0, 9380, 9381, 1, 0, 0, 0, 9381, 9416, 7, + 102, 0, 0, 9382, 9384, 5, 1208, 0, 0, 9383, 9382, 1, 0, 0, 0, 9383, 9384, + 1, 0, 0, 0, 9384, 9389, 1, 0, 0, 0, 9385, 9390, 5, 624, 0, 0, 9386, 9387, + 5, 938, 0, 0, 9387, 9388, 5, 1188, 0, 0, 9388, 9390, 5, 1184, 0, 0, 9389, + 9385, 1, 0, 0, 0, 9389, 9386, 1, 0, 0, 0, 9390, 9416, 1, 0, 0, 0, 9391, + 9393, 5, 1208, 0, 0, 9392, 9391, 1, 0, 0, 0, 9392, 9393, 1, 0, 0, 0, 9393, + 9394, 1, 0, 0, 0, 9394, 9416, 5, 638, 0, 0, 9395, 9397, 5, 1208, 0, 0, + 9396, 9395, 1, 0, 0, 0, 9396, 9397, 1, 0, 0, 0, 9397, 9398, 1, 0, 0, 0, + 9398, 9399, 5, 297, 0, 0, 9399, 9400, 5, 1206, 0, 0, 9400, 9401, 5, 21, + 0, 0, 9401, 9402, 5, 1188, 0, 0, 9402, 9403, 7, 103, 0, 0, 9403, 9404, + 5, 1208, 0, 0, 9404, 9405, 5, 889, 0, 0, 9405, 9406, 5, 123, 0, 0, 9406, + 9413, 5, 1188, 0, 0, 9407, 9414, 3, 1230, 615, 0, 9408, 9409, 5, 889, 0, + 0, 9409, 9410, 5, 61, 0, 0, 9410, 9411, 5, 498, 0, 0, 9411, 9412, 5, 1188, + 0, 0, 9412, 9414, 3, 1230, 615, 0, 9413, 9407, 1, 0, 0, 0, 9413, 9408, + 1, 0, 0, 0, 9414, 9416, 1, 0, 0, 0, 9415, 9249, 1, 0, 0, 0, 9415, 9253, + 1, 0, 0, 0, 9415, 9257, 1, 0, 0, 0, 9415, 9261, 1, 0, 0, 0, 9415, 9270, + 1, 0, 0, 0, 9415, 9276, 1, 0, 0, 0, 9415, 9280, 1, 0, 0, 0, 9415, 9284, + 1, 0, 0, 0, 9415, 9301, 1, 0, 0, 0, 9415, 9305, 1, 0, 0, 0, 9415, 9309, + 1, 0, 0, 0, 9415, 9313, 1, 0, 0, 0, 9415, 9322, 1, 0, 0, 0, 9415, 9328, + 1, 0, 0, 0, 9415, 9337, 1, 0, 0, 0, 9415, 9346, 1, 0, 0, 0, 9415, 9355, + 1, 0, 0, 0, 9415, 9359, 1, 0, 0, 0, 9415, 9363, 1, 0, 0, 0, 9415, 9367, + 1, 0, 0, 0, 9415, 9375, 1, 0, 0, 0, 9415, 9379, 1, 0, 0, 0, 9415, 9383, + 1, 0, 0, 0, 9415, 9392, 1, 0, 0, 0, 9415, 9396, 1, 0, 0, 0, 9416, 9419, + 1, 0, 0, 0, 9417, 9415, 1, 0, 0, 0, 9417, 9418, 1, 0, 0, 0, 9418, 9421, + 1, 0, 0, 0, 9419, 9417, 1, 0, 0, 0, 9420, 9247, 1, 0, 0, 0, 9420, 9421, + 1, 0, 0, 0, 9421, 743, 1, 0, 0, 0, 9422, 9423, 5, 85, 0, 0, 9423, 9424, + 5, 123, 0, 0, 9424, 9425, 3, 1230, 615, 0, 9425, 9426, 5, 1000, 0, 0, 9426, + 9427, 5, 343, 0, 0, 9427, 9428, 5, 1188, 0, 0, 9428, 9460, 5, 1184, 0, + 0, 9429, 9430, 5, 1077, 0, 0, 9430, 9431, 5, 736, 0, 0, 9431, 9432, 5, + 498, 0, 0, 9432, 9455, 5, 1206, 0, 0, 9433, 9435, 5, 1208, 0, 0, 9434, + 9433, 1, 0, 0, 0, 9434, 9435, 1, 0, 0, 0, 9435, 9436, 1, 0, 0, 0, 9436, + 9437, 5, 343, 0, 0, 9437, 9438, 5, 1188, 0, 0, 9438, 9456, 5, 1184, 0, + 0, 9439, 9441, 5, 1208, 0, 0, 9440, 9439, 1, 0, 0, 0, 9440, 9441, 1, 0, + 0, 0, 9441, 9442, 1, 0, 0, 0, 9442, 9443, 5, 297, 0, 0, 9443, 9444, 5, + 111, 0, 0, 9444, 9445, 5, 703, 0, 0, 9445, 9446, 5, 1188, 0, 0, 9446, 9456, + 5, 1184, 0, 0, 9447, 9449, 5, 1208, 0, 0, 9448, 9447, 1, 0, 0, 0, 9448, + 9449, 1, 0, 0, 0, 9449, 9450, 1, 0, 0, 0, 9450, 9451, 5, 244, 0, 0, 9451, + 9452, 5, 111, 0, 0, 9452, 9453, 5, 703, 0, 0, 9453, 9454, 5, 1188, 0, 0, + 9454, 9456, 5, 1184, 0, 0, 9455, 9434, 1, 0, 0, 0, 9455, 9440, 1, 0, 0, + 0, 9455, 9448, 1, 0, 0, 0, 9456, 9457, 1, 0, 0, 0, 9457, 9455, 1, 0, 0, + 0, 9457, 9458, 1, 0, 0, 0, 9458, 9459, 1, 0, 0, 0, 9459, 9461, 5, 1207, + 0, 0, 9460, 9429, 1, 0, 0, 0, 9460, 9461, 1, 0, 0, 0, 9461, 745, 1, 0, + 0, 0, 9462, 9463, 5, 85, 0, 0, 9463, 9464, 5, 547, 0, 0, 9464, 9465, 5, + 498, 0, 0, 9465, 9466, 5, 1000, 0, 0, 9466, 9467, 5, 343, 0, 0, 9467, 9468, + 5, 1188, 0, 0, 9468, 9469, 5, 1184, 0, 0, 9469, 9470, 5, 297, 0, 0, 9470, + 9471, 5, 111, 0, 0, 9471, 9472, 5, 703, 0, 0, 9472, 9473, 5, 1188, 0, 0, + 9473, 9474, 5, 1184, 0, 0, 9474, 747, 1, 0, 0, 0, 9475, 9476, 5, 85, 0, + 0, 9476, 9477, 5, 891, 0, 0, 9477, 9478, 5, 547, 0, 0, 9478, 9479, 5, 498, + 0, 0, 9479, 9480, 5, 1000, 0, 0, 9480, 9481, 5, 343, 0, 0, 9481, 9482, + 5, 1188, 0, 0, 9482, 9483, 5, 1184, 0, 0, 9483, 9484, 5, 297, 0, 0, 9484, + 9485, 5, 111, 0, 0, 9485, 9486, 5, 703, 0, 0, 9486, 9487, 5, 1188, 0, 0, + 9487, 9488, 5, 1184, 0, 0, 9488, 749, 1, 0, 0, 0, 9489, 9493, 5, 504, 0, + 0, 9490, 9494, 3, 752, 376, 0, 9491, 9494, 3, 754, 377, 0, 9492, 9494, + 3, 756, 378, 0, 9493, 9490, 1, 0, 0, 0, 9493, 9491, 1, 0, 0, 0, 9493, 9492, + 1, 0, 0, 0, 9494, 751, 1, 0, 0, 0, 9495, 9498, 7, 31, 0, 0, 9496, 9498, + 5, 1041, 0, 0, 9497, 9495, 1, 0, 0, 0, 9497, 9496, 1, 0, 0, 0, 9498, 9501, + 1, 0, 0, 0, 9499, 9500, 5, 1077, 0, 0, 9500, 9502, 5, 952, 0, 0, 9501, + 9499, 1, 0, 0, 0, 9501, 9502, 1, 0, 0, 0, 9502, 753, 1, 0, 0, 0, 9503, + 9504, 5, 752, 0, 0, 9504, 9505, 5, 628, 0, 0, 9505, 9508, 5, 965, 0, 0, + 9506, 9509, 5, 22, 0, 0, 9507, 9509, 5, 1182, 0, 0, 9508, 9506, 1, 0, 0, + 0, 9508, 9507, 1, 0, 0, 0, 9509, 755, 1, 0, 0, 0, 9510, 9511, 5, 948, 0, + 0, 9511, 9512, 5, 483, 0, 0, 9512, 9513, 5, 1182, 0, 0, 9513, 757, 1, 0, + 0, 0, 9514, 9515, 5, 320, 0, 0, 9515, 9517, 3, 762, 381, 0, 9516, 9518, + 5, 1209, 0, 0, 9517, 9516, 1, 0, 0, 0, 9517, 9518, 1, 0, 0, 0, 9518, 759, + 1, 0, 0, 0, 9519, 9528, 3, 1178, 589, 0, 9520, 9525, 3, 764, 382, 0, 9521, + 9522, 5, 1208, 0, 0, 9522, 9524, 3, 764, 382, 0, 9523, 9521, 1, 0, 0, 0, + 9524, 9527, 1, 0, 0, 0, 9525, 9523, 1, 0, 0, 0, 9525, 9526, 1, 0, 0, 0, + 9526, 9529, 1, 0, 0, 0, 9527, 9525, 1, 0, 0, 0, 9528, 9520, 1, 0, 0, 0, + 9528, 9529, 1, 0, 0, 0, 9529, 9531, 1, 0, 0, 0, 9530, 9532, 5, 1209, 0, + 0, 9531, 9530, 1, 0, 0, 0, 9531, 9532, 1, 0, 0, 0, 9532, 761, 1, 0, 0, + 0, 9533, 9534, 5, 1180, 0, 0, 9534, 9536, 5, 1188, 0, 0, 9535, 9533, 1, + 0, 0, 0, 9535, 9536, 1, 0, 0, 0, 9536, 9539, 1, 0, 0, 0, 9537, 9540, 3, + 1178, 589, 0, 9538, 9540, 3, 772, 386, 0, 9539, 9537, 1, 0, 0, 0, 9539, + 9538, 1, 0, 0, 0, 9540, 9542, 1, 0, 0, 0, 9541, 9543, 3, 764, 382, 0, 9542, + 9541, 1, 0, 0, 0, 9542, 9543, 1, 0, 0, 0, 9543, 9572, 1, 0, 0, 0, 9544, + 9545, 5, 1206, 0, 0, 9545, 9550, 3, 772, 386, 0, 9546, 9547, 5, 1208, 0, + 0, 9547, 9549, 3, 772, 386, 0, 9548, 9546, 1, 0, 0, 0, 9549, 9552, 1, 0, + 0, 0, 9550, 9548, 1, 0, 0, 0, 9550, 9551, 1, 0, 0, 0, 9551, 9553, 1, 0, + 0, 0, 9552, 9550, 1, 0, 0, 0, 9553, 9558, 5, 1207, 0, 0, 9554, 9555, 5, + 56, 0, 0, 9555, 9556, 7, 104, 0, 0, 9556, 9557, 5, 1188, 0, 0, 9557, 9559, + 5, 1184, 0, 0, 9558, 9554, 1, 0, 0, 0, 9558, 9559, 1, 0, 0, 0, 9559, 9562, + 1, 0, 0, 0, 9560, 9561, 5, 63, 0, 0, 9561, 9563, 3, 1230, 615, 0, 9562, + 9560, 1, 0, 0, 0, 9562, 9563, 1, 0, 0, 0, 9563, 9572, 1, 0, 0, 0, 9564, + 9569, 5, 56, 0, 0, 9565, 9566, 7, 104, 0, 0, 9566, 9567, 5, 1188, 0, 0, + 9567, 9570, 5, 1184, 0, 0, 9568, 9570, 5, 114, 0, 0, 9569, 9565, 1, 0, + 0, 0, 9569, 9568, 1, 0, 0, 0, 9570, 9572, 1, 0, 0, 0, 9571, 9535, 1, 0, + 0, 0, 9571, 9544, 1, 0, 0, 0, 9571, 9564, 1, 0, 0, 0, 9572, 763, 1, 0, + 0, 0, 9573, 9578, 3, 768, 384, 0, 9574, 9575, 5, 1208, 0, 0, 9575, 9577, + 3, 764, 382, 0, 9576, 9574, 1, 0, 0, 0, 9577, 9580, 1, 0, 0, 0, 9578, 9576, + 1, 0, 0, 0, 9578, 9579, 1, 0, 0, 0, 9579, 9590, 1, 0, 0, 0, 9580, 9578, + 1, 0, 0, 0, 9581, 9586, 3, 766, 383, 0, 9582, 9583, 5, 1208, 0, 0, 9583, + 9585, 3, 766, 383, 0, 9584, 9582, 1, 0, 0, 0, 9585, 9588, 1, 0, 0, 0, 9586, + 9584, 1, 0, 0, 0, 9586, 9587, 1, 0, 0, 0, 9587, 9590, 1, 0, 0, 0, 9588, + 9586, 1, 0, 0, 0, 9589, 9573, 1, 0, 0, 0, 9589, 9581, 1, 0, 0, 0, 9590, + 765, 1, 0, 0, 0, 9591, 9592, 5, 1180, 0, 0, 9592, 9593, 5, 1188, 0, 0, + 9593, 9594, 3, 770, 385, 0, 9594, 767, 1, 0, 0, 0, 9595, 9596, 3, 770, + 385, 0, 9596, 769, 1, 0, 0, 0, 9597, 9606, 3, 1224, 612, 0, 9598, 9600, + 5, 1180, 0, 0, 9599, 9601, 7, 105, 0, 0, 9600, 9599, 1, 0, 0, 0, 9600, + 9601, 1, 0, 0, 0, 9601, 9606, 1, 0, 0, 0, 9602, 9606, 3, 1230, 615, 0, + 9603, 9606, 5, 245, 0, 0, 9604, 9606, 5, 643, 0, 0, 9605, 9597, 1, 0, 0, + 0, 9605, 9598, 1, 0, 0, 0, 9605, 9602, 1, 0, 0, 0, 9605, 9603, 1, 0, 0, + 0, 9605, 9604, 1, 0, 0, 0, 9606, 771, 1, 0, 0, 0, 9607, 9609, 5, 1180, + 0, 0, 9608, 9610, 7, 105, 0, 0, 9609, 9608, 1, 0, 0, 0, 9609, 9610, 1, + 0, 0, 0, 9610, 9617, 1, 0, 0, 0, 9611, 9612, 5, 1215, 0, 0, 9612, 9615, + 5, 1180, 0, 0, 9613, 9614, 5, 1215, 0, 0, 9614, 9616, 3, 772, 386, 0, 9615, + 9613, 1, 0, 0, 0, 9615, 9616, 1, 0, 0, 0, 9616, 9618, 1, 0, 0, 0, 9617, + 9611, 1, 0, 0, 0, 9617, 9618, 1, 0, 0, 0, 9618, 9629, 1, 0, 0, 0, 9619, + 9626, 5, 1184, 0, 0, 9620, 9621, 5, 1215, 0, 0, 9621, 9624, 5, 1180, 0, + 0, 9622, 9623, 5, 1215, 0, 0, 9623, 9625, 3, 772, 386, 0, 9624, 9622, 1, + 0, 0, 0, 9624, 9625, 1, 0, 0, 0, 9625, 9627, 1, 0, 0, 0, 9626, 9620, 1, + 0, 0, 0, 9626, 9627, 1, 0, 0, 0, 9627, 9629, 1, 0, 0, 0, 9628, 9607, 1, + 0, 0, 0, 9628, 9619, 1, 0, 0, 0, 9629, 773, 1, 0, 0, 0, 9630, 9632, 3, + 864, 432, 0, 9631, 9633, 5, 1209, 0, 0, 9632, 9631, 1, 0, 0, 0, 9632, 9633, + 1, 0, 0, 0, 9633, 9693, 1, 0, 0, 0, 9634, 9646, 5, 410, 0, 0, 9635, 9637, + 5, 22, 0, 0, 9636, 9638, 5, 738, 0, 0, 9637, 9636, 1, 0, 0, 0, 9637, 9638, + 1, 0, 0, 0, 9638, 9647, 1, 0, 0, 0, 9639, 9644, 3, 802, 401, 0, 9640, 9641, + 5, 1206, 0, 0, 9641, 9642, 3, 1192, 596, 0, 9642, 9643, 5, 1207, 0, 0, + 9643, 9645, 1, 0, 0, 0, 9644, 9640, 1, 0, 0, 0, 9644, 9645, 1, 0, 0, 0, + 9645, 9647, 1, 0, 0, 0, 9646, 9635, 1, 0, 0, 0, 9646, 9639, 1, 0, 0, 0, + 9647, 9655, 1, 0, 0, 0, 9648, 9652, 5, 662, 0, 0, 9649, 9650, 3, 156, 78, + 0, 9650, 9651, 5, 1211, 0, 0, 9651, 9653, 1, 0, 0, 0, 9652, 9649, 1, 0, + 0, 0, 9652, 9653, 1, 0, 0, 0, 9653, 9654, 1, 0, 0, 0, 9654, 9656, 3, 1170, + 585, 0, 9655, 9648, 1, 0, 0, 0, 9655, 9656, 1, 0, 0, 0, 9656, 9657, 1, + 0, 0, 0, 9657, 9658, 5, 1000, 0, 0, 9658, 9663, 3, 776, 388, 0, 9659, 9660, + 5, 1208, 0, 0, 9660, 9662, 3, 776, 388, 0, 9661, 9659, 1, 0, 0, 0, 9662, + 9665, 1, 0, 0, 0, 9663, 9661, 1, 0, 0, 0, 9663, 9664, 1, 0, 0, 0, 9664, + 9669, 1, 0, 0, 0, 9665, 9663, 1, 0, 0, 0, 9666, 9667, 5, 1077, 0, 0, 9667, + 9668, 5, 410, 0, 0, 9668, 9670, 5, 677, 0, 0, 9669, 9666, 1, 0, 0, 0, 9669, + 9670, 1, 0, 0, 0, 9670, 9673, 1, 0, 0, 0, 9671, 9672, 5, 56, 0, 0, 9672, + 9674, 3, 776, 388, 0, 9673, 9671, 1, 0, 0, 0, 9673, 9674, 1, 0, 0, 0, 9674, + 9676, 1, 0, 0, 0, 9675, 9677, 5, 1209, 0, 0, 9676, 9675, 1, 0, 0, 0, 9676, + 9677, 1, 0, 0, 0, 9677, 9693, 1, 0, 0, 0, 9678, 9683, 5, 827, 0, 0, 9679, + 9680, 5, 1077, 0, 0, 9680, 9681, 5, 193, 0, 0, 9681, 9682, 5, 1188, 0, + 0, 9682, 9684, 5, 1180, 0, 0, 9683, 9679, 1, 0, 0, 0, 9683, 9684, 1, 0, + 0, 0, 9684, 9686, 1, 0, 0, 0, 9685, 9687, 5, 1209, 0, 0, 9686, 9685, 1, + 0, 0, 0, 9686, 9687, 1, 0, 0, 0, 9687, 9693, 1, 0, 0, 0, 9688, 9693, 3, + 788, 394, 0, 9689, 9693, 3, 790, 395, 0, 9690, 9693, 3, 792, 396, 0, 9691, + 9693, 3, 778, 389, 0, 9692, 9630, 1, 0, 0, 0, 9692, 9634, 1, 0, 0, 0, 9692, + 9678, 1, 0, 0, 0, 9692, 9688, 1, 0, 0, 0, 9692, 9689, 1, 0, 0, 0, 9692, + 9690, 1, 0, 0, 0, 9692, 9691, 1, 0, 0, 0, 9693, 775, 1, 0, 0, 0, 9694, + 9697, 3, 1230, 615, 0, 9695, 9697, 5, 748, 0, 0, 9696, 9694, 1, 0, 0, 0, + 9696, 9695, 1, 0, 0, 0, 9697, 777, 1, 0, 0, 0, 9698, 9699, 5, 199, 0, 0, + 9699, 9700, 5, 123, 0, 0, 9700, 9703, 3, 1230, 615, 0, 9701, 9702, 5, 68, + 0, 0, 9702, 9704, 3, 1230, 615, 0, 9703, 9701, 1, 0, 0, 0, 9703, 9704, + 1, 0, 0, 0, 9704, 9708, 1, 0, 0, 0, 9705, 9706, 5, 380, 0, 0, 9706, 9709, + 3, 780, 390, 0, 9707, 9709, 3, 784, 392, 0, 9708, 9705, 1, 0, 0, 0, 9708, + 9707, 1, 0, 0, 0, 9709, 9716, 1, 0, 0, 0, 9710, 9711, 5, 10, 0, 0, 9711, + 9712, 5, 365, 0, 0, 9712, 9713, 5, 90, 0, 0, 9713, 9714, 5, 266, 0, 0, + 9714, 9715, 5, 1188, 0, 0, 9715, 9717, 3, 1196, 598, 0, 9716, 9710, 1, + 0, 0, 0, 9716, 9717, 1, 0, 0, 0, 9717, 779, 1, 0, 0, 0, 9718, 9719, 5, + 59, 0, 0, 9719, 9736, 3, 1230, 615, 0, 9720, 9722, 5, 318, 0, 0, 9721, + 9720, 1, 0, 0, 0, 9721, 9722, 1, 0, 0, 0, 9722, 9723, 1, 0, 0, 0, 9723, + 9724, 5, 343, 0, 0, 9724, 9725, 5, 1188, 0, 0, 9725, 9733, 5, 1184, 0, + 0, 9726, 9727, 5, 1077, 0, 0, 9727, 9728, 5, 736, 0, 0, 9728, 9729, 5, + 498, 0, 0, 9729, 9730, 5, 1206, 0, 0, 9730, 9731, 3, 782, 391, 0, 9731, + 9732, 5, 1207, 0, 0, 9732, 9734, 1, 0, 0, 0, 9733, 9726, 1, 0, 0, 0, 9733, + 9734, 1, 0, 0, 0, 9734, 9736, 1, 0, 0, 0, 9735, 9718, 1, 0, 0, 0, 9735, + 9721, 1, 0, 0, 0, 9736, 781, 1, 0, 0, 0, 9737, 9738, 7, 106, 0, 0, 9738, + 9739, 5, 1188, 0, 0, 9739, 9746, 5, 1184, 0, 0, 9740, 9741, 5, 1208, 0, + 0, 9741, 9742, 7, 107, 0, 0, 9742, 9743, 5, 111, 0, 0, 9743, 9744, 5, 703, + 0, 0, 9744, 9745, 5, 1188, 0, 0, 9745, 9747, 5, 1184, 0, 0, 9746, 9740, + 1, 0, 0, 0, 9746, 9747, 1, 0, 0, 0, 9747, 783, 1, 0, 0, 0, 9748, 9749, + 5, 297, 0, 0, 9749, 9750, 5, 111, 0, 0, 9750, 9751, 5, 703, 0, 0, 9751, + 9752, 5, 1188, 0, 0, 9752, 9754, 5, 1184, 0, 0, 9753, 9748, 1, 0, 0, 0, + 9753, 9754, 1, 0, 0, 0, 9754, 9755, 1, 0, 0, 0, 9755, 9756, 5, 1077, 0, + 0, 9756, 9757, 5, 963, 0, 0, 9757, 9758, 5, 1188, 0, 0, 9758, 9763, 5, + 1184, 0, 0, 9759, 9760, 5, 1208, 0, 0, 9760, 9762, 3, 786, 393, 0, 9761, + 9759, 1, 0, 0, 0, 9762, 9765, 1, 0, 0, 0, 9763, 9761, 1, 0, 0, 0, 9763, + 9764, 1, 0, 0, 0, 9764, 785, 1, 0, 0, 0, 9765, 9763, 1, 0, 0, 0, 9766, + 9767, 7, 108, 0, 0, 9767, 9768, 5, 1188, 0, 0, 9768, 9769, 5, 1184, 0, + 0, 9769, 787, 1, 0, 0, 0, 9770, 9771, 5, 666, 0, 0, 9771, 9772, 5, 975, + 0, 0, 9772, 9773, 5, 498, 0, 0, 9773, 9774, 3, 1230, 615, 0, 9774, 9775, + 5, 244, 0, 0, 9775, 9776, 5, 111, 0, 0, 9776, 9777, 3, 800, 400, 0, 9777, + 9787, 1, 0, 0, 0, 9778, 9779, 5, 666, 0, 0, 9779, 9780, 5, 547, 0, 0, 9780, + 9781, 5, 498, 0, 0, 9781, 9782, 5, 244, 0, 0, 9782, 9783, 5, 111, 0, 0, + 9783, 9784, 5, 703, 0, 0, 9784, 9785, 5, 1188, 0, 0, 9785, 9787, 5, 1184, + 0, 0, 9786, 9770, 1, 0, 0, 0, 9786, 9778, 1, 0, 0, 0, 9787, 789, 1, 0, + 0, 0, 9788, 9789, 5, 149, 0, 0, 9789, 9790, 5, 975, 0, 0, 9790, 9791, 5, + 498, 0, 0, 9791, 9800, 3, 1230, 615, 0, 9792, 9793, 5, 149, 0, 0, 9793, + 9794, 5, 22, 0, 0, 9794, 9795, 5, 975, 0, 0, 9795, 9800, 5, 499, 0, 0, + 9796, 9797, 5, 149, 0, 0, 9797, 9798, 5, 547, 0, 0, 9798, 9800, 5, 498, + 0, 0, 9799, 9788, 1, 0, 0, 0, 9799, 9792, 1, 0, 0, 0, 9799, 9796, 1, 0, + 0, 0, 9800, 791, 1, 0, 0, 0, 9801, 9802, 5, 199, 0, 0, 9802, 9803, 5, 547, + 0, 0, 9803, 9804, 5, 498, 0, 0, 9804, 9805, 5, 297, 0, 0, 9805, 9806, 5, + 111, 0, 0, 9806, 9807, 5, 703, 0, 0, 9807, 9808, 5, 1188, 0, 0, 9808, 9837, + 5, 1184, 0, 0, 9809, 9810, 5, 199, 0, 0, 9810, 9811, 5, 975, 0, 0, 9811, + 9812, 5, 498, 0, 0, 9812, 9815, 3, 1230, 615, 0, 9813, 9814, 5, 68, 0, + 0, 9814, 9816, 3, 1230, 615, 0, 9815, 9813, 1, 0, 0, 0, 9815, 9816, 1, + 0, 0, 0, 9816, 9820, 1, 0, 0, 0, 9817, 9818, 5, 380, 0, 0, 9818, 9819, + 5, 746, 0, 0, 9819, 9821, 3, 1230, 615, 0, 9820, 9817, 1, 0, 0, 0, 9820, + 9821, 1, 0, 0, 0, 9821, 9822, 1, 0, 0, 0, 9822, 9832, 5, 1077, 0, 0, 9823, + 9828, 3, 794, 397, 0, 9824, 9825, 5, 297, 0, 0, 9825, 9826, 5, 111, 0, + 0, 9826, 9828, 3, 798, 399, 0, 9827, 9823, 1, 0, 0, 0, 9827, 9824, 1, 0, + 0, 0, 9828, 9830, 1, 0, 0, 0, 9829, 9831, 5, 1208, 0, 0, 9830, 9829, 1, + 0, 0, 0, 9830, 9831, 1, 0, 0, 0, 9831, 9833, 1, 0, 0, 0, 9832, 9827, 1, + 0, 0, 0, 9833, 9834, 1, 0, 0, 0, 9834, 9832, 1, 0, 0, 0, 9834, 9835, 1, + 0, 0, 0, 9835, 9837, 1, 0, 0, 0, 9836, 9801, 1, 0, 0, 0, 9836, 9809, 1, + 0, 0, 0, 9837, 793, 1, 0, 0, 0, 9838, 9839, 5, 502, 0, 0, 9839, 9840, 5, + 1188, 0, 0, 9840, 9854, 5, 1184, 0, 0, 9841, 9842, 5, 21, 0, 0, 9842, 9843, + 5, 1188, 0, 0, 9843, 9854, 3, 796, 398, 0, 9844, 9845, 5, 436, 0, 0, 9845, + 9846, 5, 1188, 0, 0, 9846, 9854, 5, 1184, 0, 0, 9847, 9848, 5, 747, 0, + 0, 9848, 9849, 5, 1188, 0, 0, 9849, 9854, 5, 1184, 0, 0, 9850, 9851, 5, + 201, 0, 0, 9851, 9852, 5, 1188, 0, 0, 9852, 9854, 7, 9, 0, 0, 9853, 9838, + 1, 0, 0, 0, 9853, 9841, 1, 0, 0, 0, 9853, 9844, 1, 0, 0, 0, 9853, 9847, + 1, 0, 0, 0, 9853, 9850, 1, 0, 0, 0, 9854, 795, 1, 0, 0, 0, 9855, 9856, + 7, 109, 0, 0, 9856, 797, 1, 0, 0, 0, 9857, 9858, 5, 123, 0, 0, 9858, 9869, + 3, 1230, 615, 0, 9859, 9860, 5, 61, 0, 0, 9860, 9861, 5, 498, 0, 0, 9861, + 9869, 3, 1230, 615, 0, 9862, 9863, 5, 975, 0, 0, 9863, 9864, 5, 498, 0, + 0, 9864, 9869, 3, 1230, 615, 0, 9865, 9866, 5, 703, 0, 0, 9866, 9867, 5, + 1188, 0, 0, 9867, 9869, 5, 1184, 0, 0, 9868, 9857, 1, 0, 0, 0, 9868, 9859, + 1, 0, 0, 0, 9868, 9862, 1, 0, 0, 0, 9868, 9865, 1, 0, 0, 0, 9869, 799, + 1, 0, 0, 0, 9870, 9871, 5, 123, 0, 0, 9871, 9876, 3, 1230, 615, 0, 9872, + 9873, 5, 1077, 0, 0, 9873, 9874, 5, 703, 0, 0, 9874, 9875, 5, 1188, 0, + 0, 9875, 9877, 5, 1184, 0, 0, 9876, 9872, 1, 0, 0, 0, 9876, 9877, 1, 0, + 0, 0, 9877, 9894, 1, 0, 0, 0, 9878, 9879, 5, 61, 0, 0, 9879, 9880, 5, 498, + 0, 0, 9880, 9885, 3, 1230, 615, 0, 9881, 9882, 5, 1077, 0, 0, 9882, 9883, + 5, 703, 0, 0, 9883, 9884, 5, 1188, 0, 0, 9884, 9886, 5, 1184, 0, 0, 9885, + 9881, 1, 0, 0, 0, 9885, 9886, 1, 0, 0, 0, 9886, 9894, 1, 0, 0, 0, 9887, + 9888, 5, 975, 0, 0, 9888, 9889, 5, 498, 0, 0, 9889, 9894, 3, 1230, 615, + 0, 9890, 9891, 5, 703, 0, 0, 9891, 9892, 5, 1188, 0, 0, 9892, 9894, 5, + 1184, 0, 0, 9893, 9870, 1, 0, 0, 0, 9893, 9878, 1, 0, 0, 0, 9893, 9887, + 1, 0, 0, 0, 9893, 9890, 1, 0, 0, 0, 9894, 801, 1, 0, 0, 0, 9895, 9901, + 5, 13, 0, 0, 9896, 9897, 5, 109, 0, 0, 9897, 9902, 5, 673, 0, 0, 9898, + 9899, 5, 219, 0, 0, 9899, 9900, 5, 109, 0, 0, 9900, 9902, 5, 673, 0, 0, + 9901, 9896, 1, 0, 0, 0, 9901, 9898, 1, 0, 0, 0, 9902, 10109, 1, 0, 0, 0, + 9903, 9974, 5, 35, 0, 0, 9904, 9967, 5, 46, 0, 0, 9905, 9906, 5, 48, 0, + 0, 9906, 9968, 5, 832, 0, 0, 9907, 9968, 5, 59, 0, 0, 9908, 9909, 5, 61, + 0, 0, 9909, 9968, 5, 498, 0, 0, 9910, 9911, 5, 81, 0, 0, 9911, 9968, 5, + 412, 0, 0, 9912, 9968, 5, 123, 0, 0, 9913, 9918, 5, 155, 0, 0, 9914, 9915, + 5, 297, 0, 0, 9915, 9919, 5, 498, 0, 0, 9916, 9917, 5, 547, 0, 0, 9917, + 9919, 5, 498, 0, 0, 9918, 9914, 1, 0, 0, 0, 9918, 9916, 1, 0, 0, 0, 9919, + 9968, 1, 0, 0, 0, 9920, 9968, 5, 177, 0, 0, 9921, 9968, 5, 188, 0, 0, 9922, + 9968, 5, 202, 0, 0, 9923, 9931, 5, 219, 0, 0, 9924, 9932, 5, 64, 0, 0, + 9925, 9926, 5, 240, 0, 0, 9926, 9932, 5, 1013, 0, 0, 9927, 9928, 5, 313, + 0, 0, 9928, 9932, 7, 110, 0, 0, 9929, 9930, 5, 862, 0, 0, 9930, 9932, 5, + 175, 0, 0, 9931, 9924, 1, 0, 0, 0, 9931, 9925, 1, 0, 0, 0, 9931, 9927, + 1, 0, 0, 0, 9931, 9929, 1, 0, 0, 0, 9931, 9932, 1, 0, 0, 0, 9932, 9968, + 1, 0, 0, 0, 9933, 9968, 5, 224, 0, 0, 9934, 9968, 5, 300, 0, 0, 9935, 9936, + 5, 313, 0, 0, 9936, 9968, 7, 110, 0, 0, 9937, 9943, 5, 331, 0, 0, 9938, + 9939, 5, 218, 0, 0, 9939, 9944, 5, 926, 0, 0, 9940, 9941, 5, 343, 0, 0, + 9941, 9944, 5, 374, 0, 0, 9942, 9944, 5, 518, 0, 0, 9943, 9938, 1, 0, 0, + 0, 9943, 9940, 1, 0, 0, 0, 9943, 9942, 1, 0, 0, 0, 9944, 9968, 1, 0, 0, + 0, 9945, 9946, 5, 383, 0, 0, 9946, 9968, 5, 119, 0, 0, 9947, 9948, 5, 522, + 0, 0, 9948, 9968, 5, 889, 0, 0, 9949, 9968, 5, 537, 0, 0, 9950, 9968, 5, + 545, 0, 0, 9951, 9952, 5, 578, 0, 0, 9952, 9968, 5, 1024, 0, 0, 9953, 9954, + 5, 791, 0, 0, 9954, 9955, 5, 891, 0, 0, 9955, 9968, 5, 96, 0, 0, 9956, + 9968, 5, 832, 0, 0, 9957, 9968, 5, 836, 0, 0, 9958, 9968, 5, 857, 0, 0, + 9959, 9960, 5, 874, 0, 0, 9960, 9968, 5, 724, 0, 0, 9961, 9962, 5, 889, + 0, 0, 9962, 9968, 7, 111, 0, 0, 9963, 9968, 5, 891, 0, 0, 9964, 9965, 5, + 975, 0, 0, 9965, 9968, 5, 498, 0, 0, 9966, 9968, 5, 1049, 0, 0, 9967, 9905, + 1, 0, 0, 0, 9967, 9907, 1, 0, 0, 0, 9967, 9908, 1, 0, 0, 0, 9967, 9910, + 1, 0, 0, 0, 9967, 9912, 1, 0, 0, 0, 9967, 9913, 1, 0, 0, 0, 9967, 9920, + 1, 0, 0, 0, 9967, 9921, 1, 0, 0, 0, 9967, 9922, 1, 0, 0, 0, 9967, 9923, + 1, 0, 0, 0, 9967, 9933, 1, 0, 0, 0, 9967, 9934, 1, 0, 0, 0, 9967, 9935, + 1, 0, 0, 0, 9967, 9937, 1, 0, 0, 0, 9967, 9945, 1, 0, 0, 0, 9967, 9947, + 1, 0, 0, 0, 9967, 9949, 1, 0, 0, 0, 9967, 9950, 1, 0, 0, 0, 9967, 9951, + 1, 0, 0, 0, 9967, 9953, 1, 0, 0, 0, 9967, 9956, 1, 0, 0, 0, 9967, 9957, + 1, 0, 0, 0, 9967, 9958, 1, 0, 0, 0, 9967, 9959, 1, 0, 0, 0, 9967, 9961, + 1, 0, 0, 0, 9967, 9963, 1, 0, 0, 0, 9967, 9964, 1, 0, 0, 0, 9967, 9966, + 1, 0, 0, 0, 9968, 9975, 1, 0, 0, 0, 9969, 9975, 5, 814, 0, 0, 9970, 9971, + 5, 889, 0, 0, 9971, 9975, 5, 943, 0, 0, 9972, 9975, 5, 903, 0, 0, 9973, + 9975, 5, 1004, 0, 0, 9974, 9904, 1, 0, 0, 0, 9974, 9969, 1, 0, 0, 0, 9974, + 9970, 1, 0, 0, 0, 9974, 9972, 1, 0, 0, 0, 9974, 9973, 1, 0, 0, 0, 9974, + 9975, 1, 0, 0, 0, 9975, 10109, 1, 0, 0, 0, 9976, 9978, 5, 66, 0, 0, 9977, + 9979, 5, 889, 0, 0, 9978, 9977, 1, 0, 0, 0, 9978, 9979, 1, 0, 0, 0, 9979, + 10109, 1, 0, 0, 0, 9980, 9981, 5, 85, 0, 0, 9981, 10109, 7, 112, 0, 0, + 9982, 10109, 5, 139, 0, 0, 9983, 9988, 5, 176, 0, 0, 9984, 9985, 5, 46, + 0, 0, 9985, 9989, 5, 219, 0, 0, 9986, 9989, 5, 804, 0, 0, 9987, 9989, 5, + 933, 0, 0, 9988, 9984, 1, 0, 0, 0, 9988, 9986, 1, 0, 0, 0, 9988, 9987, + 1, 0, 0, 0, 9988, 9989, 1, 0, 0, 0, 9989, 10109, 1, 0, 0, 0, 9990, 9992, + 5, 190, 0, 0, 9991, 9993, 5, 889, 0, 0, 9992, 9991, 1, 0, 0, 0, 9992, 9993, + 1, 0, 0, 0, 9993, 10109, 1, 0, 0, 0, 9994, 10048, 5, 199, 0, 0, 9995, 10049, + 5, 20, 0, 0, 9996, 9997, 5, 46, 0, 0, 9997, 10049, 5, 219, 0, 0, 9998, + 10049, 5, 59, 0, 0, 9999, 10000, 5, 61, 0, 0, 10000, 10049, 5, 498, 0, + 0, 10001, 10002, 5, 81, 0, 0, 10002, 10049, 5, 412, 0, 0, 10003, 10049, + 5, 123, 0, 0, 10004, 10049, 5, 188, 0, 0, 10005, 10009, 5, 219, 0, 0, 10006, + 10007, 5, 240, 0, 0, 10007, 10008, 5, 313, 0, 0, 10008, 10010, 5, 628, + 0, 0, 10009, 10006, 1, 0, 0, 0, 10009, 10010, 1, 0, 0, 0, 10010, 10049, + 1, 0, 0, 0, 10011, 10012, 5, 240, 0, 0, 10012, 10013, 5, 313, 0, 0, 10013, + 10049, 5, 628, 0, 0, 10014, 10049, 5, 245, 0, 0, 10015, 10049, 5, 300, + 0, 0, 10016, 10017, 5, 331, 0, 0, 10017, 10049, 5, 518, 0, 0, 10018, 10019, + 5, 383, 0, 0, 10019, 10049, 5, 119, 0, 0, 10020, 10049, 5, 386, 0, 0, 10021, + 10022, 5, 578, 0, 0, 10022, 10049, 5, 1024, 0, 0, 10023, 10049, 5, 741, + 0, 0, 10024, 10049, 5, 754, 0, 0, 10025, 10026, 5, 791, 0, 0, 10026, 10027, + 5, 891, 0, 0, 10027, 10049, 5, 96, 0, 0, 10028, 10049, 5, 832, 0, 0, 10029, + 10049, 5, 836, 0, 0, 10030, 10049, 5, 851, 0, 0, 10031, 10049, 5, 857, + 0, 0, 10032, 10049, 5, 886, 0, 0, 10033, 10034, 5, 889, 0, 0, 10034, 10049, + 5, 832, 0, 0, 10035, 10049, 5, 891, 0, 0, 10036, 10037, 5, 975, 0, 0, 10037, + 10049, 5, 498, 0, 0, 10038, 10049, 5, 977, 0, 0, 10039, 10049, 5, 980, + 0, 0, 10040, 10041, 5, 1004, 0, 0, 10041, 10042, 5, 313, 0, 0, 10042, 10049, + 5, 628, 0, 0, 10043, 10049, 5, 1024, 0, 0, 10044, 10049, 5, 1065, 0, 0, + 10045, 10046, 5, 1088, 0, 0, 10046, 10047, 5, 857, 0, 0, 10047, 10049, + 5, 154, 0, 0, 10048, 9995, 1, 0, 0, 0, 10048, 9996, 1, 0, 0, 0, 10048, + 9998, 1, 0, 0, 0, 10048, 9999, 1, 0, 0, 0, 10048, 10001, 1, 0, 0, 0, 10048, + 10003, 1, 0, 0, 0, 10048, 10004, 1, 0, 0, 0, 10048, 10005, 1, 0, 0, 0, + 10048, 10011, 1, 0, 0, 0, 10048, 10014, 1, 0, 0, 0, 10048, 10015, 1, 0, + 0, 0, 10048, 10016, 1, 0, 0, 0, 10048, 10018, 1, 0, 0, 0, 10048, 10020, + 1, 0, 0, 0, 10048, 10021, 1, 0, 0, 0, 10048, 10023, 1, 0, 0, 0, 10048, + 10024, 1, 0, 0, 0, 10048, 10025, 1, 0, 0, 0, 10048, 10028, 1, 0, 0, 0, + 10048, 10029, 1, 0, 0, 0, 10048, 10030, 1, 0, 0, 0, 10048, 10031, 1, 0, + 0, 0, 10048, 10032, 1, 0, 0, 0, 10048, 10033, 1, 0, 0, 0, 10048, 10035, + 1, 0, 0, 0, 10048, 10036, 1, 0, 0, 0, 10048, 10038, 1, 0, 0, 0, 10048, + 10039, 1, 0, 0, 0, 10048, 10040, 1, 0, 0, 0, 10048, 10043, 1, 0, 0, 0, + 10048, 10044, 1, 0, 0, 0, 10048, 10045, 1, 0, 0, 0, 10049, 10109, 1, 0, + 0, 0, 10050, 10109, 5, 254, 0, 0, 10051, 10055, 5, 320, 0, 0, 10052, 10053, + 5, 46, 0, 0, 10053, 10054, 5, 331, 0, 0, 10054, 10056, 5, 864, 0, 0, 10055, + 10052, 1, 0, 0, 0, 10055, 10056, 1, 0, 0, 0, 10056, 10109, 1, 0, 0, 0, + 10057, 10058, 5, 331, 0, 0, 10058, 10059, 5, 7, 0, 0, 10059, 10109, 5, + 59, 0, 0, 10060, 10063, 5, 448, 0, 0, 10061, 10062, 5, 46, 0, 0, 10062, + 10064, 5, 537, 0, 0, 10063, 10061, 1, 0, 0, 0, 10063, 10064, 1, 0, 0, 0, + 10064, 10109, 1, 0, 0, 0, 10065, 10109, 5, 466, 0, 0, 10066, 10067, 5, + 504, 0, 0, 10067, 10068, 5, 219, 0, 0, 10068, 10109, 5, 177, 0, 0, 10069, + 10109, 5, 781, 0, 0, 10070, 10109, 5, 786, 0, 0, 10071, 10075, 5, 878, + 0, 0, 10072, 10073, 5, 22, 0, 0, 10073, 10074, 5, 1049, 0, 0, 10074, 10076, + 5, 873, 0, 0, 10075, 10072, 1, 0, 0, 0, 10075, 10076, 1, 0, 0, 0, 10076, + 10109, 1, 0, 0, 0, 10077, 10109, 5, 884, 0, 0, 10078, 10109, 5, 908, 0, + 0, 10079, 10109, 5, 913, 0, 0, 10080, 10081, 5, 964, 0, 0, 10081, 10082, + 5, 752, 0, 0, 10082, 10109, 5, 629, 0, 0, 10083, 10084, 5, 985, 0, 0, 10084, + 10109, 5, 688, 0, 0, 10085, 10109, 5, 1038, 0, 0, 10086, 10087, 5, 1040, + 0, 0, 10087, 10109, 5, 59, 0, 0, 10088, 10109, 5, 1042, 0, 0, 10089, 10106, + 5, 1065, 0, 0, 10090, 10097, 5, 46, 0, 0, 10091, 10098, 5, 219, 0, 0, 10092, + 10098, 5, 251, 0, 0, 10093, 10094, 5, 155, 0, 0, 10094, 10095, 7, 12, 0, + 0, 10095, 10096, 5, 498, 0, 0, 10096, 10098, 5, 251, 0, 0, 10097, 10091, + 1, 0, 0, 0, 10097, 10092, 1, 0, 0, 0, 10097, 10093, 1, 0, 0, 0, 10098, + 10107, 1, 0, 0, 0, 10099, 10100, 5, 126, 0, 0, 10100, 10107, 5, 1005, 0, + 0, 10101, 10102, 5, 219, 0, 0, 10102, 10107, 5, 943, 0, 0, 10103, 10107, + 5, 251, 0, 0, 10104, 10105, 5, 889, 0, 0, 10105, 10107, 5, 943, 0, 0, 10106, + 10090, 1, 0, 0, 0, 10106, 10099, 1, 0, 0, 0, 10106, 10101, 1, 0, 0, 0, + 10106, 10103, 1, 0, 0, 0, 10106, 10104, 1, 0, 0, 0, 10107, 10109, 1, 0, + 0, 0, 10108, 9895, 1, 0, 0, 0, 10108, 9903, 1, 0, 0, 0, 10108, 9976, 1, + 0, 0, 0, 10108, 9980, 1, 0, 0, 0, 10108, 9982, 1, 0, 0, 0, 10108, 9983, + 1, 0, 0, 0, 10108, 9990, 1, 0, 0, 0, 10108, 9994, 1, 0, 0, 0, 10108, 10050, + 1, 0, 0, 0, 10108, 10051, 1, 0, 0, 0, 10108, 10057, 1, 0, 0, 0, 10108, + 10060, 1, 0, 0, 0, 10108, 10065, 1, 0, 0, 0, 10108, 10066, 1, 0, 0, 0, + 10108, 10069, 1, 0, 0, 0, 10108, 10070, 1, 0, 0, 0, 10108, 10071, 1, 0, + 0, 0, 10108, 10077, 1, 0, 0, 0, 10108, 10078, 1, 0, 0, 0, 10108, 10079, + 1, 0, 0, 0, 10108, 10080, 1, 0, 0, 0, 10108, 10083, 1, 0, 0, 0, 10108, + 10085, 1, 0, 0, 0, 10108, 10086, 1, 0, 0, 0, 10108, 10088, 1, 0, 0, 0, + 10108, 10089, 1, 0, 0, 0, 10109, 803, 1, 0, 0, 0, 10110, 10111, 5, 900, + 0, 0, 10111, 10114, 5, 1180, 0, 0, 10112, 10113, 5, 1201, 0, 0, 10113, + 10115, 3, 1230, 615, 0, 10114, 10112, 1, 0, 0, 0, 10114, 10115, 1, 0, 0, + 0, 10115, 10116, 1, 0, 0, 0, 10116, 10117, 5, 1188, 0, 0, 10117, 10142, + 3, 926, 463, 0, 10118, 10119, 5, 900, 0, 0, 10119, 10120, 5, 1180, 0, 0, + 10120, 10121, 3, 1238, 619, 0, 10121, 10122, 3, 926, 463, 0, 10122, 10142, + 1, 0, 0, 0, 10123, 10124, 5, 900, 0, 0, 10124, 10125, 5, 1180, 0, 0, 10125, + 10126, 5, 1188, 0, 0, 10126, 10127, 5, 213, 0, 0, 10127, 10138, 3, 914, + 457, 0, 10128, 10136, 5, 365, 0, 0, 10129, 10130, 5, 767, 0, 0, 10130, + 10137, 5, 664, 0, 0, 10131, 10134, 5, 1042, 0, 0, 10132, 10133, 5, 655, + 0, 0, 10133, 10135, 3, 1192, 596, 0, 10134, 10132, 1, 0, 0, 0, 10134, 10135, + 1, 0, 0, 0, 10135, 10137, 1, 0, 0, 0, 10136, 10129, 1, 0, 0, 0, 10136, + 10131, 1, 0, 0, 0, 10137, 10139, 1, 0, 0, 0, 10138, 10128, 1, 0, 0, 0, + 10138, 10139, 1, 0, 0, 0, 10139, 10142, 1, 0, 0, 0, 10140, 10142, 3, 920, + 460, 0, 10141, 10110, 1, 0, 0, 0, 10141, 10118, 1, 0, 0, 0, 10141, 10123, + 1, 0, 0, 0, 10141, 10140, 1, 0, 0, 0, 10142, 805, 1, 0, 0, 0, 10143, 10144, + 5, 90, 0, 0, 10144, 10145, 5, 275, 0, 0, 10145, 10148, 7, 113, 0, 0, 10146, + 10149, 3, 1230, 615, 0, 10147, 10149, 5, 1180, 0, 0, 10148, 10146, 1, 0, + 0, 0, 10148, 10147, 1, 0, 0, 0, 10148, 10149, 1, 0, 0, 0, 10149, 10204, + 1, 0, 0, 0, 10150, 10151, 5, 90, 0, 0, 10151, 10161, 7, 113, 0, 0, 10152, + 10155, 3, 1230, 615, 0, 10153, 10155, 5, 1180, 0, 0, 10154, 10152, 1, 0, + 0, 0, 10154, 10153, 1, 0, 0, 0, 10155, 10159, 1, 0, 0, 0, 10156, 10157, + 5, 1077, 0, 0, 10157, 10158, 5, 544, 0, 0, 10158, 10160, 5, 1184, 0, 0, + 10159, 10156, 1, 0, 0, 0, 10159, 10160, 1, 0, 0, 0, 10160, 10162, 1, 0, + 0, 0, 10161, 10154, 1, 0, 0, 0, 10161, 10162, 1, 0, 0, 0, 10162, 10204, + 1, 0, 0, 0, 10163, 10164, 5, 164, 0, 0, 10164, 10177, 7, 113, 0, 0, 10165, + 10168, 3, 1230, 615, 0, 10166, 10168, 5, 1180, 0, 0, 10167, 10165, 1, 0, + 0, 0, 10167, 10166, 1, 0, 0, 0, 10168, 10175, 1, 0, 0, 0, 10169, 10170, + 5, 1077, 0, 0, 10170, 10171, 5, 1206, 0, 0, 10171, 10172, 5, 253, 0, 0, + 10172, 10173, 5, 1188, 0, 0, 10173, 10174, 7, 17, 0, 0, 10174, 10176, 5, + 1207, 0, 0, 10175, 10169, 1, 0, 0, 0, 10175, 10176, 1, 0, 0, 0, 10176, + 10178, 1, 0, 0, 0, 10177, 10167, 1, 0, 0, 0, 10177, 10178, 1, 0, 0, 0, + 10178, 10204, 1, 0, 0, 0, 10179, 10181, 5, 164, 0, 0, 10180, 10182, 5, + 1082, 0, 0, 10181, 10180, 1, 0, 0, 0, 10181, 10182, 1, 0, 0, 0, 10182, + 10204, 1, 0, 0, 0, 10183, 10184, 5, 164, 0, 0, 10184, 10204, 3, 1230, 615, + 0, 10185, 10186, 5, 833, 0, 0, 10186, 10204, 3, 1230, 615, 0, 10187, 10188, + 5, 833, 0, 0, 10188, 10191, 7, 113, 0, 0, 10189, 10192, 3, 1230, 615, 0, + 10190, 10192, 5, 1180, 0, 0, 10191, 10189, 1, 0, 0, 0, 10191, 10190, 1, + 0, 0, 0, 10191, 10192, 1, 0, 0, 0, 10192, 10204, 1, 0, 0, 0, 10193, 10195, + 5, 833, 0, 0, 10194, 10196, 5, 1082, 0, 0, 10195, 10194, 1, 0, 0, 0, 10195, + 10196, 1, 0, 0, 0, 10196, 10204, 1, 0, 0, 0, 10197, 10198, 5, 855, 0, 0, + 10198, 10201, 7, 113, 0, 0, 10199, 10202, 3, 1230, 615, 0, 10200, 10202, + 5, 1180, 0, 0, 10201, 10199, 1, 0, 0, 0, 10201, 10200, 1, 0, 0, 0, 10201, + 10202, 1, 0, 0, 0, 10202, 10204, 1, 0, 0, 0, 10203, 10143, 1, 0, 0, 0, + 10203, 10150, 1, 0, 0, 0, 10203, 10163, 1, 0, 0, 0, 10203, 10179, 1, 0, + 0, 0, 10203, 10183, 1, 0, 0, 0, 10203, 10185, 1, 0, 0, 0, 10203, 10187, + 1, 0, 0, 0, 10203, 10193, 1, 0, 0, 0, 10203, 10197, 1, 0, 0, 0, 10204, + 807, 1, 0, 0, 0, 10205, 10207, 5, 407, 0, 0, 10206, 10208, 5, 1182, 0, + 0, 10207, 10206, 1, 0, 0, 0, 10207, 10208, 1, 0, 0, 0, 10208, 809, 1, 0, + 0, 0, 10209, 10210, 5, 1047, 0, 0, 10210, 10211, 3, 1230, 615, 0, 10211, + 811, 1, 0, 0, 0, 10212, 10214, 5, 904, 0, 0, 10213, 10215, 5, 1184, 0, + 0, 10214, 10213, 1, 0, 0, 0, 10214, 10215, 1, 0, 0, 0, 10215, 813, 1, 0, + 0, 0, 10216, 10219, 5, 783, 0, 0, 10217, 10218, 5, 1077, 0, 0, 10218, 10220, + 5, 686, 0, 0, 10219, 10217, 1, 0, 0, 0, 10219, 10220, 1, 0, 0, 0, 10220, + 815, 1, 0, 0, 0, 10221, 10224, 5, 913, 0, 0, 10222, 10223, 5, 1077, 0, + 0, 10223, 10225, 5, 631, 0, 0, 10224, 10222, 1, 0, 0, 0, 10224, 10225, + 1, 0, 0, 0, 10225, 817, 1, 0, 0, 0, 10226, 10228, 5, 139, 0, 0, 10227, + 10229, 5, 1182, 0, 0, 10228, 10227, 1, 0, 0, 0, 10228, 10229, 1, 0, 0, + 0, 10229, 819, 1, 0, 0, 0, 10230, 10231, 7, 114, 0, 0, 10231, 821, 1, 0, + 0, 0, 10232, 10257, 5, 134, 0, 0, 10233, 10237, 5, 1206, 0, 0, 10234, 10238, + 3, 1230, 615, 0, 10235, 10238, 5, 1184, 0, 0, 10236, 10238, 5, 1182, 0, + 0, 10237, 10234, 1, 0, 0, 0, 10237, 10235, 1, 0, 0, 0, 10237, 10236, 1, + 0, 0, 0, 10238, 10243, 1, 0, 0, 0, 10239, 10240, 5, 1208, 0, 0, 10240, + 10244, 5, 617, 0, 0, 10241, 10242, 5, 1208, 0, 0, 10242, 10244, 7, 115, + 0, 0, 10243, 10239, 1, 0, 0, 0, 10243, 10241, 1, 0, 0, 0, 10243, 10244, + 1, 0, 0, 0, 10244, 10245, 1, 0, 0, 0, 10245, 10255, 5, 1207, 0, 0, 10246, + 10247, 5, 1077, 0, 0, 10247, 10252, 3, 820, 410, 0, 10248, 10249, 5, 1208, + 0, 0, 10249, 10251, 3, 820, 410, 0, 10250, 10248, 1, 0, 0, 0, 10251, 10254, + 1, 0, 0, 0, 10252, 10250, 1, 0, 0, 0, 10252, 10253, 1, 0, 0, 0, 10253, + 10256, 1, 0, 0, 0, 10254, 10252, 1, 0, 0, 0, 10255, 10246, 1, 0, 0, 0, + 10255, 10256, 1, 0, 0, 0, 10256, 10258, 1, 0, 0, 0, 10257, 10233, 1, 0, + 0, 0, 10257, 10258, 1, 0, 0, 0, 10258, 823, 1, 0, 0, 0, 10259, 10267, 5, + 135, 0, 0, 10260, 10264, 5, 1206, 0, 0, 10261, 10265, 3, 1230, 615, 0, + 10262, 10265, 5, 1184, 0, 0, 10263, 10265, 5, 1182, 0, 0, 10264, 10261, + 1, 0, 0, 0, 10264, 10262, 1, 0, 0, 0, 10264, 10263, 1, 0, 0, 0, 10265, + 10266, 1, 0, 0, 0, 10266, 10268, 5, 1207, 0, 0, 10267, 10260, 1, 0, 0, + 0, 10267, 10268, 1, 0, 0, 0, 10268, 10271, 1, 0, 0, 0, 10269, 10270, 5, + 1077, 0, 0, 10270, 10272, 5, 635, 0, 0, 10271, 10269, 1, 0, 0, 0, 10271, + 10272, 1, 0, 0, 0, 10272, 825, 1, 0, 0, 0, 10273, 10274, 7, 116, 0, 0, + 10274, 827, 1, 0, 0, 0, 10275, 10282, 5, 136, 0, 0, 10276, 10279, 5, 1206, + 0, 0, 10277, 10280, 3, 1230, 615, 0, 10278, 10280, 5, 1184, 0, 0, 10279, + 10277, 1, 0, 0, 0, 10279, 10278, 1, 0, 0, 0, 10280, 10281, 1, 0, 0, 0, + 10281, 10283, 5, 1207, 0, 0, 10282, 10276, 1, 0, 0, 0, 10282, 10283, 1, + 0, 0, 0, 10283, 10293, 1, 0, 0, 0, 10284, 10285, 5, 1077, 0, 0, 10285, + 10290, 3, 826, 413, 0, 10286, 10287, 5, 1208, 0, 0, 10287, 10289, 3, 826, + 413, 0, 10288, 10286, 1, 0, 0, 0, 10289, 10292, 1, 0, 0, 0, 10290, 10288, + 1, 0, 0, 0, 10290, 10291, 1, 0, 0, 0, 10291, 10294, 1, 0, 0, 0, 10292, + 10290, 1, 0, 0, 0, 10293, 10284, 1, 0, 0, 0, 10293, 10294, 1, 0, 0, 0, + 10294, 829, 1, 0, 0, 0, 10295, 10306, 5, 32, 0, 0, 10296, 10306, 5, 329, + 0, 0, 10297, 10306, 5, 635, 0, 0, 10298, 10306, 5, 983, 0, 0, 10299, 10306, + 5, 312, 0, 0, 10300, 10306, 5, 719, 0, 0, 10301, 10306, 5, 226, 0, 0, 10302, + 10303, 5, 551, 0, 0, 10303, 10304, 5, 1188, 0, 0, 10304, 10306, 5, 1182, + 0, 0, 10305, 10295, 1, 0, 0, 0, 10305, 10296, 1, 0, 0, 0, 10305, 10297, + 1, 0, 0, 0, 10305, 10298, 1, 0, 0, 0, 10305, 10299, 1, 0, 0, 0, 10305, + 10300, 1, 0, 0, 0, 10305, 10301, 1, 0, 0, 0, 10305, 10302, 1, 0, 0, 0, + 10306, 831, 1, 0, 0, 0, 10307, 10319, 5, 137, 0, 0, 10308, 10312, 5, 1206, + 0, 0, 10309, 10313, 3, 1230, 615, 0, 10310, 10313, 5, 1184, 0, 0, 10311, + 10313, 5, 1182, 0, 0, 10312, 10309, 1, 0, 0, 0, 10312, 10310, 1, 0, 0, + 0, 10312, 10311, 1, 0, 0, 0, 10313, 10316, 1, 0, 0, 0, 10314, 10315, 5, + 1208, 0, 0, 10315, 10317, 7, 117, 0, 0, 10316, 10314, 1, 0, 0, 0, 10316, + 10317, 1, 0, 0, 0, 10317, 10318, 1, 0, 0, 0, 10318, 10320, 5, 1207, 0, + 0, 10319, 10308, 1, 0, 0, 0, 10319, 10320, 1, 0, 0, 0, 10320, 10330, 1, + 0, 0, 0, 10321, 10322, 5, 1077, 0, 0, 10322, 10327, 3, 830, 415, 0, 10323, + 10324, 5, 1208, 0, 0, 10324, 10326, 3, 830, 415, 0, 10325, 10323, 1, 0, + 0, 0, 10326, 10329, 1, 0, 0, 0, 10327, 10325, 1, 0, 0, 0, 10327, 10328, + 1, 0, 0, 0, 10328, 10331, 1, 0, 0, 0, 10329, 10327, 1, 0, 0, 0, 10330, + 10321, 1, 0, 0, 0, 10330, 10331, 1, 0, 0, 0, 10331, 833, 1, 0, 0, 0, 10332, + 10341, 5, 32, 0, 0, 10333, 10341, 5, 635, 0, 0, 10334, 10341, 5, 983, 0, + 0, 10335, 10341, 5, 312, 0, 0, 10336, 10341, 5, 719, 0, 0, 10337, 10338, + 5, 551, 0, 0, 10338, 10339, 5, 1188, 0, 0, 10339, 10341, 5, 1182, 0, 0, + 10340, 10332, 1, 0, 0, 0, 10340, 10333, 1, 0, 0, 0, 10340, 10334, 1, 0, + 0, 0, 10340, 10335, 1, 0, 0, 0, 10340, 10336, 1, 0, 0, 0, 10340, 10337, + 1, 0, 0, 0, 10341, 835, 1, 0, 0, 0, 10342, 10353, 5, 138, 0, 0, 10343, + 10346, 5, 1206, 0, 0, 10344, 10347, 5, 1182, 0, 0, 10345, 10347, 5, 1184, + 0, 0, 10346, 10344, 1, 0, 0, 0, 10346, 10345, 1, 0, 0, 0, 10347, 10350, + 1, 0, 0, 0, 10348, 10349, 5, 1208, 0, 0, 10349, 10351, 7, 117, 0, 0, 10350, + 10348, 1, 0, 0, 0, 10350, 10351, 1, 0, 0, 0, 10351, 10352, 1, 0, 0, 0, + 10352, 10354, 5, 1207, 0, 0, 10353, 10343, 1, 0, 0, 0, 10353, 10354, 1, + 0, 0, 0, 10354, 10364, 1, 0, 0, 0, 10355, 10356, 5, 1077, 0, 0, 10356, + 10361, 3, 834, 417, 0, 10357, 10358, 5, 1208, 0, 0, 10358, 10360, 3, 834, + 417, 0, 10359, 10357, 1, 0, 0, 0, 10360, 10363, 1, 0, 0, 0, 10361, 10359, + 1, 0, 0, 0, 10361, 10362, 1, 0, 0, 0, 10362, 10365, 1, 0, 0, 0, 10363, + 10361, 1, 0, 0, 0, 10364, 10355, 1, 0, 0, 0, 10364, 10365, 1, 0, 0, 0, + 10365, 837, 1, 0, 0, 0, 10366, 10367, 5, 142, 0, 0, 10367, 10368, 5, 1206, + 0, 0, 10368, 10377, 5, 1184, 0, 0, 10369, 10375, 5, 1208, 0, 0, 10370, + 10376, 5, 617, 0, 0, 10371, 10376, 3, 926, 463, 0, 10372, 10376, 5, 796, + 0, 0, 10373, 10376, 5, 797, 0, 0, 10374, 10376, 5, 798, 0, 0, 10375, 10370, + 1, 0, 0, 0, 10375, 10371, 1, 0, 0, 0, 10375, 10372, 1, 0, 0, 0, 10375, + 10373, 1, 0, 0, 0, 10375, 10374, 1, 0, 0, 0, 10376, 10378, 1, 0, 0, 0, + 10377, 10369, 1, 0, 0, 0, 10377, 10378, 1, 0, 0, 0, 10378, 10379, 1, 0, + 0, 0, 10379, 10389, 5, 1207, 0, 0, 10380, 10381, 5, 1077, 0, 0, 10381, + 10386, 3, 830, 415, 0, 10382, 10383, 5, 1208, 0, 0, 10383, 10385, 3, 830, + 415, 0, 10384, 10382, 1, 0, 0, 0, 10385, 10388, 1, 0, 0, 0, 10386, 10384, + 1, 0, 0, 0, 10386, 10387, 1, 0, 0, 0, 10387, 10390, 1, 0, 0, 0, 10388, + 10386, 1, 0, 0, 0, 10389, 10380, 1, 0, 0, 0, 10389, 10390, 1, 0, 0, 0, + 10390, 839, 1, 0, 0, 0, 10391, 10392, 5, 146, 0, 0, 10392, 10396, 5, 1206, + 0, 0, 10393, 10397, 3, 1230, 615, 0, 10394, 10397, 5, 1184, 0, 0, 10395, + 10397, 5, 1182, 0, 0, 10396, 10393, 1, 0, 0, 0, 10396, 10394, 1, 0, 0, + 0, 10396, 10395, 1, 0, 0, 0, 10397, 10398, 1, 0, 0, 0, 10398, 10401, 5, + 1208, 0, 0, 10399, 10402, 3, 1230, 615, 0, 10400, 10402, 5, 1184, 0, 0, + 10401, 10399, 1, 0, 0, 0, 10401, 10400, 1, 0, 0, 0, 10402, 10405, 1, 0, + 0, 0, 10403, 10404, 5, 1208, 0, 0, 10404, 10406, 5, 1182, 0, 0, 10405, + 10403, 1, 0, 0, 0, 10405, 10406, 1, 0, 0, 0, 10406, 10407, 1, 0, 0, 0, + 10407, 10410, 5, 1207, 0, 0, 10408, 10409, 5, 1077, 0, 0, 10409, 10411, + 5, 635, 0, 0, 10410, 10408, 1, 0, 0, 0, 10410, 10411, 1, 0, 0, 0, 10411, + 841, 1, 0, 0, 0, 10412, 10413, 7, 118, 0, 0, 10413, 843, 1, 0, 0, 0, 10414, + 10415, 5, 148, 0, 0, 10415, 10416, 5, 1206, 0, 0, 10416, 10417, 3, 1230, + 615, 0, 10417, 10418, 5, 1208, 0, 0, 10418, 10419, 3, 1230, 615, 0, 10419, + 10429, 5, 1207, 0, 0, 10420, 10421, 5, 1077, 0, 0, 10421, 10426, 3, 842, + 421, 0, 10422, 10423, 5, 1208, 0, 0, 10423, 10425, 3, 842, 421, 0, 10424, + 10422, 1, 0, 0, 0, 10425, 10428, 1, 0, 0, 0, 10426, 10424, 1, 0, 0, 0, + 10426, 10427, 1, 0, 0, 0, 10427, 10430, 1, 0, 0, 0, 10428, 10426, 1, 0, + 0, 0, 10429, 10420, 1, 0, 0, 0, 10429, 10430, 1, 0, 0, 0, 10430, 845, 1, + 0, 0, 0, 10431, 10436, 5, 707, 0, 0, 10432, 10433, 5, 1206, 0, 0, 10433, + 10434, 3, 1230, 615, 0, 10434, 10435, 5, 1207, 0, 0, 10435, 10437, 1, 0, + 0, 0, 10436, 10432, 1, 0, 0, 0, 10436, 10437, 1, 0, 0, 0, 10437, 10440, + 1, 0, 0, 0, 10438, 10439, 5, 1077, 0, 0, 10439, 10441, 5, 444, 0, 0, 10440, + 10438, 1, 0, 0, 0, 10440, 10441, 1, 0, 0, 0, 10441, 847, 1, 0, 0, 0, 10442, + 10445, 5, 740, 0, 0, 10443, 10444, 5, 1077, 0, 0, 10444, 10446, 5, 635, + 0, 0, 10445, 10443, 1, 0, 0, 0, 10445, 10446, 1, 0, 0, 0, 10446, 849, 1, + 0, 0, 0, 10447, 10448, 7, 119, 0, 0, 10448, 851, 1, 0, 0, 0, 10449, 10458, + 5, 907, 0, 0, 10450, 10451, 5, 1206, 0, 0, 10451, 10454, 3, 926, 463, 0, + 10452, 10453, 5, 1208, 0, 0, 10453, 10455, 3, 926, 463, 0, 10454, 10452, + 1, 0, 0, 0, 10454, 10455, 1, 0, 0, 0, 10455, 10456, 1, 0, 0, 0, 10456, + 10457, 5, 1207, 0, 0, 10457, 10459, 1, 0, 0, 0, 10458, 10450, 1, 0, 0, + 0, 10458, 10459, 1, 0, 0, 0, 10459, 10469, 1, 0, 0, 0, 10460, 10461, 5, + 1077, 0, 0, 10461, 10466, 3, 850, 425, 0, 10462, 10463, 5, 1208, 0, 0, + 10463, 10465, 3, 850, 425, 0, 10464, 10462, 1, 0, 0, 0, 10465, 10468, 1, + 0, 0, 0, 10466, 10464, 1, 0, 0, 0, 10466, 10467, 1, 0, 0, 0, 10467, 10470, + 1, 0, 0, 0, 10468, 10466, 1, 0, 0, 0, 10469, 10460, 1, 0, 0, 0, 10469, + 10470, 1, 0, 0, 0, 10470, 853, 1, 0, 0, 0, 10471, 10481, 5, 912, 0, 0, + 10472, 10473, 5, 1206, 0, 0, 10473, 10474, 5, 918, 0, 0, 10474, 10478, + 5, 1188, 0, 0, 10475, 10476, 5, 1182, 0, 0, 10476, 10479, 7, 51, 0, 0, + 10477, 10479, 5, 245, 0, 0, 10478, 10475, 1, 0, 0, 0, 10478, 10477, 1, + 0, 0, 0, 10479, 10480, 1, 0, 0, 0, 10480, 10482, 5, 1207, 0, 0, 10481, + 10472, 1, 0, 0, 0, 10481, 10482, 1, 0, 0, 0, 10482, 10485, 1, 0, 0, 0, + 10483, 10484, 5, 1077, 0, 0, 10484, 10486, 5, 635, 0, 0, 10485, 10483, + 1, 0, 0, 0, 10485, 10486, 1, 0, 0, 0, 10486, 855, 1, 0, 0, 0, 10487, 10488, + 5, 235, 0, 0, 10488, 10489, 5, 1206, 0, 0, 10489, 10496, 3, 1234, 617, + 0, 10490, 10491, 5, 1208, 0, 0, 10491, 10494, 3, 1234, 617, 0, 10492, 10493, + 5, 1208, 0, 0, 10493, 10495, 3, 926, 463, 0, 10494, 10492, 1, 0, 0, 0, + 10494, 10495, 1, 0, 0, 0, 10495, 10497, 1, 0, 0, 0, 10496, 10490, 1, 0, + 0, 0, 10496, 10497, 1, 0, 0, 0, 10497, 10498, 1, 0, 0, 0, 10498, 10501, + 5, 1207, 0, 0, 10499, 10500, 5, 1077, 0, 0, 10500, 10502, 5, 635, 0, 0, + 10501, 10499, 1, 0, 0, 0, 10501, 10502, 1, 0, 0, 0, 10502, 857, 1, 0, 0, + 0, 10503, 10504, 3, 1230, 615, 0, 10504, 10505, 5, 1206, 0, 0, 10505, 10506, + 5, 377, 0, 0, 10506, 10509, 5, 1207, 0, 0, 10507, 10508, 5, 1077, 0, 0, + 10508, 10510, 5, 635, 0, 0, 10509, 10507, 1, 0, 0, 0, 10509, 10510, 1, + 0, 0, 0, 10510, 859, 1, 0, 0, 0, 10511, 10516, 5, 283, 0, 0, 10512, 10513, + 5, 1206, 0, 0, 10513, 10517, 5, 171, 0, 0, 10514, 10515, 5, 22, 0, 0, 10515, + 10517, 5, 1207, 0, 0, 10516, 10512, 1, 0, 0, 0, 10516, 10514, 1, 0, 0, + 0, 10516, 10517, 1, 0, 0, 0, 10517, 10520, 1, 0, 0, 0, 10518, 10519, 5, + 1077, 0, 0, 10519, 10521, 5, 635, 0, 0, 10520, 10518, 1, 0, 0, 0, 10520, + 10521, 1, 0, 0, 0, 10521, 861, 1, 0, 0, 0, 10522, 10538, 5, 234, 0, 0, + 10523, 10539, 3, 822, 411, 0, 10524, 10539, 3, 824, 412, 0, 10525, 10539, + 3, 828, 414, 0, 10526, 10539, 3, 832, 416, 0, 10527, 10539, 3, 836, 418, + 0, 10528, 10539, 3, 838, 419, 0, 10529, 10539, 3, 840, 420, 0, 10530, 10539, + 3, 844, 422, 0, 10531, 10539, 3, 856, 428, 0, 10532, 10539, 3, 858, 429, + 0, 10533, 10539, 3, 860, 430, 0, 10534, 10539, 3, 846, 423, 0, 10535, 10539, + 3, 848, 424, 0, 10536, 10539, 3, 852, 426, 0, 10537, 10539, 3, 854, 427, + 0, 10538, 10523, 1, 0, 0, 0, 10538, 10524, 1, 0, 0, 0, 10538, 10525, 1, + 0, 0, 0, 10538, 10526, 1, 0, 0, 0, 10538, 10527, 1, 0, 0, 0, 10538, 10528, + 1, 0, 0, 0, 10538, 10529, 1, 0, 0, 0, 10538, 10530, 1, 0, 0, 0, 10538, + 10531, 1, 0, 0, 0, 10538, 10532, 1, 0, 0, 0, 10538, 10533, 1, 0, 0, 0, + 10538, 10534, 1, 0, 0, 0, 10538, 10535, 1, 0, 0, 0, 10538, 10536, 1, 0, + 0, 0, 10538, 10537, 1, 0, 0, 0, 10539, 863, 1, 0, 0, 0, 10540, 10541, 5, + 320, 0, 0, 10541, 10542, 5, 56, 0, 0, 10542, 10543, 7, 120, 0, 0, 10543, + 865, 1, 0, 0, 0, 10544, 10546, 5, 1180, 0, 0, 10545, 10547, 5, 56, 0, 0, + 10546, 10545, 1, 0, 0, 0, 10546, 10547, 1, 0, 0, 0, 10547, 10548, 1, 0, + 0, 0, 10548, 10551, 3, 1222, 611, 0, 10549, 10550, 5, 1188, 0, 0, 10550, + 10552, 3, 926, 463, 0, 10551, 10549, 1, 0, 0, 0, 10551, 10552, 1, 0, 0, + 0, 10552, 867, 1, 0, 0, 0, 10553, 10554, 5, 980, 0, 0, 10554, 10555, 5, + 1206, 0, 0, 10555, 10562, 3, 876, 438, 0, 10556, 10558, 5, 1208, 0, 0, + 10557, 10556, 1, 0, 0, 0, 10557, 10558, 1, 0, 0, 0, 10558, 10559, 1, 0, + 0, 0, 10559, 10561, 3, 870, 435, 0, 10560, 10557, 1, 0, 0, 0, 10561, 10564, + 1, 0, 0, 0, 10562, 10560, 1, 0, 0, 0, 10562, 10563, 1, 0, 0, 0, 10563, + 10565, 1, 0, 0, 0, 10564, 10562, 1, 0, 0, 0, 10565, 10566, 5, 1207, 0, + 0, 10566, 869, 1, 0, 0, 0, 10567, 10568, 5, 730, 0, 0, 10568, 10572, 5, + 498, 0, 0, 10569, 10570, 5, 456, 0, 0, 10570, 10572, 3, 1230, 615, 0, 10571, + 10567, 1, 0, 0, 0, 10571, 10569, 1, 0, 0, 0, 10572, 10574, 1, 0, 0, 0, + 10573, 10575, 7, 121, 0, 0, 10574, 10573, 1, 0, 0, 0, 10574, 10575, 1, + 0, 0, 0, 10575, 10578, 1, 0, 0, 0, 10576, 10578, 5, 1034, 0, 0, 10577, + 10571, 1, 0, 0, 0, 10577, 10576, 1, 0, 0, 0, 10578, 10579, 1, 0, 0, 0, + 10579, 10580, 5, 1206, 0, 0, 10580, 10581, 3, 1184, 592, 0, 10581, 10582, + 5, 1207, 0, 0, 10582, 10589, 1, 0, 0, 0, 10583, 10584, 5, 133, 0, 0, 10584, + 10585, 5, 1206, 0, 0, 10585, 10586, 3, 950, 475, 0, 10586, 10587, 5, 1207, + 0, 0, 10587, 10589, 1, 0, 0, 0, 10588, 10577, 1, 0, 0, 0, 10588, 10583, + 1, 0, 0, 0, 10589, 871, 1, 0, 0, 0, 10590, 10591, 5, 1088, 0, 0, 10591, + 10593, 5, 1206, 0, 0, 10592, 10594, 7, 122, 0, 0, 10593, 10592, 1, 0, 0, + 0, 10593, 10594, 1, 0, 0, 0, 10594, 10595, 1, 0, 0, 0, 10595, 10596, 3, + 874, 437, 0, 10596, 10597, 5, 1207, 0, 0, 10597, 873, 1, 0, 0, 0, 10598, + 10599, 5, 1183, 0, 0, 10599, 10600, 5, 1201, 0, 0, 10600, 10601, 5, 1183, + 0, 0, 10601, 875, 1, 0, 0, 0, 10602, 10609, 3, 878, 439, 0, 10603, 10605, + 5, 1208, 0, 0, 10604, 10603, 1, 0, 0, 0, 10604, 10605, 1, 0, 0, 0, 10605, + 10606, 1, 0, 0, 0, 10606, 10608, 3, 878, 439, 0, 10607, 10604, 1, 0, 0, + 0, 10608, 10611, 1, 0, 0, 0, 10609, 10607, 1, 0, 0, 0, 10609, 10610, 1, + 0, 0, 0, 10610, 877, 1, 0, 0, 0, 10611, 10609, 1, 0, 0, 0, 10612, 10616, + 3, 880, 440, 0, 10613, 10616, 3, 886, 443, 0, 10614, 10616, 3, 894, 447, + 0, 10615, 10612, 1, 0, 0, 0, 10615, 10613, 1, 0, 0, 0, 10615, 10614, 1, + 0, 0, 0, 10616, 879, 1, 0, 0, 0, 10617, 10624, 3, 1230, 615, 0, 10618, + 10625, 3, 1222, 611, 0, 10619, 10620, 5, 56, 0, 0, 10620, 10622, 3, 926, + 463, 0, 10621, 10623, 5, 714, 0, 0, 10622, 10621, 1, 0, 0, 0, 10622, 10623, + 1, 0, 0, 0, 10623, 10625, 1, 0, 0, 0, 10624, 10618, 1, 0, 0, 0, 10624, + 10619, 1, 0, 0, 0, 10625, 10629, 1, 0, 0, 0, 10626, 10628, 3, 882, 441, + 0, 10627, 10626, 1, 0, 0, 0, 10628, 10631, 1, 0, 0, 0, 10629, 10627, 1, + 0, 0, 0, 10629, 10630, 1, 0, 0, 0, 10630, 10633, 1, 0, 0, 0, 10631, 10629, + 1, 0, 0, 0, 10632, 10634, 3, 890, 445, 0, 10633, 10632, 1, 0, 0, 0, 10633, + 10634, 1, 0, 0, 0, 10634, 881, 1, 0, 0, 0, 10635, 10689, 5, 353, 0, 0, + 10636, 10637, 5, 153, 0, 0, 10637, 10689, 3, 1230, 615, 0, 10638, 10689, + 5, 928, 0, 0, 10639, 10640, 5, 546, 0, 0, 10640, 10641, 5, 1077, 0, 0, + 10641, 10642, 5, 1206, 0, 0, 10642, 10643, 5, 386, 0, 0, 10643, 10644, + 5, 1188, 0, 0, 10644, 10645, 5, 1184, 0, 0, 10645, 10689, 5, 1207, 0, 0, + 10646, 10647, 5, 179, 0, 0, 10647, 10649, 3, 1230, 615, 0, 10648, 10646, + 1, 0, 0, 0, 10648, 10649, 1, 0, 0, 0, 10649, 10650, 1, 0, 0, 0, 10650, + 10651, 5, 245, 0, 0, 10651, 10689, 3, 926, 463, 0, 10652, 10658, 5, 433, + 0, 0, 10653, 10654, 5, 1206, 0, 0, 10654, 10655, 5, 1182, 0, 0, 10655, + 10656, 5, 1208, 0, 0, 10656, 10657, 5, 1182, 0, 0, 10657, 10659, 5, 1207, + 0, 0, 10658, 10653, 1, 0, 0, 0, 10658, 10659, 1, 0, 0, 0, 10659, 10689, + 1, 0, 0, 0, 10660, 10661, 5, 627, 0, 0, 10661, 10662, 5, 365, 0, 0, 10662, + 10689, 5, 804, 0, 0, 10663, 10664, 5, 388, 0, 0, 10664, 10665, 5, 36, 0, + 0, 10665, 10666, 5, 56, 0, 0, 10666, 10667, 7, 123, 0, 0, 10667, 10669, + 7, 124, 0, 0, 10668, 10670, 5, 425, 0, 0, 10669, 10668, 1, 0, 0, 0, 10669, + 10670, 1, 0, 0, 0, 10670, 10689, 1, 0, 0, 0, 10671, 10689, 5, 841, 0, 0, + 10672, 10673, 5, 295, 0, 0, 10673, 10674, 5, 1077, 0, 0, 10674, 10675, + 5, 1206, 0, 0, 10675, 10676, 5, 160, 0, 0, 10676, 10677, 5, 1188, 0, 0, + 10677, 10678, 5, 1184, 0, 0, 10678, 10679, 5, 1208, 0, 0, 10679, 10680, + 5, 298, 0, 0, 10680, 10681, 5, 1188, 0, 0, 10681, 10682, 7, 125, 0, 0, + 10682, 10683, 5, 1208, 0, 0, 10683, 10684, 5, 21, 0, 0, 10684, 10685, 5, + 1188, 0, 0, 10685, 10686, 5, 1184, 0, 0, 10686, 10689, 5, 1207, 0, 0, 10687, + 10689, 3, 888, 444, 0, 10688, 10635, 1, 0, 0, 0, 10688, 10636, 1, 0, 0, + 0, 10688, 10638, 1, 0, 0, 0, 10688, 10639, 1, 0, 0, 0, 10688, 10648, 1, + 0, 0, 0, 10688, 10652, 1, 0, 0, 0, 10688, 10660, 1, 0, 0, 0, 10688, 10663, + 1, 0, 0, 0, 10688, 10671, 1, 0, 0, 0, 10688, 10672, 1, 0, 0, 0, 10688, + 10687, 1, 0, 0, 0, 10689, 883, 1, 0, 0, 0, 10690, 10691, 3, 1230, 615, + 0, 10691, 10713, 7, 23, 0, 0, 10692, 10714, 5, 841, 0, 0, 10693, 10714, + 5, 714, 0, 0, 10694, 10695, 5, 627, 0, 0, 10695, 10696, 5, 365, 0, 0, 10696, + 10714, 5, 804, 0, 0, 10697, 10714, 5, 928, 0, 0, 10698, 10714, 5, 425, + 0, 0, 10699, 10711, 5, 546, 0, 0, 10700, 10709, 5, 1077, 0, 0, 10701, 10702, + 5, 386, 0, 0, 10702, 10703, 5, 1188, 0, 0, 10703, 10710, 5, 1184, 0, 0, + 10704, 10705, 5, 1206, 0, 0, 10705, 10706, 5, 386, 0, 0, 10706, 10707, + 5, 1188, 0, 0, 10707, 10708, 5, 1184, 0, 0, 10708, 10710, 5, 1207, 0, 0, + 10709, 10701, 1, 0, 0, 0, 10709, 10704, 1, 0, 0, 0, 10710, 10712, 1, 0, + 0, 0, 10711, 10700, 1, 0, 0, 0, 10711, 10712, 1, 0, 0, 0, 10712, 10714, + 1, 0, 0, 0, 10713, 10692, 1, 0, 0, 0, 10713, 10693, 1, 0, 0, 0, 10713, + 10694, 1, 0, 0, 0, 10713, 10697, 1, 0, 0, 0, 10713, 10698, 1, 0, 0, 0, + 10713, 10699, 1, 0, 0, 0, 10714, 885, 1, 0, 0, 0, 10715, 10716, 3, 1230, + 615, 0, 10716, 10717, 7, 126, 0, 0, 10717, 10721, 3, 926, 463, 0, 10718, + 10722, 5, 549, 0, 0, 10719, 10720, 5, 627, 0, 0, 10720, 10722, 5, 549, + 0, 0, 10721, 10718, 1, 0, 0, 0, 10721, 10719, 1, 0, 0, 0, 10721, 10722, + 1, 0, 0, 0, 10722, 887, 1, 0, 0, 0, 10723, 10724, 5, 179, 0, 0, 10724, + 10726, 3, 1230, 615, 0, 10725, 10723, 1, 0, 0, 0, 10725, 10726, 1, 0, 0, + 0, 10726, 10743, 1, 0, 0, 0, 10727, 10744, 3, 1200, 600, 0, 10728, 10729, + 5, 730, 0, 0, 10729, 10732, 5, 498, 0, 0, 10730, 10732, 5, 1034, 0, 0, + 10731, 10728, 1, 0, 0, 0, 10731, 10730, 1, 0, 0, 0, 10732, 10734, 1, 0, + 0, 0, 10733, 10735, 3, 1198, 599, 0, 10734, 10733, 1, 0, 0, 0, 10734, 10735, + 1, 0, 0, 0, 10735, 10736, 1, 0, 0, 0, 10736, 10744, 3, 898, 449, 0, 10737, + 10738, 5, 373, 0, 0, 10738, 10740, 5, 498, 0, 0, 10739, 10737, 1, 0, 0, + 0, 10739, 10740, 1, 0, 0, 0, 10740, 10741, 1, 0, 0, 0, 10741, 10744, 3, + 900, 450, 0, 10742, 10744, 3, 902, 451, 0, 10743, 10727, 1, 0, 0, 0, 10743, + 10731, 1, 0, 0, 0, 10743, 10739, 1, 0, 0, 0, 10743, 10742, 1, 0, 0, 0, + 10744, 889, 1, 0, 0, 0, 10745, 10746, 5, 456, 0, 0, 10746, 10748, 3, 1230, + 615, 0, 10747, 10749, 3, 1198, 599, 0, 10748, 10747, 1, 0, 0, 0, 10748, + 10749, 1, 0, 0, 0, 10749, 10751, 1, 0, 0, 0, 10750, 10752, 3, 606, 303, + 0, 10751, 10750, 1, 0, 0, 0, 10751, 10752, 1, 0, 0, 0, 10752, 10754, 1, + 0, 0, 0, 10753, 10755, 3, 892, 446, 0, 10754, 10753, 1, 0, 0, 0, 10754, + 10755, 1, 0, 0, 0, 10755, 10761, 1, 0, 0, 0, 10756, 10759, 5, 354, 0, 0, + 10757, 10760, 3, 1230, 615, 0, 10758, 10760, 5, 644, 0, 0, 10759, 10757, + 1, 0, 0, 0, 10759, 10758, 1, 0, 0, 0, 10760, 10762, 1, 0, 0, 0, 10761, + 10756, 1, 0, 0, 0, 10761, 10762, 1, 0, 0, 0, 10762, 891, 1, 0, 0, 0, 10763, + 10771, 5, 662, 0, 0, 10764, 10765, 3, 1230, 615, 0, 10765, 10766, 5, 1206, + 0, 0, 10766, 10767, 3, 1230, 615, 0, 10767, 10768, 5, 1207, 0, 0, 10768, + 10772, 1, 0, 0, 0, 10769, 10772, 3, 1230, 615, 0, 10770, 10772, 5, 247, + 0, 0, 10771, 10764, 1, 0, 0, 0, 10771, 10769, 1, 0, 0, 0, 10771, 10770, + 1, 0, 0, 0, 10772, 893, 1, 0, 0, 0, 10773, 10774, 5, 179, 0, 0, 10774, + 10776, 3, 1230, 615, 0, 10775, 10773, 1, 0, 0, 0, 10775, 10776, 1, 0, 0, + 0, 10776, 10818, 1, 0, 0, 0, 10777, 10778, 5, 730, 0, 0, 10778, 10781, + 5, 498, 0, 0, 10779, 10781, 5, 1034, 0, 0, 10780, 10777, 1, 0, 0, 0, 10780, + 10779, 1, 0, 0, 0, 10781, 10783, 1, 0, 0, 0, 10782, 10784, 3, 1198, 599, + 0, 10783, 10782, 1, 0, 0, 0, 10783, 10784, 1, 0, 0, 0, 10784, 10785, 1, + 0, 0, 0, 10785, 10786, 5, 1206, 0, 0, 10786, 10787, 3, 1184, 592, 0, 10787, + 10788, 5, 1207, 0, 0, 10788, 10789, 3, 898, 449, 0, 10789, 10819, 1, 0, + 0, 0, 10790, 10791, 5, 373, 0, 0, 10791, 10792, 5, 498, 0, 0, 10792, 10793, + 5, 1206, 0, 0, 10793, 10794, 3, 1192, 596, 0, 10794, 10795, 5, 1207, 0, + 0, 10795, 10796, 3, 900, 450, 0, 10796, 10819, 1, 0, 0, 0, 10797, 10798, + 5, 177, 0, 0, 10798, 10799, 5, 1206, 0, 0, 10799, 10804, 3, 896, 448, 0, + 10800, 10801, 5, 1208, 0, 0, 10801, 10803, 3, 896, 448, 0, 10802, 10800, + 1, 0, 0, 0, 10803, 10806, 1, 0, 0, 0, 10804, 10802, 1, 0, 0, 0, 10804, + 10805, 1, 0, 0, 0, 10805, 10807, 1, 0, 0, 0, 10806, 10804, 1, 0, 0, 0, + 10807, 10808, 5, 1207, 0, 0, 10808, 10819, 1, 0, 0, 0, 10809, 10810, 5, + 245, 0, 0, 10810, 10811, 3, 926, 463, 0, 10811, 10812, 5, 365, 0, 0, 10812, + 10815, 3, 1230, 615, 0, 10813, 10814, 5, 1077, 0, 0, 10814, 10816, 5, 1056, + 0, 0, 10815, 10813, 1, 0, 0, 0, 10815, 10816, 1, 0, 0, 0, 10816, 10819, + 1, 0, 0, 0, 10817, 10819, 3, 902, 451, 0, 10818, 10780, 1, 0, 0, 0, 10818, + 10790, 1, 0, 0, 0, 10818, 10797, 1, 0, 0, 0, 10818, 10809, 1, 0, 0, 0, + 10818, 10817, 1, 0, 0, 0, 10819, 895, 1, 0, 0, 0, 10820, 10821, 3, 1230, + 615, 0, 10821, 10822, 5, 1000, 0, 0, 10822, 10823, 3, 1230, 615, 0, 10823, + 897, 1, 0, 0, 0, 10824, 10825, 5, 1077, 0, 0, 10825, 10826, 5, 359, 0, + 0, 10826, 10827, 5, 1188, 0, 0, 10827, 10829, 5, 1182, 0, 0, 10828, 10824, + 1, 0, 0, 0, 10828, 10829, 1, 0, 0, 0, 10829, 10831, 1, 0, 0, 0, 10830, + 10832, 3, 908, 454, 0, 10831, 10830, 1, 0, 0, 0, 10831, 10832, 1, 0, 0, + 0, 10832, 10834, 1, 0, 0, 0, 10833, 10835, 3, 892, 446, 0, 10834, 10833, + 1, 0, 0, 0, 10834, 10835, 1, 0, 0, 0, 10835, 899, 1, 0, 0, 0, 10836, 10837, + 5, 786, 0, 0, 10837, 10838, 3, 1170, 585, 0, 10838, 10839, 5, 1206, 0, + 0, 10839, 10840, 3, 1192, 596, 0, 10840, 10845, 5, 1207, 0, 0, 10841, 10844, + 3, 904, 452, 0, 10842, 10844, 3, 906, 453, 0, 10843, 10841, 1, 0, 0, 0, + 10843, 10842, 1, 0, 0, 0, 10844, 10847, 1, 0, 0, 0, 10845, 10843, 1, 0, + 0, 0, 10845, 10846, 1, 0, 0, 0, 10846, 10851, 1, 0, 0, 0, 10847, 10845, + 1, 0, 0, 0, 10848, 10849, 5, 627, 0, 0, 10849, 10850, 5, 365, 0, 0, 10850, + 10852, 5, 804, 0, 0, 10851, 10848, 1, 0, 0, 0, 10851, 10852, 1, 0, 0, 0, + 10852, 901, 1, 0, 0, 0, 10853, 10857, 5, 133, 0, 0, 10854, 10855, 5, 627, + 0, 0, 10855, 10856, 5, 365, 0, 0, 10856, 10858, 5, 804, 0, 0, 10857, 10854, + 1, 0, 0, 0, 10857, 10858, 1, 0, 0, 0, 10858, 10859, 1, 0, 0, 0, 10859, + 10860, 5, 1206, 0, 0, 10860, 10861, 3, 950, 475, 0, 10861, 10862, 5, 1207, + 0, 0, 10862, 903, 1, 0, 0, 0, 10863, 10864, 5, 662, 0, 0, 10864, 10872, + 5, 254, 0, 0, 10865, 10866, 5, 609, 0, 0, 10866, 10873, 5, 8, 0, 0, 10867, + 10873, 5, 116, 0, 0, 10868, 10869, 5, 900, 0, 0, 10869, 10873, 5, 643, + 0, 0, 10870, 10871, 5, 900, 0, 0, 10871, 10873, 5, 245, 0, 0, 10872, 10865, + 1, 0, 0, 0, 10872, 10867, 1, 0, 0, 0, 10872, 10868, 1, 0, 0, 0, 10872, + 10870, 1, 0, 0, 0, 10873, 905, 1, 0, 0, 0, 10874, 10875, 5, 662, 0, 0, + 10875, 10883, 5, 1042, 0, 0, 10876, 10877, 5, 609, 0, 0, 10877, 10884, + 5, 8, 0, 0, 10878, 10884, 5, 116, 0, 0, 10879, 10880, 5, 900, 0, 0, 10880, + 10884, 5, 643, 0, 0, 10881, 10882, 5, 900, 0, 0, 10882, 10884, 5, 245, + 0, 0, 10883, 10876, 1, 0, 0, 0, 10883, 10878, 1, 0, 0, 0, 10883, 10879, + 1, 0, 0, 0, 10883, 10881, 1, 0, 0, 0, 10884, 907, 1, 0, 0, 0, 10885, 10886, + 5, 1077, 0, 0, 10886, 10887, 5, 1206, 0, 0, 10887, 10892, 3, 910, 455, + 0, 10888, 10889, 5, 1208, 0, 0, 10889, 10891, 3, 910, 455, 0, 10890, 10888, + 1, 0, 0, 0, 10891, 10894, 1, 0, 0, 0, 10892, 10890, 1, 0, 0, 0, 10892, + 10893, 1, 0, 0, 0, 10893, 10895, 1, 0, 0, 0, 10894, 10892, 1, 0, 0, 0, + 10895, 10896, 5, 1207, 0, 0, 10896, 909, 1, 0, 0, 0, 10897, 10898, 5, 689, + 0, 0, 10898, 10899, 5, 1188, 0, 0, 10899, 10984, 3, 1196, 598, 0, 10900, + 10901, 5, 359, 0, 0, 10901, 10902, 5, 1188, 0, 0, 10902, 10984, 5, 1182, + 0, 0, 10903, 10904, 5, 442, 0, 0, 10904, 10905, 5, 1188, 0, 0, 10905, 10984, + 3, 1196, 598, 0, 10906, 10907, 5, 947, 0, 0, 10907, 10908, 5, 1188, 0, + 0, 10908, 10984, 3, 1196, 598, 0, 10909, 10910, 5, 28, 0, 0, 10910, 10911, + 5, 1188, 0, 0, 10911, 10984, 3, 1196, 598, 0, 10912, 10913, 5, 27, 0, 0, + 10913, 10914, 5, 1188, 0, 0, 10914, 10984, 3, 1196, 598, 0, 10915, 10916, + 5, 676, 0, 0, 10916, 10917, 5, 1188, 0, 0, 10917, 10984, 3, 1196, 598, + 0, 10918, 10919, 5, 924, 0, 0, 10919, 10920, 5, 1188, 0, 0, 10920, 10984, + 3, 1196, 598, 0, 10921, 10922, 5, 551, 0, 0, 10922, 10923, 5, 1188, 0, + 0, 10923, 10984, 5, 1182, 0, 0, 10924, 10925, 5, 225, 0, 0, 10925, 10926, + 5, 1188, 0, 0, 10926, 10928, 7, 65, 0, 0, 10927, 10929, 3, 542, 271, 0, + 10928, 10927, 1, 0, 0, 0, 10928, 10929, 1, 0, 0, 0, 10929, 10984, 1, 0, + 0, 0, 10930, 10931, 5, 1092, 0, 0, 10931, 10932, 5, 1188, 0, 0, 10932, + 10934, 3, 1196, 598, 0, 10933, 10935, 3, 542, 271, 0, 10934, 10933, 1, + 0, 0, 0, 10934, 10935, 1, 0, 0, 0, 10935, 10984, 1, 0, 0, 0, 10936, 10937, + 5, 276, 0, 0, 10937, 10938, 5, 1188, 0, 0, 10938, 10939, 5, 417, 0, 0, + 10939, 10940, 5, 1206, 0, 0, 10940, 10941, 3, 1230, 615, 0, 10941, 10942, + 5, 1207, 0, 0, 10942, 10984, 1, 0, 0, 0, 10943, 10944, 5, 151, 0, 0, 10944, + 10945, 5, 456, 0, 0, 10945, 10946, 5, 1206, 0, 0, 10946, 10948, 3, 1230, + 615, 0, 10947, 10949, 7, 74, 0, 0, 10948, 10947, 1, 0, 0, 0, 10948, 10949, + 1, 0, 0, 0, 10949, 10957, 1, 0, 0, 0, 10950, 10951, 5, 1208, 0, 0, 10951, + 10953, 3, 1230, 615, 0, 10952, 10954, 7, 74, 0, 0, 10953, 10952, 1, 0, + 0, 0, 10953, 10954, 1, 0, 0, 0, 10954, 10956, 1, 0, 0, 0, 10955, 10950, + 1, 0, 0, 0, 10956, 10959, 1, 0, 0, 0, 10957, 10955, 1, 0, 0, 0, 10957, + 10958, 1, 0, 0, 0, 10958, 10960, 1, 0, 0, 0, 10959, 10957, 1, 0, 0, 0, + 10960, 10961, 5, 1207, 0, 0, 10961, 10984, 1, 0, 0, 0, 10962, 10963, 5, + 663, 0, 0, 10963, 10972, 5, 1188, 0, 0, 10964, 10969, 5, 662, 0, 0, 10965, + 10966, 5, 1206, 0, 0, 10966, 10967, 3, 618, 309, 0, 10967, 10968, 5, 1207, + 0, 0, 10968, 10970, 1, 0, 0, 0, 10969, 10965, 1, 0, 0, 0, 10969, 10970, + 1, 0, 0, 0, 10970, 10973, 1, 0, 0, 0, 10971, 10973, 5, 656, 0, 0, 10972, + 10964, 1, 0, 0, 0, 10972, 10971, 1, 0, 0, 0, 10973, 10984, 1, 0, 0, 0, + 10974, 10975, 5, 820, 0, 0, 10975, 10976, 5, 1188, 0, 0, 10976, 10984, + 3, 1196, 598, 0, 10977, 10978, 5, 559, 0, 0, 10978, 10979, 5, 1188, 0, + 0, 10979, 10981, 5, 1182, 0, 0, 10980, 10982, 5, 582, 0, 0, 10981, 10980, + 1, 0, 0, 0, 10981, 10982, 1, 0, 0, 0, 10982, 10984, 1, 0, 0, 0, 10983, + 10897, 1, 0, 0, 0, 10983, 10900, 1, 0, 0, 0, 10983, 10903, 1, 0, 0, 0, + 10983, 10906, 1, 0, 0, 0, 10983, 10909, 1, 0, 0, 0, 10983, 10912, 1, 0, + 0, 0, 10983, 10915, 1, 0, 0, 0, 10983, 10918, 1, 0, 0, 0, 10983, 10921, + 1, 0, 0, 0, 10983, 10924, 1, 0, 0, 0, 10983, 10930, 1, 0, 0, 0, 10983, + 10936, 1, 0, 0, 0, 10983, 10943, 1, 0, 0, 0, 10983, 10962, 1, 0, 0, 0, + 10983, 10974, 1, 0, 0, 0, 10983, 10977, 1, 0, 0, 0, 10984, 911, 1, 0, 0, + 0, 10985, 10986, 5, 242, 0, 0, 10986, 11018, 3, 1194, 597, 0, 10987, 10997, + 5, 213, 0, 0, 10988, 10995, 3, 914, 457, 0, 10989, 10990, 5, 365, 0, 0, + 10990, 10993, 5, 1042, 0, 0, 10991, 10992, 5, 655, 0, 0, 10992, 10994, + 3, 1192, 596, 0, 10993, 10991, 1, 0, 0, 0, 10993, 10994, 1, 0, 0, 0, 10994, + 10996, 1, 0, 0, 0, 10995, 10989, 1, 0, 0, 0, 10995, 10996, 1, 0, 0, 0, + 10996, 10998, 1, 0, 0, 0, 10997, 10988, 1, 0, 0, 0, 10997, 10998, 1, 0, + 0, 0, 10998, 11019, 1, 0, 0, 0, 10999, 11001, 7, 127, 0, 0, 11000, 10999, + 1, 0, 0, 0, 11000, 11001, 1, 0, 0, 0, 11001, 11003, 1, 0, 0, 0, 11002, + 11004, 5, 865, 0, 0, 11003, 11002, 1, 0, 0, 0, 11003, 11004, 1, 0, 0, 0, + 11004, 11005, 1, 0, 0, 0, 11005, 11006, 5, 213, 0, 0, 11006, 11007, 5, + 365, 0, 0, 11007, 11016, 3, 482, 241, 0, 11008, 11014, 5, 365, 0, 0, 11009, + 11010, 5, 767, 0, 0, 11010, 11015, 5, 664, 0, 0, 11011, 11015, 5, 1042, + 0, 0, 11012, 11013, 5, 655, 0, 0, 11013, 11015, 3, 1192, 596, 0, 11014, + 11009, 1, 0, 0, 0, 11014, 11011, 1, 0, 0, 0, 11014, 11012, 1, 0, 0, 0, + 11015, 11017, 1, 0, 0, 0, 11016, 11008, 1, 0, 0, 0, 11016, 11017, 1, 0, + 0, 0, 11017, 11019, 1, 0, 0, 0, 11018, 10987, 1, 0, 0, 0, 11018, 11000, + 1, 0, 0, 0, 11019, 11021, 1, 0, 0, 0, 11020, 11022, 5, 1209, 0, 0, 11021, + 11020, 1, 0, 0, 0, 11021, 11022, 1, 0, 0, 0, 11022, 913, 1, 0, 0, 0, 11023, + 11025, 3, 916, 458, 0, 11024, 11023, 1, 0, 0, 0, 11025, 11028, 1, 0, 0, + 0, 11026, 11024, 1, 0, 0, 0, 11026, 11027, 1, 0, 0, 0, 11027, 11029, 1, + 0, 0, 0, 11028, 11026, 1, 0, 0, 0, 11029, 11030, 5, 365, 0, 0, 11030, 11031, + 3, 482, 241, 0, 11031, 915, 1, 0, 0, 0, 11032, 11038, 7, 82, 0, 0, 11033, + 11038, 7, 128, 0, 0, 11034, 11038, 7, 129, 0, 0, 11035, 11038, 7, 130, + 0, 0, 11036, 11038, 5, 1028, 0, 0, 11037, 11032, 1, 0, 0, 0, 11037, 11033, + 1, 0, 0, 0, 11037, 11034, 1, 0, 0, 0, 11037, 11035, 1, 0, 0, 0, 11037, + 11036, 1, 0, 0, 0, 11038, 917, 1, 0, 0, 0, 11039, 11049, 5, 342, 0, 0, + 11040, 11047, 5, 608, 0, 0, 11041, 11047, 5, 733, 0, 0, 11042, 11047, 5, + 361, 0, 0, 11043, 11047, 5, 507, 0, 0, 11044, 11045, 7, 131, 0, 0, 11045, + 11047, 3, 926, 463, 0, 11046, 11040, 1, 0, 0, 0, 11046, 11041, 1, 0, 0, + 0, 11046, 11042, 1, 0, 0, 0, 11046, 11043, 1, 0, 0, 0, 11046, 11044, 1, + 0, 0, 0, 11046, 11047, 1, 0, 0, 0, 11047, 11048, 1, 0, 0, 0, 11048, 11050, + 5, 380, 0, 0, 11049, 11046, 1, 0, 0, 0, 11049, 11050, 1, 0, 0, 0, 11050, + 11052, 1, 0, 0, 0, 11051, 11053, 5, 406, 0, 0, 11052, 11051, 1, 0, 0, 0, + 11052, 11053, 1, 0, 0, 0, 11053, 11054, 1, 0, 0, 0, 11054, 11064, 3, 1194, + 597, 0, 11055, 11056, 5, 471, 0, 0, 11056, 11061, 5, 1180, 0, 0, 11057, + 11058, 5, 1208, 0, 0, 11058, 11060, 5, 1180, 0, 0, 11059, 11057, 1, 0, + 0, 0, 11060, 11063, 1, 0, 0, 0, 11061, 11059, 1, 0, 0, 0, 11061, 11062, + 1, 0, 0, 0, 11062, 11065, 1, 0, 0, 0, 11063, 11061, 1, 0, 0, 0, 11064, + 11055, 1, 0, 0, 0, 11064, 11065, 1, 0, 0, 0, 11065, 11067, 1, 0, 0, 0, + 11066, 11068, 5, 1209, 0, 0, 11067, 11066, 1, 0, 0, 0, 11067, 11068, 1, + 0, 0, 0, 11068, 919, 1, 0, 0, 0, 11069, 11070, 5, 900, 0, 0, 11070, 11074, + 3, 1230, 615, 0, 11071, 11075, 3, 1230, 615, 0, 11072, 11075, 3, 924, 462, + 0, 11073, 11075, 3, 1196, 598, 0, 11074, 11071, 1, 0, 0, 0, 11074, 11072, + 1, 0, 0, 0, 11074, 11073, 1, 0, 0, 0, 11075, 11077, 1, 0, 0, 0, 11076, + 11078, 5, 1209, 0, 0, 11077, 11076, 1, 0, 0, 0, 11077, 11078, 1, 0, 0, + 0, 11078, 11137, 1, 0, 0, 0, 11079, 11080, 5, 900, 0, 0, 11080, 11081, + 5, 945, 0, 0, 11081, 11082, 7, 132, 0, 0, 11082, 11084, 3, 1196, 598, 0, + 11083, 11085, 5, 1209, 0, 0, 11084, 11083, 1, 0, 0, 0, 11084, 11085, 1, + 0, 0, 0, 11085, 11137, 1, 0, 0, 0, 11086, 11087, 5, 900, 0, 0, 11087, 11088, + 5, 838, 0, 0, 11088, 11090, 7, 0, 0, 0, 11089, 11091, 5, 1209, 0, 0, 11090, + 11089, 1, 0, 0, 0, 11090, 11091, 1, 0, 0, 0, 11091, 11137, 1, 0, 0, 0, + 11092, 11093, 5, 900, 0, 0, 11093, 11094, 5, 992, 0, 0, 11094, 11096, 5, + 1182, 0, 0, 11095, 11097, 5, 1209, 0, 0, 11096, 11095, 1, 0, 0, 0, 11096, + 11097, 1, 0, 0, 0, 11097, 11137, 1, 0, 0, 0, 11098, 11099, 5, 900, 0, 0, + 11099, 11100, 5, 1008, 0, 0, 11100, 11101, 5, 479, 0, 0, 11101, 11111, + 5, 513, 0, 0, 11102, 11103, 5, 767, 0, 0, 11103, 11112, 5, 1031, 0, 0, + 11104, 11105, 5, 767, 0, 0, 11105, 11112, 5, 165, 0, 0, 11106, 11107, 5, + 799, 0, 0, 11107, 11112, 5, 767, 0, 0, 11108, 11112, 5, 921, 0, 0, 11109, + 11112, 5, 888, 0, 0, 11110, 11112, 5, 1182, 0, 0, 11111, 11102, 1, 0, 0, + 0, 11111, 11104, 1, 0, 0, 0, 11111, 11106, 1, 0, 0, 0, 11111, 11108, 1, + 0, 0, 0, 11111, 11109, 1, 0, 0, 0, 11111, 11110, 1, 0, 0, 0, 11112, 11114, + 1, 0, 0, 0, 11113, 11115, 5, 1209, 0, 0, 11114, 11113, 1, 0, 0, 0, 11114, + 11115, 1, 0, 0, 0, 11115, 11137, 1, 0, 0, 0, 11116, 11117, 5, 900, 0, 0, + 11117, 11118, 5, 435, 0, 0, 11118, 11119, 3, 1170, 585, 0, 11119, 11121, + 3, 1196, 598, 0, 11120, 11122, 5, 1209, 0, 0, 11121, 11120, 1, 0, 0, 0, + 11121, 11122, 1, 0, 0, 0, 11122, 11137, 1, 0, 0, 0, 11123, 11124, 5, 900, + 0, 0, 11124, 11129, 3, 922, 461, 0, 11125, 11126, 5, 1208, 0, 0, 11126, + 11128, 3, 922, 461, 0, 11127, 11125, 1, 0, 0, 0, 11128, 11131, 1, 0, 0, + 0, 11129, 11127, 1, 0, 0, 0, 11129, 11130, 1, 0, 0, 0, 11130, 11132, 1, + 0, 0, 0, 11131, 11129, 1, 0, 0, 0, 11132, 11133, 3, 1196, 598, 0, 11133, + 11137, 1, 0, 0, 0, 11134, 11135, 5, 900, 0, 0, 11135, 11137, 3, 1088, 544, + 0, 11136, 11069, 1, 0, 0, 0, 11136, 11079, 1, 0, 0, 0, 11136, 11086, 1, + 0, 0, 0, 11136, 11092, 1, 0, 0, 0, 11136, 11098, 1, 0, 0, 0, 11136, 11116, + 1, 0, 0, 0, 11136, 11123, 1, 0, 0, 0, 11136, 11134, 1, 0, 0, 0, 11137, + 921, 1, 0, 0, 0, 11138, 11139, 7, 133, 0, 0, 11139, 923, 1, 0, 0, 0, 11140, + 11143, 3, 1224, 612, 0, 11141, 11143, 5, 1180, 0, 0, 11142, 11140, 1, 0, + 0, 0, 11142, 11141, 1, 0, 0, 0, 11143, 925, 1, 0, 0, 0, 11144, 11145, 6, + 463, -1, 0, 11145, 11154, 3, 932, 466, 0, 11146, 11154, 3, 1182, 591, 0, + 11147, 11154, 3, 1052, 526, 0, 11148, 11154, 3, 934, 467, 0, 11149, 11154, + 3, 938, 469, 0, 11150, 11154, 3, 936, 468, 0, 11151, 11154, 3, 1136, 568, + 0, 11152, 11154, 5, 1169, 0, 0, 11153, 11144, 1, 0, 0, 0, 11153, 11146, + 1, 0, 0, 0, 11153, 11147, 1, 0, 0, 0, 11153, 11148, 1, 0, 0, 0, 11153, + 11149, 1, 0, 0, 0, 11153, 11150, 1, 0, 0, 0, 11153, 11151, 1, 0, 0, 0, + 11153, 11152, 1, 0, 0, 0, 11154, 11179, 1, 0, 0, 0, 11155, 11156, 10, 5, + 0, 0, 11156, 11157, 7, 134, 0, 0, 11157, 11178, 3, 926, 463, 6, 11158, + 11159, 10, 4, 0, 0, 11159, 11160, 7, 135, 0, 0, 11160, 11178, 3, 926, 463, + 5, 11161, 11162, 10, 11, 0, 0, 11162, 11167, 5, 1201, 0, 0, 11163, 11168, + 3, 1078, 539, 0, 11164, 11168, 3, 1082, 541, 0, 11165, 11168, 3, 1086, + 543, 0, 11166, 11168, 3, 1090, 545, 0, 11167, 11163, 1, 0, 0, 0, 11167, + 11164, 1, 0, 0, 0, 11167, 11165, 1, 0, 0, 0, 11167, 11166, 1, 0, 0, 0, + 11168, 11178, 1, 0, 0, 0, 11169, 11170, 10, 10, 0, 0, 11170, 11171, 5, + 1201, 0, 0, 11171, 11178, 3, 1092, 546, 0, 11172, 11173, 10, 9, 0, 0, 11173, + 11174, 5, 153, 0, 0, 11174, 11178, 3, 1230, 615, 0, 11175, 11176, 10, 3, + 0, 0, 11176, 11178, 3, 930, 465, 0, 11177, 11155, 1, 0, 0, 0, 11177, 11158, + 1, 0, 0, 0, 11177, 11161, 1, 0, 0, 0, 11177, 11169, 1, 0, 0, 0, 11177, + 11172, 1, 0, 0, 0, 11177, 11175, 1, 0, 0, 0, 11178, 11181, 1, 0, 0, 0, + 11179, 11177, 1, 0, 0, 0, 11179, 11180, 1, 0, 0, 0, 11180, 927, 1, 0, 0, + 0, 11181, 11179, 1, 0, 0, 0, 11182, 11183, 5, 1221, 0, 0, 11183, 929, 1, + 0, 0, 0, 11184, 11185, 5, 63, 0, 0, 11185, 11186, 5, 996, 0, 0, 11186, + 11187, 5, 1094, 0, 0, 11187, 11188, 3, 926, 463, 0, 11188, 931, 1, 0, 0, + 0, 11189, 11194, 5, 245, 0, 0, 11190, 11194, 5, 643, 0, 0, 11191, 11194, + 5, 1180, 0, 0, 11192, 11194, 3, 1226, 613, 0, 11193, 11189, 1, 0, 0, 0, + 11193, 11190, 1, 0, 0, 0, 11193, 11191, 1, 0, 0, 0, 11193, 11192, 1, 0, + 0, 0, 11194, 933, 1, 0, 0, 0, 11195, 11196, 5, 117, 0, 0, 11196, 11198, + 3, 926, 463, 0, 11197, 11199, 3, 1098, 549, 0, 11198, 11197, 1, 0, 0, 0, + 11199, 11200, 1, 0, 0, 0, 11200, 11198, 1, 0, 0, 0, 11200, 11201, 1, 0, + 0, 0, 11201, 11204, 1, 0, 0, 0, 11202, 11203, 5, 289, 0, 0, 11203, 11205, + 3, 926, 463, 0, 11204, 11202, 1, 0, 0, 0, 11204, 11205, 1, 0, 0, 0, 11205, + 11206, 1, 0, 0, 0, 11206, 11207, 5, 299, 0, 0, 11207, 11221, 1, 0, 0, 0, + 11208, 11210, 5, 117, 0, 0, 11209, 11211, 3, 1100, 550, 0, 11210, 11209, + 1, 0, 0, 0, 11211, 11212, 1, 0, 0, 0, 11212, 11210, 1, 0, 0, 0, 11212, + 11213, 1, 0, 0, 0, 11213, 11216, 1, 0, 0, 0, 11214, 11215, 5, 289, 0, 0, + 11215, 11217, 3, 926, 463, 0, 11216, 11214, 1, 0, 0, 0, 11216, 11217, 1, + 0, 0, 0, 11217, 11218, 1, 0, 0, 0, 11218, 11219, 5, 299, 0, 0, 11219, 11221, + 1, 0, 0, 0, 11220, 11195, 1, 0, 0, 0, 11220, 11208, 1, 0, 0, 0, 11221, + 935, 1, 0, 0, 0, 11222, 11223, 5, 1217, 0, 0, 11223, 11227, 3, 926, 463, + 0, 11224, 11225, 7, 136, 0, 0, 11225, 11227, 3, 926, 463, 0, 11226, 11222, + 1, 0, 0, 0, 11226, 11224, 1, 0, 0, 0, 11227, 937, 1, 0, 0, 0, 11228, 11229, + 5, 1206, 0, 0, 11229, 11230, 3, 926, 463, 0, 11230, 11231, 5, 1207, 0, + 0, 11231, 11237, 1, 0, 0, 0, 11232, 11233, 5, 1206, 0, 0, 11233, 11234, + 3, 940, 470, 0, 11234, 11235, 5, 1207, 0, 0, 11235, 11237, 1, 0, 0, 0, + 11236, 11228, 1, 0, 0, 0, 11236, 11232, 1, 0, 0, 0, 11237, 939, 1, 0, 0, + 0, 11238, 11239, 3, 484, 242, 0, 11239, 941, 1, 0, 0, 0, 11240, 11241, + 5, 1077, 0, 0, 11241, 11246, 3, 944, 472, 0, 11242, 11243, 5, 1208, 0, + 0, 11243, 11245, 3, 944, 472, 0, 11244, 11242, 1, 0, 0, 0, 11245, 11248, + 1, 0, 0, 0, 11246, 11244, 1, 0, 0, 0, 11246, 11247, 1, 0, 0, 0, 11247, + 943, 1, 0, 0, 0, 11248, 11246, 1, 0, 0, 0, 11249, 11254, 3, 1230, 615, + 0, 11250, 11251, 5, 1206, 0, 0, 11251, 11252, 3, 1192, 596, 0, 11252, 11253, + 5, 1207, 0, 0, 11253, 11255, 1, 0, 0, 0, 11254, 11250, 1, 0, 0, 0, 11254, + 11255, 1, 0, 0, 0, 11255, 11256, 1, 0, 0, 0, 11256, 11257, 5, 56, 0, 0, + 11257, 11258, 5, 1206, 0, 0, 11258, 11259, 3, 484, 242, 0, 11259, 11260, + 5, 1207, 0, 0, 11260, 945, 1, 0, 0, 0, 11261, 11262, 5, 1180, 0, 0, 11262, + 11263, 5, 1188, 0, 0, 11263, 11266, 3, 1182, 591, 0, 11264, 11267, 5, 1188, + 0, 0, 11265, 11267, 3, 1238, 619, 0, 11266, 11264, 1, 0, 0, 0, 11266, 11265, + 1, 0, 0, 0, 11267, 11268, 1, 0, 0, 0, 11268, 11269, 3, 926, 463, 0, 11269, + 11287, 1, 0, 0, 0, 11270, 11273, 3, 1182, 591, 0, 11271, 11273, 5, 1180, + 0, 0, 11272, 11270, 1, 0, 0, 0, 11272, 11271, 1, 0, 0, 0, 11273, 11276, + 1, 0, 0, 0, 11274, 11277, 5, 1188, 0, 0, 11275, 11277, 3, 1238, 619, 0, + 11276, 11274, 1, 0, 0, 0, 11276, 11275, 1, 0, 0, 0, 11277, 11278, 1, 0, + 0, 0, 11278, 11287, 3, 926, 463, 0, 11279, 11280, 3, 1230, 615, 0, 11280, + 11281, 5, 1201, 0, 0, 11281, 11282, 3, 1230, 615, 0, 11282, 11283, 5, 1206, + 0, 0, 11283, 11284, 3, 1126, 563, 0, 11284, 11285, 5, 1207, 0, 0, 11285, + 11287, 1, 0, 0, 0, 11286, 11261, 1, 0, 0, 0, 11286, 11272, 1, 0, 0, 0, + 11286, 11279, 1, 0, 0, 0, 11287, 947, 1, 0, 0, 0, 11288, 11291, 3, 1182, + 591, 0, 11289, 11291, 5, 1180, 0, 0, 11290, 11288, 1, 0, 0, 0, 11290, 11289, + 1, 0, 0, 0, 11291, 11294, 1, 0, 0, 0, 11292, 11295, 5, 1188, 0, 0, 11293, + 11295, 3, 1238, 619, 0, 11294, 11292, 1, 0, 0, 0, 11294, 11293, 1, 0, 0, + 0, 11295, 11296, 1, 0, 0, 0, 11296, 11305, 3, 926, 463, 0, 11297, 11298, + 3, 1230, 615, 0, 11298, 11299, 5, 1201, 0, 0, 11299, 11300, 3, 1230, 615, + 0, 11300, 11301, 5, 1206, 0, 0, 11301, 11302, 3, 1126, 563, 0, 11302, 11303, + 5, 1207, 0, 0, 11303, 11305, 1, 0, 0, 0, 11304, 11290, 1, 0, 0, 0, 11304, + 11297, 1, 0, 0, 0, 11305, 949, 1, 0, 0, 0, 11306, 11310, 6, 475, -1, 0, + 11307, 11309, 5, 627, 0, 0, 11308, 11307, 1, 0, 0, 0, 11309, 11312, 1, + 0, 0, 0, 11310, 11308, 1, 0, 0, 0, 11310, 11311, 1, 0, 0, 0, 11311, 11318, + 1, 0, 0, 0, 11312, 11310, 1, 0, 0, 0, 11313, 11319, 3, 952, 476, 0, 11314, + 11315, 5, 1206, 0, 0, 11315, 11316, 3, 950, 475, 0, 11316, 11317, 5, 1207, + 0, 0, 11317, 11319, 1, 0, 0, 0, 11318, 11313, 1, 0, 0, 0, 11318, 11314, + 1, 0, 0, 0, 11319, 11328, 1, 0, 0, 0, 11320, 11321, 10, 2, 0, 0, 11321, + 11322, 5, 37, 0, 0, 11322, 11327, 3, 950, 475, 3, 11323, 11324, 10, 1, + 0, 0, 11324, 11325, 5, 678, 0, 0, 11325, 11327, 3, 950, 475, 2, 11326, + 11320, 1, 0, 0, 0, 11326, 11323, 1, 0, 0, 0, 11327, 11330, 1, 0, 0, 0, + 11328, 11326, 1, 0, 0, 0, 11328, 11329, 1, 0, 0, 0, 11329, 951, 1, 0, 0, + 0, 11330, 11328, 1, 0, 0, 0, 11331, 11332, 5, 322, 0, 0, 11332, 11333, + 5, 1206, 0, 0, 11333, 11334, 3, 940, 470, 0, 11334, 11335, 5, 1207, 0, + 0, 11335, 11397, 1, 0, 0, 0, 11336, 11397, 3, 1058, 529, 0, 11337, 11338, + 3, 926, 463, 0, 11338, 11339, 3, 1236, 618, 0, 11339, 11340, 3, 926, 463, + 0, 11340, 11397, 1, 0, 0, 0, 11341, 11342, 3, 926, 463, 0, 11342, 11343, + 5, 1194, 0, 0, 11343, 11344, 3, 926, 463, 0, 11344, 11397, 1, 0, 0, 0, + 11345, 11346, 3, 926, 463, 0, 11346, 11347, 3, 1236, 618, 0, 11347, 11348, + 7, 137, 0, 0, 11348, 11349, 5, 1206, 0, 0, 11349, 11350, 3, 940, 470, 0, + 11350, 11351, 5, 1207, 0, 0, 11351, 11397, 1, 0, 0, 0, 11352, 11356, 3, + 926, 463, 0, 11353, 11355, 5, 627, 0, 0, 11354, 11353, 1, 0, 0, 0, 11355, + 11358, 1, 0, 0, 0, 11356, 11354, 1, 0, 0, 0, 11356, 11357, 1, 0, 0, 0, + 11357, 11359, 1, 0, 0, 0, 11358, 11356, 1, 0, 0, 0, 11359, 11360, 5, 92, + 0, 0, 11360, 11361, 3, 926, 463, 0, 11361, 11362, 5, 37, 0, 0, 11362, 11363, + 3, 926, 463, 0, 11363, 11397, 1, 0, 0, 0, 11364, 11368, 3, 926, 463, 0, + 11365, 11367, 5, 627, 0, 0, 11366, 11365, 1, 0, 0, 0, 11367, 11370, 1, + 0, 0, 0, 11368, 11366, 1, 0, 0, 0, 11368, 11369, 1, 0, 0, 0, 11369, 11371, + 1, 0, 0, 0, 11370, 11368, 1, 0, 0, 0, 11371, 11372, 5, 451, 0, 0, 11372, + 11375, 5, 1206, 0, 0, 11373, 11376, 3, 940, 470, 0, 11374, 11376, 3, 1126, + 563, 0, 11375, 11373, 1, 0, 0, 0, 11375, 11374, 1, 0, 0, 0, 11376, 11377, + 1, 0, 0, 0, 11377, 11378, 5, 1207, 0, 0, 11378, 11397, 1, 0, 0, 0, 11379, + 11383, 3, 926, 463, 0, 11380, 11382, 5, 627, 0, 0, 11381, 11380, 1, 0, + 0, 0, 11382, 11385, 1, 0, 0, 0, 11383, 11381, 1, 0, 0, 0, 11383, 11384, + 1, 0, 0, 0, 11384, 11386, 1, 0, 0, 0, 11385, 11383, 1, 0, 0, 0, 11386, + 11387, 5, 520, 0, 0, 11387, 11390, 3, 926, 463, 0, 11388, 11389, 5, 311, + 0, 0, 11389, 11391, 3, 926, 463, 0, 11390, 11388, 1, 0, 0, 0, 11390, 11391, + 1, 0, 0, 0, 11391, 11397, 1, 0, 0, 0, 11392, 11393, 3, 926, 463, 0, 11393, + 11394, 5, 474, 0, 0, 11394, 11395, 3, 1200, 600, 0, 11395, 11397, 1, 0, + 0, 0, 11396, 11331, 1, 0, 0, 0, 11396, 11336, 1, 0, 0, 0, 11396, 11337, + 1, 0, 0, 0, 11396, 11341, 1, 0, 0, 0, 11396, 11345, 1, 0, 0, 0, 11396, + 11352, 1, 0, 0, 0, 11396, 11364, 1, 0, 0, 0, 11396, 11379, 1, 0, 0, 0, + 11396, 11392, 1, 0, 0, 0, 11397, 953, 1, 0, 0, 0, 11398, 11400, 3, 958, + 479, 0, 11399, 11401, 3, 974, 487, 0, 11400, 11399, 1, 0, 0, 0, 11400, + 11401, 1, 0, 0, 0, 11401, 11405, 1, 0, 0, 0, 11402, 11404, 3, 956, 478, + 0, 11403, 11402, 1, 0, 0, 0, 11404, 11407, 1, 0, 0, 0, 11405, 11403, 1, + 0, 0, 0, 11405, 11406, 1, 0, 0, 0, 11406, 11419, 1, 0, 0, 0, 11407, 11405, + 1, 0, 0, 0, 11408, 11409, 5, 1206, 0, 0, 11409, 11410, 3, 954, 477, 0, + 11410, 11416, 5, 1207, 0, 0, 11411, 11413, 5, 1033, 0, 0, 11412, 11414, + 5, 22, 0, 0, 11413, 11412, 1, 0, 0, 0, 11413, 11414, 1, 0, 0, 0, 11414, + 11415, 1, 0, 0, 0, 11415, 11417, 3, 954, 477, 0, 11416, 11411, 1, 0, 0, + 0, 11416, 11417, 1, 0, 0, 0, 11417, 11419, 1, 0, 0, 0, 11418, 11398, 1, + 0, 0, 0, 11418, 11408, 1, 0, 0, 0, 11419, 955, 1, 0, 0, 0, 11420, 11422, + 5, 1033, 0, 0, 11421, 11423, 5, 22, 0, 0, 11422, 11421, 1, 0, 0, 0, 11422, + 11423, 1, 0, 0, 0, 11423, 11427, 1, 0, 0, 0, 11424, 11427, 5, 316, 0, 0, + 11425, 11427, 5, 470, 0, 0, 11426, 11420, 1, 0, 0, 0, 11426, 11424, 1, + 0, 0, 0, 11426, 11425, 1, 0, 0, 0, 11427, 11433, 1, 0, 0, 0, 11428, 11434, + 3, 958, 479, 0, 11429, 11430, 5, 1206, 0, 0, 11430, 11431, 3, 954, 477, + 0, 11431, 11432, 5, 1207, 0, 0, 11432, 11434, 1, 0, 0, 0, 11433, 11428, + 1, 0, 0, 0, 11433, 11429, 1, 0, 0, 0, 11434, 957, 1, 0, 0, 0, 11435, 11437, + 5, 878, 0, 0, 11436, 11438, 7, 138, 0, 0, 11437, 11436, 1, 0, 0, 0, 11437, + 11438, 1, 0, 0, 0, 11438, 11440, 1, 0, 0, 0, 11439, 11441, 3, 966, 483, + 0, 11440, 11439, 1, 0, 0, 0, 11440, 11441, 1, 0, 0, 0, 11441, 11442, 1, + 0, 0, 0, 11442, 11445, 3, 992, 496, 0, 11443, 11444, 5, 471, 0, 0, 11444, + 11446, 3, 1170, 585, 0, 11445, 11443, 1, 0, 0, 0, 11445, 11446, 1, 0, 0, + 0, 11446, 11448, 1, 0, 0, 0, 11447, 11449, 3, 964, 482, 0, 11448, 11447, + 1, 0, 0, 0, 11448, 11449, 1, 0, 0, 0, 11449, 11452, 1, 0, 0, 0, 11450, + 11451, 5, 1074, 0, 0, 11451, 11453, 3, 950, 475, 0, 11452, 11450, 1, 0, + 0, 0, 11452, 11453, 1, 0, 0, 0, 11453, 11455, 1, 0, 0, 0, 11454, 11456, + 3, 960, 480, 0, 11455, 11454, 1, 0, 0, 0, 11455, 11456, 1, 0, 0, 0, 11456, + 11458, 1, 0, 0, 0, 11457, 11459, 3, 962, 481, 0, 11458, 11457, 1, 0, 0, + 0, 11458, 11459, 1, 0, 0, 0, 11459, 959, 1, 0, 0, 0, 11460, 11461, 5, 412, + 0, 0, 11461, 11486, 5, 111, 0, 0, 11462, 11464, 5, 22, 0, 0, 11463, 11462, + 1, 0, 0, 0, 11463, 11464, 1, 0, 0, 0, 11464, 11465, 1, 0, 0, 0, 11465, + 11470, 3, 984, 492, 0, 11466, 11467, 5, 1208, 0, 0, 11467, 11469, 3, 984, + 492, 0, 11468, 11466, 1, 0, 0, 0, 11469, 11472, 1, 0, 0, 0, 11470, 11468, + 1, 0, 0, 0, 11470, 11471, 1, 0, 0, 0, 11471, 11487, 1, 0, 0, 0, 11472, + 11470, 1, 0, 0, 0, 11473, 11474, 5, 413, 0, 0, 11474, 11475, 5, 902, 0, + 0, 11475, 11476, 5, 1206, 0, 0, 11476, 11481, 3, 982, 491, 0, 11477, 11478, + 5, 1208, 0, 0, 11478, 11480, 3, 982, 491, 0, 11479, 11477, 1, 0, 0, 0, + 11480, 11483, 1, 0, 0, 0, 11481, 11479, 1, 0, 0, 0, 11481, 11482, 1, 0, + 0, 0, 11482, 11484, 1, 0, 0, 0, 11483, 11481, 1, 0, 0, 0, 11484, 11485, + 5, 1207, 0, 0, 11485, 11487, 1, 0, 0, 0, 11486, 11463, 1, 0, 0, 0, 11486, + 11473, 1, 0, 0, 0, 11487, 961, 1, 0, 0, 0, 11488, 11489, 5, 421, 0, 0, + 11489, 11490, 3, 950, 475, 0, 11490, 963, 1, 0, 0, 0, 11491, 11492, 5, + 380, 0, 0, 11492, 11493, 3, 1004, 502, 0, 11493, 965, 1, 0, 0, 0, 11494, + 11497, 5, 1001, 0, 0, 11495, 11498, 3, 968, 484, 0, 11496, 11498, 3, 970, + 485, 0, 11497, 11495, 1, 0, 0, 0, 11497, 11496, 1, 0, 0, 0, 11498, 11501, + 1, 0, 0, 0, 11499, 11500, 5, 1077, 0, 0, 11500, 11502, 5, 995, 0, 0, 11501, + 11499, 1, 0, 0, 0, 11501, 11502, 1, 0, 0, 0, 11502, 967, 1, 0, 0, 0, 11503, + 11504, 7, 64, 0, 0, 11504, 11511, 5, 708, 0, 0, 11505, 11506, 5, 1206, + 0, 0, 11506, 11507, 3, 926, 463, 0, 11507, 11508, 5, 1207, 0, 0, 11508, + 11509, 5, 708, 0, 0, 11509, 11511, 1, 0, 0, 0, 11510, 11503, 1, 0, 0, 0, + 11510, 11505, 1, 0, 0, 0, 11511, 969, 1, 0, 0, 0, 11512, 11518, 5, 1182, + 0, 0, 11513, 11514, 5, 1206, 0, 0, 11514, 11515, 3, 926, 463, 0, 11515, + 11516, 5, 1207, 0, 0, 11516, 11518, 1, 0, 0, 0, 11517, 11512, 1, 0, 0, + 0, 11517, 11513, 1, 0, 0, 0, 11518, 971, 1, 0, 0, 0, 11519, 11520, 5, 679, + 0, 0, 11520, 11521, 5, 111, 0, 0, 11521, 11526, 3, 980, 490, 0, 11522, + 11523, 5, 1208, 0, 0, 11523, 11525, 3, 980, 490, 0, 11524, 11522, 1, 0, + 0, 0, 11525, 11528, 1, 0, 0, 0, 11526, 11524, 1, 0, 0, 0, 11526, 11527, + 1, 0, 0, 0, 11527, 973, 1, 0, 0, 0, 11528, 11526, 1, 0, 0, 0, 11529, 11541, + 3, 972, 486, 0, 11530, 11531, 5, 658, 0, 0, 11531, 11532, 3, 926, 463, + 0, 11532, 11539, 7, 139, 0, 0, 11533, 11534, 5, 342, 0, 0, 11534, 11535, + 7, 140, 0, 0, 11535, 11536, 3, 926, 463, 0, 11536, 11537, 7, 139, 0, 0, + 11537, 11538, 5, 664, 0, 0, 11538, 11540, 1, 0, 0, 0, 11539, 11533, 1, + 0, 0, 0, 11539, 11540, 1, 0, 0, 0, 11540, 11542, 1, 0, 0, 0, 11541, 11530, + 1, 0, 0, 0, 11541, 11542, 1, 0, 0, 0, 11542, 975, 1, 0, 0, 0, 11543, 11544, + 5, 365, 0, 0, 11544, 11633, 5, 106, 0, 0, 11545, 11546, 5, 365, 0, 0, 11546, + 11554, 5, 1088, 0, 0, 11547, 11551, 5, 763, 0, 0, 11548, 11549, 5, 1206, + 0, 0, 11549, 11550, 5, 1184, 0, 0, 11550, 11552, 5, 1207, 0, 0, 11551, + 11548, 1, 0, 0, 0, 11551, 11552, 1, 0, 0, 0, 11552, 11555, 1, 0, 0, 0, + 11553, 11555, 5, 69, 0, 0, 11554, 11547, 1, 0, 0, 0, 11554, 11553, 1, 0, + 0, 0, 11555, 11559, 1, 0, 0, 0, 11556, 11558, 3, 978, 489, 0, 11557, 11556, + 1, 0, 0, 0, 11558, 11561, 1, 0, 0, 0, 11559, 11557, 1, 0, 0, 0, 11559, + 11560, 1, 0, 0, 0, 11560, 11572, 1, 0, 0, 0, 11561, 11559, 1, 0, 0, 0, + 11562, 11570, 5, 1208, 0, 0, 11563, 11571, 5, 1089, 0, 0, 11564, 11568, + 5, 1091, 0, 0, 11565, 11566, 5, 1206, 0, 0, 11566, 11567, 5, 1184, 0, 0, + 11567, 11569, 5, 1207, 0, 0, 11568, 11565, 1, 0, 0, 0, 11568, 11569, 1, + 0, 0, 0, 11569, 11571, 1, 0, 0, 0, 11570, 11563, 1, 0, 0, 0, 11570, 11564, + 1, 0, 0, 0, 11571, 11573, 1, 0, 0, 0, 11572, 11562, 1, 0, 0, 0, 11572, + 11573, 1, 0, 0, 0, 11573, 11579, 1, 0, 0, 0, 11574, 11575, 5, 1208, 0, + 0, 11575, 11577, 5, 288, 0, 0, 11576, 11578, 7, 141, 0, 0, 11577, 11576, + 1, 0, 0, 0, 11577, 11578, 1, 0, 0, 0, 11578, 11580, 1, 0, 0, 0, 11579, + 11574, 1, 0, 0, 0, 11579, 11580, 1, 0, 0, 0, 11580, 11633, 1, 0, 0, 0, + 11581, 11582, 5, 365, 0, 0, 11582, 11583, 5, 1088, 0, 0, 11583, 11587, + 5, 328, 0, 0, 11584, 11586, 3, 978, 489, 0, 11585, 11584, 1, 0, 0, 0, 11586, + 11589, 1, 0, 0, 0, 11587, 11585, 1, 0, 0, 0, 11587, 11588, 1, 0, 0, 0, + 11588, 11592, 1, 0, 0, 0, 11589, 11587, 1, 0, 0, 0, 11590, 11591, 5, 1208, + 0, 0, 11591, 11593, 5, 1089, 0, 0, 11592, 11590, 1, 0, 0, 0, 11592, 11593, + 1, 0, 0, 0, 11593, 11633, 1, 0, 0, 0, 11594, 11595, 5, 365, 0, 0, 11595, + 11596, 5, 1088, 0, 0, 11596, 11600, 5, 704, 0, 0, 11597, 11598, 5, 1206, + 0, 0, 11598, 11599, 5, 1184, 0, 0, 11599, 11601, 5, 1207, 0, 0, 11600, + 11597, 1, 0, 0, 0, 11600, 11601, 1, 0, 0, 0, 11601, 11605, 1, 0, 0, 0, + 11602, 11604, 3, 978, 489, 0, 11603, 11602, 1, 0, 0, 0, 11604, 11607, 1, + 0, 0, 0, 11605, 11603, 1, 0, 0, 0, 11605, 11606, 1, 0, 0, 0, 11606, 11613, + 1, 0, 0, 0, 11607, 11605, 1, 0, 0, 0, 11608, 11609, 5, 1208, 0, 0, 11609, + 11611, 5, 288, 0, 0, 11610, 11612, 7, 141, 0, 0, 11611, 11610, 1, 0, 0, + 0, 11611, 11612, 1, 0, 0, 0, 11612, 11614, 1, 0, 0, 0, 11613, 11608, 1, + 0, 0, 0, 11613, 11614, 1, 0, 0, 0, 11614, 11633, 1, 0, 0, 0, 11615, 11616, + 5, 365, 0, 0, 11616, 11617, 5, 485, 0, 0, 11617, 11629, 7, 142, 0, 0, 11618, + 11625, 5, 1208, 0, 0, 11619, 11620, 5, 834, 0, 0, 11620, 11621, 5, 1206, + 0, 0, 11621, 11622, 5, 1184, 0, 0, 11622, 11626, 5, 1207, 0, 0, 11623, + 11626, 5, 453, 0, 0, 11624, 11626, 5, 1080, 0, 0, 11625, 11619, 1, 0, 0, + 0, 11625, 11623, 1, 0, 0, 0, 11625, 11624, 1, 0, 0, 0, 11626, 11628, 1, + 0, 0, 0, 11627, 11618, 1, 0, 0, 0, 11628, 11631, 1, 0, 0, 0, 11629, 11627, + 1, 0, 0, 0, 11629, 11630, 1, 0, 0, 0, 11630, 11633, 1, 0, 0, 0, 11631, + 11629, 1, 0, 0, 0, 11632, 11543, 1, 0, 0, 0, 11632, 11545, 1, 0, 0, 0, + 11632, 11581, 1, 0, 0, 0, 11632, 11594, 1, 0, 0, 0, 11632, 11615, 1, 0, + 0, 0, 11633, 977, 1, 0, 0, 0, 11634, 11644, 5, 1208, 0, 0, 11635, 11636, + 5, 95, 0, 0, 11636, 11645, 5, 88, 0, 0, 11637, 11645, 5, 1024, 0, 0, 11638, + 11642, 5, 834, 0, 0, 11639, 11640, 5, 1206, 0, 0, 11640, 11641, 5, 1184, + 0, 0, 11641, 11643, 5, 1207, 0, 0, 11642, 11639, 1, 0, 0, 0, 11642, 11643, + 1, 0, 0, 0, 11643, 11645, 1, 0, 0, 0, 11644, 11635, 1, 0, 0, 0, 11644, + 11637, 1, 0, 0, 0, 11644, 11638, 1, 0, 0, 0, 11645, 979, 1, 0, 0, 0, 11646, + 11649, 3, 926, 463, 0, 11647, 11650, 5, 57, 0, 0, 11648, 11650, 5, 260, + 0, 0, 11649, 11647, 1, 0, 0, 0, 11649, 11648, 1, 0, 0, 0, 11649, 11650, + 1, 0, 0, 0, 11650, 981, 1, 0, 0, 0, 11651, 11653, 5, 1206, 0, 0, 11652, + 11651, 1, 0, 0, 0, 11652, 11653, 1, 0, 0, 0, 11653, 11654, 1, 0, 0, 0, + 11654, 11659, 3, 984, 492, 0, 11655, 11656, 5, 1208, 0, 0, 11656, 11658, + 3, 984, 492, 0, 11657, 11655, 1, 0, 0, 0, 11658, 11661, 1, 0, 0, 0, 11659, + 11657, 1, 0, 0, 0, 11659, 11660, 1, 0, 0, 0, 11660, 11663, 1, 0, 0, 0, + 11661, 11659, 1, 0, 0, 0, 11662, 11664, 5, 1207, 0, 0, 11663, 11662, 1, + 0, 0, 0, 11663, 11664, 1, 0, 0, 0, 11664, 11668, 1, 0, 0, 0, 11665, 11666, + 5, 1206, 0, 0, 11666, 11668, 5, 1207, 0, 0, 11667, 11652, 1, 0, 0, 0, 11667, + 11665, 1, 0, 0, 0, 11668, 983, 1, 0, 0, 0, 11669, 11670, 3, 926, 463, 0, + 11670, 985, 1, 0, 0, 0, 11671, 11672, 5, 677, 0, 0, 11672, 11673, 5, 1206, + 0, 0, 11673, 11678, 3, 988, 494, 0, 11674, 11675, 5, 1208, 0, 0, 11675, + 11677, 3, 988, 494, 0, 11676, 11674, 1, 0, 0, 0, 11677, 11680, 1, 0, 0, + 0, 11678, 11676, 1, 0, 0, 0, 11678, 11679, 1, 0, 0, 0, 11679, 11681, 1, + 0, 0, 0, 11680, 11678, 1, 0, 0, 0, 11681, 11682, 5, 1207, 0, 0, 11682, + 987, 1, 0, 0, 0, 11683, 11684, 5, 340, 0, 0, 11684, 11729, 5, 1182, 0, + 0, 11685, 11686, 7, 143, 0, 0, 11686, 11729, 5, 412, 0, 0, 11687, 11688, + 7, 144, 0, 0, 11688, 11729, 5, 1033, 0, 0, 11689, 11690, 7, 145, 0, 0, + 11690, 11729, 5, 484, 0, 0, 11691, 11692, 5, 325, 0, 0, 11692, 11729, 5, + 1066, 0, 0, 11693, 11694, 5, 366, 0, 0, 11694, 11729, 5, 679, 0, 0, 11695, + 11729, 5, 443, 0, 0, 11696, 11697, 5, 493, 0, 0, 11697, 11729, 5, 721, + 0, 0, 11698, 11699, 5, 495, 0, 0, 11699, 11729, 5, 721, 0, 0, 11700, 11701, + 5, 551, 0, 0, 11701, 11729, 5, 1182, 0, 0, 11702, 11703, 5, 552, 0, 0, + 11703, 11729, 5, 1182, 0, 0, 11704, 11705, 5, 675, 0, 0, 11705, 11706, + 5, 365, 0, 0, 11706, 11707, 5, 1206, 0, 0, 11707, 11712, 3, 990, 495, 0, + 11708, 11709, 5, 1208, 0, 0, 11709, 11711, 3, 990, 495, 0, 11710, 11708, + 1, 0, 0, 0, 11711, 11714, 1, 0, 0, 0, 11712, 11710, 1, 0, 0, 0, 11712, + 11713, 1, 0, 0, 0, 11713, 11715, 1, 0, 0, 0, 11714, 11712, 1, 0, 0, 0, + 11715, 11716, 5, 1207, 0, 0, 11716, 11729, 1, 0, 0, 0, 11717, 11718, 5, + 675, 0, 0, 11718, 11719, 5, 365, 0, 0, 11719, 11729, 5, 1035, 0, 0, 11720, + 11721, 5, 694, 0, 0, 11721, 11729, 7, 89, 0, 0, 11722, 11729, 5, 782, 0, + 0, 11723, 11724, 5, 831, 0, 0, 11724, 11729, 5, 721, 0, 0, 11725, 11726, + 5, 1047, 0, 0, 11726, 11727, 5, 721, 0, 0, 11727, 11729, 5, 1184, 0, 0, + 11728, 11683, 1, 0, 0, 0, 11728, 11685, 1, 0, 0, 0, 11728, 11687, 1, 0, + 0, 0, 11728, 11689, 1, 0, 0, 0, 11728, 11691, 1, 0, 0, 0, 11728, 11693, + 1, 0, 0, 0, 11728, 11695, 1, 0, 0, 0, 11728, 11696, 1, 0, 0, 0, 11728, + 11698, 1, 0, 0, 0, 11728, 11700, 1, 0, 0, 0, 11728, 11702, 1, 0, 0, 0, + 11728, 11704, 1, 0, 0, 0, 11728, 11717, 1, 0, 0, 0, 11728, 11720, 1, 0, + 0, 0, 11728, 11722, 1, 0, 0, 0, 11728, 11723, 1, 0, 0, 0, 11728, 11725, + 1, 0, 0, 0, 11729, 989, 1, 0, 0, 0, 11730, 11737, 5, 1180, 0, 0, 11731, + 11738, 5, 1035, 0, 0, 11732, 11735, 5, 1188, 0, 0, 11733, 11736, 3, 1224, + 612, 0, 11734, 11736, 5, 643, 0, 0, 11735, 11733, 1, 0, 0, 0, 11735, 11734, + 1, 0, 0, 0, 11736, 11738, 1, 0, 0, 0, 11737, 11731, 1, 0, 0, 0, 11737, + 11732, 1, 0, 0, 0, 11738, 991, 1, 0, 0, 0, 11739, 11744, 3, 1002, 501, + 0, 11740, 11741, 5, 1208, 0, 0, 11741, 11743, 3, 1002, 501, 0, 11742, 11740, + 1, 0, 0, 0, 11743, 11746, 1, 0, 0, 0, 11744, 11742, 1, 0, 0, 0, 11744, + 11745, 1, 0, 0, 0, 11745, 993, 1, 0, 0, 0, 11746, 11744, 1, 0, 0, 0, 11747, + 11748, 5, 1206, 0, 0, 11748, 11753, 3, 772, 386, 0, 11749, 11750, 5, 1208, + 0, 0, 11750, 11752, 3, 772, 386, 0, 11751, 11749, 1, 0, 0, 0, 11752, 11755, + 1, 0, 0, 0, 11753, 11751, 1, 0, 0, 0, 11753, 11754, 1, 0, 0, 0, 11754, + 11756, 1, 0, 0, 0, 11755, 11753, 1, 0, 0, 0, 11756, 11757, 5, 1207, 0, + 0, 11757, 995, 1, 0, 0, 0, 11758, 11759, 3, 1170, 585, 0, 11759, 11760, + 5, 1201, 0, 0, 11760, 11762, 1, 0, 0, 0, 11761, 11758, 1, 0, 0, 0, 11761, + 11762, 1, 0, 0, 0, 11762, 11763, 1, 0, 0, 0, 11763, 11768, 5, 1212, 0, + 0, 11764, 11765, 7, 146, 0, 0, 11765, 11766, 5, 1201, 0, 0, 11766, 11768, + 5, 1212, 0, 0, 11767, 11761, 1, 0, 0, 0, 11767, 11764, 1, 0, 0, 0, 11768, + 997, 1, 0, 0, 0, 11769, 11770, 3, 1230, 615, 0, 11770, 11771, 5, 1201, + 0, 0, 11771, 11772, 3, 1230, 615, 0, 11772, 11774, 3, 994, 497, 0, 11773, + 11775, 3, 1102, 551, 0, 11774, 11773, 1, 0, 0, 0, 11774, 11775, 1, 0, 0, + 0, 11775, 11786, 1, 0, 0, 0, 11776, 11777, 3, 1230, 615, 0, 11777, 11778, + 5, 1211, 0, 0, 11778, 11780, 3, 1230, 615, 0, 11779, 11781, 3, 994, 497, + 0, 11780, 11779, 1, 0, 0, 0, 11780, 11781, 1, 0, 0, 0, 11781, 11783, 1, + 0, 0, 0, 11782, 11784, 3, 1102, 551, 0, 11783, 11782, 1, 0, 0, 0, 11783, + 11784, 1, 0, 0, 0, 11784, 11786, 1, 0, 0, 0, 11785, 11769, 1, 0, 0, 0, + 11785, 11776, 1, 0, 0, 0, 11786, 999, 1, 0, 0, 0, 11787, 11788, 3, 1122, + 561, 0, 11788, 11789, 5, 1188, 0, 0, 11789, 11790, 3, 926, 463, 0, 11790, + 11796, 1, 0, 0, 0, 11791, 11793, 3, 926, 463, 0, 11792, 11794, 3, 1102, + 551, 0, 11793, 11792, 1, 0, 0, 0, 11793, 11794, 1, 0, 0, 0, 11794, 11796, + 1, 0, 0, 0, 11795, 11787, 1, 0, 0, 0, 11795, 11791, 1, 0, 0, 0, 11796, + 1001, 1, 0, 0, 0, 11797, 11807, 3, 996, 498, 0, 11798, 11807, 3, 998, 499, + 0, 11799, 11802, 5, 1180, 0, 0, 11800, 11803, 3, 1238, 619, 0, 11801, 11803, + 5, 1188, 0, 0, 11802, 11800, 1, 0, 0, 0, 11802, 11801, 1, 0, 0, 0, 11803, + 11804, 1, 0, 0, 0, 11804, 11807, 3, 926, 463, 0, 11805, 11807, 3, 1000, + 500, 0, 11806, 11797, 1, 0, 0, 0, 11806, 11798, 1, 0, 0, 0, 11806, 11799, + 1, 0, 0, 0, 11806, 11805, 1, 0, 0, 0, 11807, 1003, 1, 0, 0, 0, 11808, 11813, + 3, 1006, 503, 0, 11809, 11810, 5, 1208, 0, 0, 11810, 11812, 3, 1006, 503, + 0, 11811, 11809, 1, 0, 0, 0, 11812, 11815, 1, 0, 0, 0, 11813, 11811, 1, + 0, 0, 0, 11813, 11814, 1, 0, 0, 0, 11814, 1005, 1, 0, 0, 0, 11815, 11813, + 1, 0, 0, 0, 11816, 11820, 3, 1008, 504, 0, 11817, 11819, 3, 1028, 514, + 0, 11818, 11817, 1, 0, 0, 0, 11819, 11822, 1, 0, 0, 0, 11820, 11818, 1, + 0, 0, 0, 11820, 11821, 1, 0, 0, 0, 11821, 1007, 1, 0, 0, 0, 11822, 11820, + 1, 0, 0, 0, 11823, 11824, 3, 1164, 582, 0, 11824, 11825, 3, 1110, 555, + 0, 11825, 11826, 3, 1104, 552, 0, 11826, 11892, 1, 0, 0, 0, 11827, 11829, + 3, 1164, 582, 0, 11828, 11830, 3, 1104, 552, 0, 11829, 11828, 1, 0, 0, + 0, 11829, 11830, 1, 0, 0, 0, 11830, 11834, 1, 0, 0, 0, 11831, 11835, 3, + 1108, 554, 0, 11832, 11835, 3, 1110, 555, 0, 11833, 11835, 3, 1112, 556, + 0, 11834, 11831, 1, 0, 0, 0, 11834, 11832, 1, 0, 0, 0, 11834, 11833, 1, + 0, 0, 0, 11834, 11835, 1, 0, 0, 0, 11835, 11892, 1, 0, 0, 0, 11836, 11838, + 3, 1046, 523, 0, 11837, 11839, 3, 1104, 552, 0, 11838, 11837, 1, 0, 0, + 0, 11838, 11839, 1, 0, 0, 0, 11839, 11892, 1, 0, 0, 0, 11840, 11841, 5, + 1206, 0, 0, 11841, 11842, 3, 1050, 525, 0, 11842, 11847, 5, 1207, 0, 0, + 11843, 11845, 3, 1104, 552, 0, 11844, 11846, 3, 1120, 560, 0, 11845, 11844, + 1, 0, 0, 0, 11845, 11846, 1, 0, 0, 0, 11846, 11848, 1, 0, 0, 0, 11847, + 11843, 1, 0, 0, 0, 11847, 11848, 1, 0, 0, 0, 11848, 11892, 1, 0, 0, 0, + 11849, 11851, 3, 1022, 511, 0, 11850, 11852, 3, 1104, 552, 0, 11851, 11850, + 1, 0, 0, 0, 11851, 11852, 1, 0, 0, 0, 11852, 11892, 1, 0, 0, 0, 11853, + 11858, 3, 1096, 548, 0, 11854, 11856, 3, 1104, 552, 0, 11855, 11857, 3, + 1120, 560, 0, 11856, 11855, 1, 0, 0, 0, 11856, 11857, 1, 0, 0, 0, 11857, + 11859, 1, 0, 0, 0, 11858, 11854, 1, 0, 0, 0, 11858, 11859, 1, 0, 0, 0, + 11859, 11892, 1, 0, 0, 0, 11860, 11865, 3, 1052, 526, 0, 11861, 11863, + 3, 1104, 552, 0, 11862, 11864, 3, 1120, 560, 0, 11863, 11862, 1, 0, 0, + 0, 11863, 11864, 1, 0, 0, 0, 11864, 11866, 1, 0, 0, 0, 11865, 11861, 1, + 0, 0, 0, 11865, 11866, 1, 0, 0, 0, 11866, 11892, 1, 0, 0, 0, 11867, 11869, + 5, 1180, 0, 0, 11868, 11870, 3, 1104, 552, 0, 11869, 11868, 1, 0, 0, 0, + 11869, 11870, 1, 0, 0, 0, 11870, 11892, 1, 0, 0, 0, 11871, 11872, 5, 1180, + 0, 0, 11872, 11873, 5, 1201, 0, 0, 11873, 11878, 3, 1052, 526, 0, 11874, + 11876, 3, 1104, 552, 0, 11875, 11877, 3, 1120, 560, 0, 11876, 11875, 1, + 0, 0, 0, 11876, 11877, 1, 0, 0, 0, 11877, 11879, 1, 0, 0, 0, 11878, 11874, + 1, 0, 0, 0, 11878, 11879, 1, 0, 0, 0, 11879, 11892, 1, 0, 0, 0, 11880, + 11892, 3, 1010, 505, 0, 11881, 11892, 3, 1012, 506, 0, 11882, 11883, 5, + 1211, 0, 0, 11883, 11885, 3, 1052, 526, 0, 11884, 11886, 3, 1104, 552, + 0, 11885, 11884, 1, 0, 0, 0, 11885, 11886, 1, 0, 0, 0, 11886, 11892, 1, + 0, 0, 0, 11887, 11888, 5, 1206, 0, 0, 11888, 11889, 3, 1006, 503, 0, 11889, + 11890, 5, 1207, 0, 0, 11890, 11892, 1, 0, 0, 0, 11891, 11823, 1, 0, 0, + 0, 11891, 11827, 1, 0, 0, 0, 11891, 11836, 1, 0, 0, 0, 11891, 11840, 1, + 0, 0, 0, 11891, 11849, 1, 0, 0, 0, 11891, 11853, 1, 0, 0, 0, 11891, 11860, + 1, 0, 0, 0, 11891, 11867, 1, 0, 0, 0, 11891, 11871, 1, 0, 0, 0, 11891, + 11880, 1, 0, 0, 0, 11891, 11881, 1, 0, 0, 0, 11891, 11882, 1, 0, 0, 0, + 11891, 11887, 1, 0, 0, 0, 11892, 1009, 1, 0, 0, 0, 11893, 11894, 5, 671, + 0, 0, 11894, 11895, 5, 1206, 0, 0, 11895, 11896, 3, 926, 463, 0, 11896, + 11897, 5, 1208, 0, 0, 11897, 11900, 3, 926, 463, 0, 11898, 11899, 5, 1208, + 0, 0, 11899, 11901, 3, 926, 463, 0, 11900, 11898, 1, 0, 0, 0, 11900, 11901, + 1, 0, 0, 0, 11901, 11902, 1, 0, 0, 0, 11902, 11908, 5, 1207, 0, 0, 11903, + 11904, 5, 1077, 0, 0, 11904, 11905, 5, 1206, 0, 0, 11905, 11906, 3, 1018, + 509, 0, 11906, 11907, 5, 1207, 0, 0, 11907, 11909, 1, 0, 0, 0, 11908, 11903, + 1, 0, 0, 0, 11908, 11909, 1, 0, 0, 0, 11909, 11911, 1, 0, 0, 0, 11910, + 11912, 3, 1104, 552, 0, 11911, 11910, 1, 0, 0, 0, 11911, 11912, 1, 0, 0, + 0, 11912, 1011, 1, 0, 0, 0, 11913, 11914, 5, 668, 0, 0, 11914, 11915, 5, + 1206, 0, 0, 11915, 11918, 3, 926, 463, 0, 11916, 11917, 5, 1208, 0, 0, + 11917, 11919, 3, 926, 463, 0, 11918, 11916, 1, 0, 0, 0, 11918, 11919, 1, + 0, 0, 0, 11919, 11920, 1, 0, 0, 0, 11920, 11926, 5, 1207, 0, 0, 11921, + 11922, 5, 1077, 0, 0, 11922, 11923, 5, 1206, 0, 0, 11923, 11924, 3, 1014, + 507, 0, 11924, 11925, 5, 1207, 0, 0, 11925, 11927, 1, 0, 0, 0, 11926, 11921, + 1, 0, 0, 0, 11926, 11927, 1, 0, 0, 0, 11927, 11929, 1, 0, 0, 0, 11928, + 11930, 3, 1104, 552, 0, 11929, 11928, 1, 0, 0, 0, 11929, 11930, 1, 0, 0, + 0, 11930, 1013, 1, 0, 0, 0, 11931, 11936, 3, 1016, 508, 0, 11932, 11933, + 5, 1208, 0, 0, 11933, 11935, 3, 1016, 508, 0, 11934, 11932, 1, 0, 0, 0, + 11935, 11938, 1, 0, 0, 0, 11936, 11934, 1, 0, 0, 0, 11936, 11937, 1, 0, + 0, 0, 11937, 1015, 1, 0, 0, 0, 11938, 11936, 1, 0, 0, 0, 11939, 11942, + 3, 1020, 510, 0, 11940, 11941, 5, 56, 0, 0, 11941, 11943, 5, 485, 0, 0, + 11942, 11940, 1, 0, 0, 0, 11942, 11943, 1, 0, 0, 0, 11943, 1017, 1, 0, + 0, 0, 11944, 11949, 3, 1020, 510, 0, 11945, 11946, 5, 1208, 0, 0, 11946, + 11948, 3, 1020, 510, 0, 11947, 11945, 1, 0, 0, 0, 11948, 11951, 1, 0, 0, + 0, 11949, 11947, 1, 0, 0, 0, 11949, 11950, 1, 0, 0, 0, 11950, 1019, 1, + 0, 0, 0, 11951, 11949, 1, 0, 0, 0, 11952, 11953, 3, 1230, 615, 0, 11953, + 11955, 3, 1222, 611, 0, 11954, 11956, 5, 1184, 0, 0, 11955, 11954, 1, 0, + 0, 0, 11955, 11956, 1, 0, 0, 0, 11956, 1021, 1, 0, 0, 0, 11957, 11960, + 3, 1024, 512, 0, 11958, 11960, 3, 1026, 513, 0, 11959, 11957, 1, 0, 0, + 0, 11959, 11958, 1, 0, 0, 0, 11960, 1023, 1, 0, 0, 0, 11961, 11962, 5, + 128, 0, 0, 11962, 11963, 5, 1206, 0, 0, 11963, 11964, 5, 127, 0, 0, 11964, + 11965, 3, 1170, 585, 0, 11965, 11966, 5, 1208, 0, 0, 11966, 11967, 7, 147, + 0, 0, 11967, 11968, 5, 1207, 0, 0, 11968, 1025, 1, 0, 0, 0, 11969, 11970, + 5, 128, 0, 0, 11970, 11971, 5, 1206, 0, 0, 11971, 11972, 5, 1064, 0, 0, + 11972, 11973, 3, 1170, 585, 0, 11973, 11974, 5, 1208, 0, 0, 11974, 11975, + 3, 1044, 522, 0, 11975, 11976, 5, 1208, 0, 0, 11976, 11977, 3, 992, 496, + 0, 11977, 11978, 5, 1207, 0, 0, 11978, 1027, 1, 0, 0, 0, 11979, 11985, + 3, 1030, 515, 0, 11980, 11985, 3, 1032, 516, 0, 11981, 11985, 3, 1034, + 517, 0, 11982, 11985, 3, 1036, 518, 0, 11983, 11985, 3, 1038, 519, 0, 11984, + 11979, 1, 0, 0, 0, 11984, 11980, 1, 0, 0, 0, 11984, 11981, 1, 0, 0, 0, + 11984, 11982, 1, 0, 0, 0, 11984, 11983, 1, 0, 0, 0, 11985, 1029, 1, 0, + 0, 0, 11986, 11988, 5, 463, 0, 0, 11987, 11986, 1, 0, 0, 0, 11987, 11988, + 1, 0, 0, 0, 11988, 11994, 1, 0, 0, 0, 11989, 11991, 7, 148, 0, 0, 11990, + 11992, 5, 683, 0, 0, 11991, 11990, 1, 0, 0, 0, 11991, 11992, 1, 0, 0, 0, + 11992, 11994, 1, 0, 0, 0, 11993, 11987, 1, 0, 0, 0, 11993, 11989, 1, 0, + 0, 0, 11994, 11996, 1, 0, 0, 0, 11995, 11997, 7, 149, 0, 0, 11996, 11995, + 1, 0, 0, 0, 11996, 11997, 1, 0, 0, 0, 11997, 11998, 1, 0, 0, 0, 11998, + 11999, 5, 484, 0, 0, 11999, 12000, 3, 1006, 503, 0, 12000, 12001, 5, 662, + 0, 0, 12001, 12002, 3, 950, 475, 0, 12002, 1031, 1, 0, 0, 0, 12003, 12004, + 5, 203, 0, 0, 12004, 12005, 5, 484, 0, 0, 12005, 12006, 3, 1008, 504, 0, + 12006, 1033, 1, 0, 0, 0, 12007, 12008, 7, 150, 0, 0, 12008, 12009, 5, 52, + 0, 0, 12009, 12010, 3, 1008, 504, 0, 12010, 1035, 1, 0, 0, 0, 12011, 12012, + 5, 720, 0, 0, 12012, 12013, 3, 1040, 520, 0, 12013, 12014, 3, 1104, 552, + 0, 12014, 1037, 1, 0, 0, 0, 12015, 12016, 5, 1039, 0, 0, 12016, 12017, + 3, 1042, 521, 0, 12017, 12018, 3, 1104, 552, 0, 12018, 1039, 1, 0, 0, 0, + 12019, 12020, 5, 1206, 0, 0, 12020, 12021, 3, 1130, 565, 0, 12021, 12022, + 5, 365, 0, 0, 12022, 12023, 3, 1182, 591, 0, 12023, 12024, 5, 451, 0, 0, + 12024, 12025, 3, 1120, 560, 0, 12025, 12026, 5, 1207, 0, 0, 12026, 1041, + 1, 0, 0, 0, 12027, 12028, 5, 1206, 0, 0, 12028, 12029, 3, 926, 463, 0, + 12029, 12030, 5, 365, 0, 0, 12030, 12031, 3, 1182, 591, 0, 12031, 12032, + 5, 451, 0, 0, 12032, 12033, 5, 1206, 0, 0, 12033, 12034, 3, 1044, 522, + 0, 12034, 12035, 5, 1207, 0, 0, 12035, 12036, 5, 1207, 0, 0, 12036, 1043, + 1, 0, 0, 0, 12037, 12042, 3, 1182, 591, 0, 12038, 12039, 5, 1208, 0, 0, + 12039, 12041, 3, 1182, 591, 0, 12040, 12038, 1, 0, 0, 0, 12041, 12044, + 1, 0, 0, 0, 12042, 12040, 1, 0, 0, 0, 12042, 12043, 1, 0, 0, 0, 12043, + 1045, 1, 0, 0, 0, 12044, 12042, 1, 0, 0, 0, 12045, 12046, 5, 670, 0, 0, + 12046, 12047, 5, 1206, 0, 0, 12047, 12048, 5, 1184, 0, 0, 12048, 12049, + 5, 1208, 0, 0, 12049, 12050, 5, 1184, 0, 0, 12050, 12051, 5, 1208, 0, 0, + 12051, 12052, 5, 1184, 0, 0, 12052, 12072, 5, 1207, 0, 0, 12053, 12054, + 5, 670, 0, 0, 12054, 12055, 5, 1206, 0, 0, 12055, 12056, 5, 109, 0, 0, + 12056, 12057, 5, 1184, 0, 0, 12057, 12067, 5, 1208, 0, 0, 12058, 12063, + 3, 1048, 524, 0, 12059, 12060, 5, 1208, 0, 0, 12060, 12062, 3, 1048, 524, + 0, 12061, 12059, 1, 0, 0, 0, 12062, 12065, 1, 0, 0, 0, 12063, 12061, 1, + 0, 0, 0, 12063, 12064, 1, 0, 0, 0, 12064, 12068, 1, 0, 0, 0, 12065, 12063, + 1, 0, 0, 0, 12066, 12068, 3, 1230, 615, 0, 12067, 12058, 1, 0, 0, 0, 12067, + 12066, 1, 0, 0, 0, 12068, 12069, 1, 0, 0, 0, 12069, 12070, 5, 1207, 0, + 0, 12070, 12072, 1, 0, 0, 0, 12071, 12045, 1, 0, 0, 0, 12071, 12053, 1, + 0, 0, 0, 12072, 1047, 1, 0, 0, 0, 12073, 12074, 3, 1230, 615, 0, 12074, + 12075, 5, 1188, 0, 0, 12075, 12076, 7, 31, 0, 0, 12076, 1049, 1, 0, 0, + 0, 12077, 12096, 3, 940, 470, 0, 12078, 12079, 5, 1206, 0, 0, 12079, 12085, + 3, 940, 470, 0, 12080, 12081, 5, 1033, 0, 0, 12081, 12082, 5, 22, 0, 0, + 12082, 12084, 3, 940, 470, 0, 12083, 12080, 1, 0, 0, 0, 12084, 12087, 1, + 0, 0, 0, 12085, 12083, 1, 0, 0, 0, 12085, 12086, 1, 0, 0, 0, 12086, 12088, + 1, 0, 0, 0, 12087, 12085, 1, 0, 0, 0, 12088, 12089, 5, 1207, 0, 0, 12089, + 12096, 1, 0, 0, 0, 12090, 12096, 3, 1124, 562, 0, 12091, 12092, 5, 1206, + 0, 0, 12092, 12093, 3, 1124, 562, 0, 12093, 12094, 5, 1207, 0, 0, 12094, + 12096, 1, 0, 0, 0, 12095, 12077, 1, 0, 0, 0, 12095, 12078, 1, 0, 0, 0, + 12095, 12090, 1, 0, 0, 0, 12095, 12091, 1, 0, 0, 0, 12096, 1051, 1, 0, + 0, 0, 12097, 12112, 3, 1128, 564, 0, 12098, 12112, 3, 1130, 565, 0, 12099, + 12112, 3, 1132, 566, 0, 12100, 12112, 3, 1064, 532, 0, 12101, 12102, 3, + 1202, 601, 0, 12102, 12104, 5, 1206, 0, 0, 12103, 12105, 3, 1126, 563, + 0, 12104, 12103, 1, 0, 0, 0, 12104, 12105, 1, 0, 0, 0, 12105, 12106, 1, + 0, 0, 0, 12106, 12107, 5, 1207, 0, 0, 12107, 12112, 1, 0, 0, 0, 12108, + 12112, 3, 1056, 528, 0, 12109, 12112, 3, 1054, 527, 0, 12110, 12112, 3, + 1094, 547, 0, 12111, 12097, 1, 0, 0, 0, 12111, 12098, 1, 0, 0, 0, 12111, + 12099, 1, 0, 0, 0, 12111, 12100, 1, 0, 0, 0, 12111, 12101, 1, 0, 0, 0, + 12111, 12108, 1, 0, 0, 0, 12111, 12109, 1, 0, 0, 0, 12111, 12110, 1, 0, + 0, 0, 12112, 1053, 1, 0, 0, 0, 12113, 12114, 3, 1230, 615, 0, 12114, 12115, + 5, 1201, 0, 0, 12115, 12117, 1, 0, 0, 0, 12116, 12113, 1, 0, 0, 0, 12116, + 12117, 1, 0, 0, 0, 12117, 12118, 1, 0, 0, 0, 12118, 12119, 5, 278, 0, 0, + 12119, 12120, 5, 1201, 0, 0, 12120, 12121, 3, 1230, 615, 0, 12121, 12122, + 5, 1206, 0, 0, 12122, 12123, 3, 926, 463, 0, 12123, 12124, 5, 1207, 0, + 0, 12124, 1055, 1, 0, 0, 0, 12125, 12126, 7, 151, 0, 0, 12126, 12127, 5, + 1206, 0, 0, 12127, 12128, 3, 1170, 585, 0, 12128, 12142, 5, 1208, 0, 0, + 12129, 12143, 3, 1182, 591, 0, 12130, 12131, 5, 1206, 0, 0, 12131, 12136, + 3, 1182, 591, 0, 12132, 12133, 5, 1208, 0, 0, 12133, 12135, 3, 1182, 591, + 0, 12134, 12132, 1, 0, 0, 0, 12135, 12138, 1, 0, 0, 0, 12136, 12134, 1, + 0, 0, 0, 12136, 12137, 1, 0, 0, 0, 12137, 12139, 1, 0, 0, 0, 12138, 12136, + 1, 0, 0, 0, 12139, 12140, 5, 1207, 0, 0, 12140, 12143, 1, 0, 0, 0, 12141, + 12143, 5, 1212, 0, 0, 12142, 12129, 1, 0, 0, 0, 12142, 12130, 1, 0, 0, + 0, 12142, 12141, 1, 0, 0, 0, 12143, 12144, 1, 0, 0, 0, 12144, 12145, 5, + 1208, 0, 0, 12145, 12149, 3, 926, 463, 0, 12146, 12147, 5, 1208, 0, 0, + 12147, 12148, 5, 506, 0, 0, 12148, 12150, 3, 926, 463, 0, 12149, 12146, + 1, 0, 0, 0, 12149, 12150, 1, 0, 0, 0, 12150, 12153, 1, 0, 0, 0, 12151, + 12152, 5, 1208, 0, 0, 12152, 12154, 3, 926, 463, 0, 12153, 12151, 1, 0, + 0, 0, 12153, 12154, 1, 0, 0, 0, 12154, 12155, 1, 0, 0, 0, 12155, 12156, + 5, 1207, 0, 0, 12156, 12194, 1, 0, 0, 0, 12157, 12158, 7, 152, 0, 0, 12158, + 12159, 5, 1206, 0, 0, 12159, 12160, 3, 1170, 585, 0, 12160, 12174, 5, 1208, + 0, 0, 12161, 12175, 3, 1182, 591, 0, 12162, 12163, 5, 1206, 0, 0, 12163, + 12168, 3, 1182, 591, 0, 12164, 12165, 5, 1208, 0, 0, 12165, 12167, 3, 1182, + 591, 0, 12166, 12164, 1, 0, 0, 0, 12167, 12170, 1, 0, 0, 0, 12168, 12166, + 1, 0, 0, 0, 12168, 12169, 1, 0, 0, 0, 12169, 12171, 1, 0, 0, 0, 12170, + 12168, 1, 0, 0, 0, 12171, 12172, 5, 1207, 0, 0, 12172, 12175, 1, 0, 0, + 0, 12173, 12175, 5, 1212, 0, 0, 12174, 12161, 1, 0, 0, 0, 12174, 12162, + 1, 0, 0, 0, 12174, 12173, 1, 0, 0, 0, 12175, 12176, 1, 0, 0, 0, 12176, + 12177, 5, 1208, 0, 0, 12177, 12178, 3, 926, 463, 0, 12178, 12179, 5, 1207, + 0, 0, 12179, 12194, 1, 0, 0, 0, 12180, 12181, 5, 881, 0, 0, 12181, 12182, + 5, 1206, 0, 0, 12182, 12183, 3, 1170, 585, 0, 12183, 12184, 5, 1208, 0, + 0, 12184, 12185, 3, 1182, 591, 0, 12185, 12186, 5, 1208, 0, 0, 12186, 12187, + 3, 926, 463, 0, 12187, 12188, 5, 1208, 0, 0, 12188, 12189, 3, 1182, 591, + 0, 12189, 12190, 5, 1208, 0, 0, 12190, 12191, 3, 926, 463, 0, 12191, 12192, + 5, 1207, 0, 0, 12192, 12194, 1, 0, 0, 0, 12193, 12125, 1, 0, 0, 0, 12193, + 12157, 1, 0, 0, 0, 12193, 12180, 1, 0, 0, 0, 12194, 1057, 1, 0, 0, 0, 12195, + 12196, 5, 181, 0, 0, 12196, 12217, 5, 1206, 0, 0, 12197, 12218, 3, 1182, + 591, 0, 12198, 12199, 5, 1206, 0, 0, 12199, 12204, 3, 1182, 591, 0, 12200, + 12201, 5, 1208, 0, 0, 12201, 12203, 3, 1182, 591, 0, 12202, 12200, 1, 0, + 0, 0, 12203, 12206, 1, 0, 0, 0, 12204, 12202, 1, 0, 0, 0, 12204, 12205, + 1, 0, 0, 0, 12205, 12207, 1, 0, 0, 0, 12206, 12204, 1, 0, 0, 0, 12207, + 12208, 5, 1207, 0, 0, 12208, 12218, 1, 0, 0, 0, 12209, 12218, 5, 1212, + 0, 0, 12210, 12211, 5, 745, 0, 0, 12211, 12212, 5, 1206, 0, 0, 12212, 12213, + 3, 1182, 591, 0, 12213, 12214, 5, 1208, 0, 0, 12214, 12215, 3, 926, 463, + 0, 12215, 12216, 5, 1207, 0, 0, 12216, 12218, 1, 0, 0, 0, 12217, 12197, + 1, 0, 0, 0, 12217, 12198, 1, 0, 0, 0, 12217, 12209, 1, 0, 0, 0, 12217, + 12210, 1, 0, 0, 0, 12218, 12219, 1, 0, 0, 0, 12219, 12220, 5, 1208, 0, + 0, 12220, 12221, 3, 926, 463, 0, 12221, 12222, 5, 1207, 0, 0, 12222, 12255, + 1, 0, 0, 0, 12223, 12224, 5, 378, 0, 0, 12224, 12228, 5, 1206, 0, 0, 12225, + 12226, 3, 1170, 585, 0, 12226, 12227, 5, 1208, 0, 0, 12227, 12229, 1, 0, + 0, 0, 12228, 12225, 1, 0, 0, 0, 12228, 12229, 1, 0, 0, 0, 12229, 12243, + 1, 0, 0, 0, 12230, 12244, 3, 1182, 591, 0, 12231, 12232, 5, 1206, 0, 0, + 12232, 12237, 3, 1182, 591, 0, 12233, 12234, 5, 1208, 0, 0, 12234, 12236, + 3, 1182, 591, 0, 12235, 12233, 1, 0, 0, 0, 12236, 12239, 1, 0, 0, 0, 12237, + 12235, 1, 0, 0, 0, 12237, 12238, 1, 0, 0, 0, 12238, 12240, 1, 0, 0, 0, + 12239, 12237, 1, 0, 0, 0, 12240, 12241, 5, 1207, 0, 0, 12241, 12244, 1, + 0, 0, 0, 12242, 12244, 5, 1212, 0, 0, 12243, 12230, 1, 0, 0, 0, 12243, + 12231, 1, 0, 0, 0, 12243, 12242, 1, 0, 0, 0, 12244, 12245, 1, 0, 0, 0, + 12245, 12246, 5, 1208, 0, 0, 12246, 12250, 3, 926, 463, 0, 12247, 12248, + 5, 1208, 0, 0, 12248, 12249, 5, 506, 0, 0, 12249, 12251, 3, 926, 463, 0, + 12250, 12247, 1, 0, 0, 0, 12250, 12251, 1, 0, 0, 0, 12251, 12252, 1, 0, + 0, 0, 12252, 12253, 5, 1207, 0, 0, 12253, 12255, 1, 0, 0, 0, 12254, 12195, + 1, 0, 0, 0, 12254, 12223, 1, 0, 0, 0, 12255, 1059, 1, 0, 0, 0, 12256, 12257, + 3, 926, 463, 0, 12257, 12258, 5, 1210, 0, 0, 12258, 12259, 3, 926, 463, + 0, 12259, 1061, 1, 0, 0, 0, 12260, 12261, 7, 153, 0, 0, 12261, 12262, 5, + 662, 0, 0, 12262, 12263, 5, 643, 0, 0, 12263, 1063, 1, 0, 0, 0, 12264, + 12265, 5, 53, 0, 0, 12265, 12266, 5, 1206, 0, 0, 12266, 13611, 5, 1207, + 0, 0, 12267, 12268, 5, 50, 0, 0, 12268, 12269, 5, 1206, 0, 0, 12269, 12270, + 3, 926, 463, 0, 12270, 12271, 5, 1208, 0, 0, 12271, 12272, 3, 926, 463, + 0, 12272, 12273, 5, 1208, 0, 0, 12273, 12274, 3, 926, 463, 0, 12274, 12275, + 5, 1207, 0, 0, 12275, 13611, 1, 0, 0, 0, 12276, 12277, 5, 51, 0, 0, 12277, + 12278, 5, 1206, 0, 0, 12278, 12279, 3, 926, 463, 0, 12279, 12280, 5, 1208, + 0, 0, 12280, 12281, 3, 926, 463, 0, 12281, 12282, 5, 1208, 0, 0, 12282, + 12283, 3, 926, 463, 0, 12283, 12284, 5, 1208, 0, 0, 12284, 12285, 3, 926, + 463, 0, 12285, 12286, 5, 1207, 0, 0, 12286, 13611, 1, 0, 0, 0, 12287, 12288, + 5, 60, 0, 0, 12288, 12289, 5, 1206, 0, 0, 12289, 12290, 3, 926, 463, 0, + 12290, 12291, 5, 1208, 0, 0, 12291, 12292, 3, 926, 463, 0, 12292, 12293, + 5, 1207, 0, 0, 12293, 13611, 1, 0, 0, 0, 12294, 12295, 5, 162, 0, 0, 12295, + 12296, 5, 1206, 0, 0, 12296, 12297, 3, 926, 463, 0, 12297, 12298, 5, 1208, + 0, 0, 12298, 12299, 3, 926, 463, 0, 12299, 12300, 5, 1207, 0, 0, 12300, + 13611, 1, 0, 0, 0, 12301, 12302, 5, 163, 0, 0, 12302, 12303, 5, 1206, 0, + 0, 12303, 12304, 3, 926, 463, 0, 12304, 12305, 5, 1208, 0, 0, 12305, 12306, + 3, 926, 463, 0, 12306, 12307, 5, 1207, 0, 0, 12307, 13611, 1, 0, 0, 0, + 12308, 12309, 5, 156, 0, 0, 12309, 12310, 5, 1206, 0, 0, 12310, 12311, + 3, 926, 463, 0, 12311, 12312, 5, 1208, 0, 0, 12312, 12313, 3, 926, 463, + 0, 12313, 12314, 5, 1208, 0, 0, 12314, 12315, 3, 926, 463, 0, 12315, 12316, + 5, 1207, 0, 0, 12316, 13611, 1, 0, 0, 0, 12317, 12318, 5, 220, 0, 0, 12318, + 12319, 5, 1206, 0, 0, 12319, 12320, 3, 926, 463, 0, 12320, 12321, 5, 1208, + 0, 0, 12321, 12322, 3, 926, 463, 0, 12322, 12323, 5, 1207, 0, 0, 12323, + 13611, 1, 0, 0, 0, 12324, 12325, 5, 238, 0, 0, 12325, 12327, 5, 1206, 0, + 0, 12326, 12328, 3, 926, 463, 0, 12327, 12326, 1, 0, 0, 0, 12327, 12328, + 1, 0, 0, 0, 12328, 12329, 1, 0, 0, 0, 12329, 13611, 5, 1207, 0, 0, 12330, + 12331, 5, 239, 0, 0, 12331, 12333, 5, 1206, 0, 0, 12332, 12334, 3, 926, + 463, 0, 12333, 12332, 1, 0, 0, 0, 12333, 12334, 1, 0, 0, 0, 12334, 12335, + 1, 0, 0, 0, 12335, 13611, 5, 1207, 0, 0, 12336, 12337, 5, 355, 0, 0, 12337, + 12338, 5, 1206, 0, 0, 12338, 12339, 3, 926, 463, 0, 12339, 12340, 5, 1207, + 0, 0, 12340, 13611, 1, 0, 0, 0, 12341, 12342, 5, 356, 0, 0, 12342, 12343, + 5, 1206, 0, 0, 12343, 12344, 3, 926, 463, 0, 12344, 12345, 5, 1207, 0, + 0, 12345, 13611, 1, 0, 0, 0, 12346, 12347, 5, 357, 0, 0, 12347, 12348, + 5, 1206, 0, 0, 12348, 12349, 3, 926, 463, 0, 12349, 12350, 5, 1207, 0, + 0, 12350, 13611, 1, 0, 0, 0, 12351, 12352, 5, 346, 0, 0, 12352, 12353, + 5, 1206, 0, 0, 12353, 12354, 3, 926, 463, 0, 12354, 12355, 5, 1207, 0, + 0, 12355, 13611, 1, 0, 0, 0, 12356, 12357, 5, 347, 0, 0, 12357, 12358, + 5, 1206, 0, 0, 12358, 12359, 3, 926, 463, 0, 12359, 12360, 5, 1207, 0, + 0, 12360, 13611, 1, 0, 0, 0, 12361, 12362, 5, 345, 0, 0, 12362, 12363, + 5, 1206, 0, 0, 12363, 12364, 3, 926, 463, 0, 12364, 12365, 5, 1208, 0, + 0, 12365, 12366, 3, 926, 463, 0, 12366, 12367, 5, 1207, 0, 0, 12367, 13611, + 1, 0, 0, 0, 12368, 12369, 5, 351, 0, 0, 12369, 12370, 5, 1206, 0, 0, 12370, + 12371, 3, 926, 463, 0, 12371, 12372, 5, 1208, 0, 0, 12372, 12373, 3, 926, + 463, 0, 12373, 12374, 5, 1207, 0, 0, 12374, 13611, 1, 0, 0, 0, 12375, 12376, + 5, 352, 0, 0, 12376, 12377, 5, 1206, 0, 0, 12377, 12378, 3, 926, 463, 0, + 12378, 12379, 5, 1208, 0, 0, 12379, 12380, 3, 926, 463, 0, 12380, 12381, + 5, 1207, 0, 0, 12381, 13611, 1, 0, 0, 0, 12382, 12383, 5, 384, 0, 0, 12383, + 12384, 5, 1206, 0, 0, 12384, 12385, 3, 926, 463, 0, 12385, 12386, 5, 1208, + 0, 0, 12386, 12387, 3, 926, 463, 0, 12387, 12388, 5, 1207, 0, 0, 12388, + 13611, 1, 0, 0, 0, 12389, 12390, 5, 385, 0, 0, 12390, 12391, 5, 1206, 0, + 0, 12391, 12392, 3, 926, 463, 0, 12392, 12393, 5, 1207, 0, 0, 12393, 13611, + 1, 0, 0, 0, 12394, 12395, 5, 459, 0, 0, 12395, 12396, 5, 1206, 0, 0, 12396, + 12397, 3, 926, 463, 0, 12397, 12398, 5, 1208, 0, 0, 12398, 12399, 3, 926, + 463, 0, 12399, 12400, 5, 1208, 0, 0, 12400, 12401, 3, 926, 463, 0, 12401, + 12402, 5, 1207, 0, 0, 12402, 13611, 1, 0, 0, 0, 12403, 12404, 5, 457, 0, + 0, 12404, 12405, 5, 1206, 0, 0, 12405, 12406, 3, 926, 463, 0, 12406, 12407, + 5, 1208, 0, 0, 12407, 12408, 3, 926, 463, 0, 12408, 12409, 5, 1208, 0, + 0, 12409, 12410, 3, 926, 463, 0, 12410, 12411, 5, 1208, 0, 0, 12411, 12412, + 3, 926, 463, 0, 12412, 12413, 5, 1207, 0, 0, 12413, 13611, 1, 0, 0, 0, + 12414, 12415, 5, 458, 0, 0, 12415, 12416, 5, 1206, 0, 0, 12416, 12417, + 3, 926, 463, 0, 12417, 12418, 5, 1208, 0, 0, 12418, 12419, 3, 926, 463, + 0, 12419, 12420, 5, 1208, 0, 0, 12420, 12421, 3, 926, 463, 0, 12421, 12422, + 5, 1207, 0, 0, 12422, 13611, 1, 0, 0, 0, 12423, 12424, 5, 608, 0, 0, 12424, + 12425, 5, 1055, 0, 0, 12425, 12426, 5, 365, 0, 0, 12426, 12432, 3, 1170, + 585, 0, 12427, 12428, 5, 685, 0, 0, 12428, 12429, 5, 1206, 0, 0, 12429, + 12430, 3, 972, 486, 0, 12430, 12431, 5, 1207, 0, 0, 12431, 12433, 1, 0, + 0, 0, 12432, 12427, 1, 0, 0, 0, 12432, 12433, 1, 0, 0, 0, 12433, 13611, + 1, 0, 0, 0, 12434, 12435, 5, 651, 0, 0, 12435, 12436, 5, 1206, 0, 0, 12436, + 12437, 3, 926, 463, 0, 12437, 12438, 5, 1207, 0, 0, 12438, 13611, 1, 0, + 0, 0, 12439, 12440, 5, 652, 0, 0, 12440, 12441, 5, 1206, 0, 0, 12441, 12444, + 3, 926, 463, 0, 12442, 12443, 5, 1208, 0, 0, 12443, 12445, 3, 926, 463, + 0, 12444, 12442, 1, 0, 0, 0, 12444, 12445, 1, 0, 0, 0, 12445, 12446, 1, + 0, 0, 0, 12446, 12447, 5, 1207, 0, 0, 12447, 13611, 1, 0, 0, 0, 12448, + 12449, 5, 653, 0, 0, 12449, 12450, 5, 1206, 0, 0, 12450, 12453, 3, 926, + 463, 0, 12451, 12452, 5, 1208, 0, 0, 12452, 12454, 3, 926, 463, 0, 12453, + 12451, 1, 0, 0, 0, 12453, 12454, 1, 0, 0, 0, 12454, 12455, 1, 0, 0, 0, + 12455, 12456, 5, 1207, 0, 0, 12456, 13611, 1, 0, 0, 0, 12457, 12458, 5, + 654, 0, 0, 12458, 12459, 5, 1206, 0, 0, 12459, 12462, 3, 926, 463, 0, 12460, + 12461, 5, 1208, 0, 0, 12461, 12463, 3, 926, 463, 0, 12462, 12460, 1, 0, + 0, 0, 12462, 12463, 1, 0, 0, 0, 12463, 12464, 1, 0, 0, 0, 12464, 12465, + 5, 1207, 0, 0, 12465, 13611, 1, 0, 0, 0, 12466, 12467, 5, 649, 0, 0, 12467, + 12468, 5, 1206, 0, 0, 12468, 12469, 3, 926, 463, 0, 12469, 12470, 5, 1208, + 0, 0, 12470, 12471, 3, 926, 463, 0, 12471, 12472, 5, 1207, 0, 0, 12472, + 13611, 1, 0, 0, 0, 12473, 12474, 5, 650, 0, 0, 12474, 12475, 5, 1206, 0, + 0, 12475, 12476, 3, 926, 463, 0, 12476, 12477, 5, 1208, 0, 0, 12477, 12478, + 3, 926, 463, 0, 12478, 12479, 5, 1207, 0, 0, 12479, 13611, 1, 0, 0, 0, + 12480, 12481, 5, 680, 0, 0, 12481, 12482, 5, 1206, 0, 0, 12482, 13611, + 5, 1207, 0, 0, 12483, 12484, 5, 697, 0, 0, 12484, 12485, 5, 1206, 0, 0, + 12485, 12486, 3, 926, 463, 0, 12486, 12487, 5, 1208, 0, 0, 12487, 12488, + 3, 926, 463, 0, 12488, 12489, 5, 1207, 0, 0, 12489, 13611, 1, 0, 0, 0, + 12490, 12491, 5, 859, 0, 0, 12491, 12493, 5, 1206, 0, 0, 12492, 12494, + 3, 926, 463, 0, 12493, 12492, 1, 0, 0, 0, 12493, 12494, 1, 0, 0, 0, 12494, + 12495, 1, 0, 0, 0, 12495, 13611, 5, 1207, 0, 0, 12496, 12497, 5, 860, 0, + 0, 12497, 12499, 5, 1206, 0, 0, 12498, 12500, 3, 926, 463, 0, 12499, 12498, + 1, 0, 0, 0, 12499, 12500, 1, 0, 0, 0, 12500, 12501, 1, 0, 0, 0, 12501, + 13611, 5, 1207, 0, 0, 12502, 12503, 5, 863, 0, 0, 12503, 12504, 5, 1206, + 0, 0, 12504, 13611, 5, 1207, 0, 0, 12505, 12506, 5, 890, 0, 0, 12506, 12507, + 5, 1206, 0, 0, 12507, 12508, 3, 926, 463, 0, 12508, 12509, 5, 1207, 0, + 0, 12509, 13611, 1, 0, 0, 0, 12510, 12511, 5, 949, 0, 0, 12511, 12512, + 5, 1206, 0, 0, 12512, 12513, 3, 926, 463, 0, 12513, 12514, 5, 1208, 0, + 0, 12514, 12515, 3, 926, 463, 0, 12515, 12516, 5, 1207, 0, 0, 12516, 13611, + 1, 0, 0, 0, 12517, 12518, 5, 1026, 0, 0, 12518, 12519, 5, 1206, 0, 0, 12519, + 12520, 3, 926, 463, 0, 12520, 12521, 5, 1207, 0, 0, 12521, 13611, 1, 0, + 0, 0, 12522, 12523, 5, 1027, 0, 0, 12523, 12524, 5, 1206, 0, 0, 12524, + 12525, 3, 926, 463, 0, 12525, 12526, 5, 1207, 0, 0, 12526, 13611, 1, 0, + 0, 0, 12527, 12528, 5, 1025, 0, 0, 12528, 12529, 5, 1206, 0, 0, 12529, + 12530, 3, 926, 463, 0, 12530, 12531, 5, 1208, 0, 0, 12531, 12532, 3, 926, + 463, 0, 12532, 12533, 5, 1207, 0, 0, 12533, 13611, 1, 0, 0, 0, 12534, 12535, + 5, 58, 0, 0, 12535, 12536, 5, 1206, 0, 0, 12536, 12537, 3, 926, 463, 0, + 12537, 12538, 5, 1207, 0, 0, 12538, 13611, 1, 0, 0, 0, 12539, 12540, 5, + 131, 0, 0, 12540, 12541, 5, 1206, 0, 0, 12541, 12542, 3, 926, 463, 0, 12542, + 12543, 5, 1207, 0, 0, 12543, 13611, 1, 0, 0, 0, 12544, 12545, 5, 132, 0, + 0, 12545, 12546, 5, 1206, 0, 0, 12546, 12547, 3, 926, 463, 0, 12547, 12548, + 5, 1208, 0, 0, 12548, 12551, 3, 926, 463, 0, 12549, 12550, 5, 1208, 0, + 0, 12550, 12552, 3, 926, 463, 0, 12551, 12549, 1, 0, 0, 0, 12551, 12552, + 1, 0, 0, 0, 12552, 12553, 1, 0, 0, 0, 12553, 12554, 5, 1207, 0, 0, 12554, + 13611, 1, 0, 0, 0, 12555, 12556, 5, 172, 0, 0, 12556, 12557, 5, 1206, 0, + 0, 12557, 12558, 3, 926, 463, 0, 12558, 12559, 5, 1208, 0, 0, 12559, 12564, + 3, 926, 463, 0, 12560, 12561, 5, 1208, 0, 0, 12561, 12563, 3, 926, 463, + 0, 12562, 12560, 1, 0, 0, 0, 12563, 12566, 1, 0, 0, 0, 12564, 12562, 1, + 0, 0, 0, 12564, 12565, 1, 0, 0, 0, 12565, 12567, 1, 0, 0, 0, 12566, 12564, + 1, 0, 0, 0, 12567, 12568, 5, 1207, 0, 0, 12568, 13611, 1, 0, 0, 0, 12569, + 12570, 5, 174, 0, 0, 12570, 12571, 5, 1206, 0, 0, 12571, 12572, 3, 926, + 463, 0, 12572, 12573, 5, 1208, 0, 0, 12573, 12574, 3, 926, 463, 0, 12574, + 12575, 5, 1208, 0, 0, 12575, 12580, 3, 926, 463, 0, 12576, 12577, 5, 1208, + 0, 0, 12577, 12579, 3, 926, 463, 0, 12578, 12576, 1, 0, 0, 0, 12579, 12582, + 1, 0, 0, 0, 12580, 12578, 1, 0, 0, 0, 12580, 12581, 1, 0, 0, 0, 12581, + 12583, 1, 0, 0, 0, 12582, 12580, 1, 0, 0, 0, 12583, 12584, 5, 1207, 0, + 0, 12584, 13611, 1, 0, 0, 0, 12585, 12586, 5, 267, 0, 0, 12586, 12587, + 5, 1206, 0, 0, 12587, 12588, 3, 926, 463, 0, 12588, 12589, 5, 1208, 0, + 0, 12589, 12590, 3, 926, 463, 0, 12590, 12591, 5, 1207, 0, 0, 12591, 13611, + 1, 0, 0, 0, 12592, 12593, 5, 374, 0, 0, 12593, 12594, 5, 1206, 0, 0, 12594, + 12595, 3, 926, 463, 0, 12595, 12596, 5, 1208, 0, 0, 12596, 12599, 3, 926, + 463, 0, 12597, 12598, 5, 1208, 0, 0, 12598, 12600, 3, 926, 463, 0, 12599, + 12597, 1, 0, 0, 0, 12599, 12600, 1, 0, 0, 0, 12600, 12601, 1, 0, 0, 0, + 12601, 12602, 5, 1207, 0, 0, 12602, 13611, 1, 0, 0, 0, 12603, 12604, 5, + 511, 0, 0, 12604, 12605, 5, 1206, 0, 0, 12605, 12606, 3, 926, 463, 0, 12606, + 12607, 5, 1208, 0, 0, 12607, 12608, 3, 926, 463, 0, 12608, 12609, 5, 1207, + 0, 0, 12609, 13611, 1, 0, 0, 0, 12610, 12611, 5, 512, 0, 0, 12611, 12612, + 5, 1206, 0, 0, 12612, 12613, 3, 926, 463, 0, 12613, 12614, 5, 1207, 0, + 0, 12614, 13611, 1, 0, 0, 0, 12615, 12616, 5, 541, 0, 0, 12616, 12617, + 5, 1206, 0, 0, 12617, 12618, 3, 926, 463, 0, 12618, 12619, 5, 1207, 0, + 0, 12619, 13611, 1, 0, 0, 0, 12620, 12621, 5, 542, 0, 0, 12621, 12622, + 5, 1206, 0, 0, 12622, 12623, 3, 926, 463, 0, 12623, 12624, 5, 1207, 0, + 0, 12624, 13611, 1, 0, 0, 0, 12625, 12626, 5, 599, 0, 0, 12626, 12627, + 5, 1206, 0, 0, 12627, 12628, 3, 926, 463, 0, 12628, 12629, 5, 1207, 0, + 0, 12629, 13611, 1, 0, 0, 0, 12630, 12631, 5, 705, 0, 0, 12631, 12632, + 5, 1206, 0, 0, 12632, 12633, 3, 926, 463, 0, 12633, 12634, 5, 1208, 0, + 0, 12634, 12635, 3, 926, 463, 0, 12635, 12636, 5, 1207, 0, 0, 12636, 13611, + 1, 0, 0, 0, 12637, 12638, 5, 757, 0, 0, 12638, 12639, 5, 1206, 0, 0, 12639, + 12642, 3, 926, 463, 0, 12640, 12641, 5, 1208, 0, 0, 12641, 12643, 3, 926, + 463, 0, 12642, 12640, 1, 0, 0, 0, 12642, 12643, 1, 0, 0, 0, 12643, 12644, + 1, 0, 0, 0, 12644, 12645, 5, 1207, 0, 0, 12645, 13611, 1, 0, 0, 0, 12646, + 12647, 5, 801, 0, 0, 12647, 12648, 5, 1206, 0, 0, 12648, 12649, 3, 926, + 463, 0, 12649, 12650, 5, 1208, 0, 0, 12650, 12651, 3, 926, 463, 0, 12651, + 12652, 5, 1208, 0, 0, 12652, 12653, 3, 926, 463, 0, 12653, 12654, 5, 1207, + 0, 0, 12654, 13611, 1, 0, 0, 0, 12655, 12656, 5, 803, 0, 0, 12656, 12657, + 5, 1206, 0, 0, 12657, 12658, 3, 926, 463, 0, 12658, 12659, 5, 1208, 0, + 0, 12659, 12660, 3, 926, 463, 0, 12660, 12661, 5, 1207, 0, 0, 12661, 13611, + 1, 0, 0, 0, 12662, 12663, 5, 826, 0, 0, 12663, 12664, 5, 1206, 0, 0, 12664, + 12665, 3, 926, 463, 0, 12665, 12666, 5, 1207, 0, 0, 12666, 13611, 1, 0, + 0, 0, 12667, 12668, 5, 830, 0, 0, 12668, 12669, 5, 1206, 0, 0, 12669, 12670, + 3, 926, 463, 0, 12670, 12671, 5, 1208, 0, 0, 12671, 12672, 3, 926, 463, + 0, 12672, 12673, 5, 1207, 0, 0, 12673, 13611, 1, 0, 0, 0, 12674, 12675, + 5, 850, 0, 0, 12675, 12676, 5, 1206, 0, 0, 12676, 12677, 3, 926, 463, 0, + 12677, 12678, 5, 1207, 0, 0, 12678, 13611, 1, 0, 0, 0, 12679, 12680, 5, + 925, 0, 0, 12680, 12681, 5, 1206, 0, 0, 12681, 12682, 3, 926, 463, 0, 12682, + 12683, 5, 1207, 0, 0, 12683, 13611, 1, 0, 0, 0, 12684, 12685, 5, 927, 0, + 0, 12685, 12686, 5, 1206, 0, 0, 12686, 12687, 3, 926, 463, 0, 12687, 12688, + 5, 1207, 0, 0, 12688, 13611, 1, 0, 0, 0, 12689, 12690, 5, 959, 0, 0, 12690, + 12691, 5, 1206, 0, 0, 12691, 12698, 3, 926, 463, 0, 12692, 12693, 5, 1208, + 0, 0, 12693, 12696, 3, 926, 463, 0, 12694, 12695, 5, 1208, 0, 0, 12695, + 12697, 3, 926, 463, 0, 12696, 12694, 1, 0, 0, 0, 12696, 12697, 1, 0, 0, + 0, 12697, 12699, 1, 0, 0, 0, 12698, 12692, 1, 0, 0, 0, 12698, 12699, 1, + 0, 0, 0, 12699, 12700, 1, 0, 0, 0, 12700, 12701, 5, 1207, 0, 0, 12701, + 13611, 1, 0, 0, 0, 12702, 12703, 5, 960, 0, 0, 12703, 12704, 5, 1206, 0, + 0, 12704, 12705, 3, 926, 463, 0, 12705, 12706, 5, 1208, 0, 0, 12706, 12707, + 3, 926, 463, 0, 12707, 12714, 5, 1207, 0, 0, 12708, 12709, 5, 1078, 0, + 0, 12709, 12710, 5, 412, 0, 0, 12710, 12711, 5, 1206, 0, 0, 12711, 12712, + 3, 972, 486, 0, 12712, 12713, 5, 1207, 0, 0, 12713, 12715, 1, 0, 0, 0, + 12714, 12708, 1, 0, 0, 0, 12714, 12715, 1, 0, 0, 0, 12715, 13611, 1, 0, + 0, 0, 12716, 12717, 5, 961, 0, 0, 12717, 12718, 5, 1206, 0, 0, 12718, 12719, + 3, 926, 463, 0, 12719, 12720, 5, 1208, 0, 0, 12720, 12721, 3, 926, 463, + 0, 12721, 12722, 5, 1207, 0, 0, 12722, 13611, 1, 0, 0, 0, 12723, 12724, + 5, 962, 0, 0, 12724, 12725, 5, 1206, 0, 0, 12725, 12726, 3, 926, 463, 0, + 12726, 12727, 5, 1208, 0, 0, 12727, 12728, 3, 926, 463, 0, 12728, 12729, + 5, 1208, 0, 0, 12729, 12730, 3, 926, 463, 0, 12730, 12731, 5, 1208, 0, + 0, 12731, 12732, 3, 926, 463, 0, 12732, 12733, 5, 1207, 0, 0, 12733, 13611, + 1, 0, 0, 0, 12734, 12735, 5, 966, 0, 0, 12735, 12736, 5, 1206, 0, 0, 12736, + 12737, 3, 926, 463, 0, 12737, 12738, 5, 1208, 0, 0, 12738, 12739, 3, 926, + 463, 0, 12739, 12740, 5, 1208, 0, 0, 12740, 12741, 3, 926, 463, 0, 12741, + 12742, 5, 1207, 0, 0, 12742, 13611, 1, 0, 0, 0, 12743, 12744, 5, 1012, + 0, 0, 12744, 12745, 5, 1206, 0, 0, 12745, 12746, 3, 926, 463, 0, 12746, + 12747, 5, 1208, 0, 0, 12747, 12748, 3, 926, 463, 0, 12748, 12749, 5, 1208, + 0, 0, 12749, 12750, 3, 926, 463, 0, 12750, 12751, 5, 1207, 0, 0, 12751, + 13611, 1, 0, 0, 0, 12752, 12753, 5, 1014, 0, 0, 12753, 12757, 5, 1206, + 0, 0, 12754, 12755, 3, 926, 463, 0, 12755, 12756, 5, 380, 0, 0, 12756, + 12758, 1, 0, 0, 0, 12757, 12754, 1, 0, 0, 0, 12757, 12758, 1, 0, 0, 0, + 12758, 12759, 1, 0, 0, 0, 12759, 12760, 3, 926, 463, 0, 12760, 12761, 5, + 1207, 0, 0, 12761, 13611, 1, 0, 0, 0, 12762, 12763, 5, 1032, 0, 0, 12763, + 12764, 5, 1206, 0, 0, 12764, 12765, 3, 926, 463, 0, 12765, 12766, 5, 1207, + 0, 0, 12766, 13611, 1, 0, 0, 0, 12767, 12768, 5, 1045, 0, 0, 12768, 12769, + 5, 1206, 0, 0, 12769, 12770, 3, 926, 463, 0, 12770, 12771, 5, 1207, 0, + 0, 12771, 13611, 1, 0, 0, 0, 12772, 12773, 5, 94, 0, 0, 12773, 12783, 5, + 1206, 0, 0, 12774, 12784, 5, 1212, 0, 0, 12775, 12780, 3, 926, 463, 0, + 12776, 12777, 5, 1208, 0, 0, 12777, 12779, 3, 926, 463, 0, 12778, 12776, + 1, 0, 0, 0, 12779, 12782, 1, 0, 0, 0, 12780, 12778, 1, 0, 0, 0, 12780, + 12781, 1, 0, 0, 0, 12781, 12784, 1, 0, 0, 0, 12782, 12780, 1, 0, 0, 0, + 12783, 12774, 1, 0, 0, 0, 12783, 12775, 1, 0, 0, 0, 12784, 12785, 1, 0, + 0, 0, 12785, 13611, 5, 1207, 0, 0, 12786, 12787, 5, 140, 0, 0, 12787, 12797, + 5, 1206, 0, 0, 12788, 12798, 5, 1212, 0, 0, 12789, 12794, 3, 926, 463, + 0, 12790, 12791, 5, 1208, 0, 0, 12791, 12793, 3, 926, 463, 0, 12792, 12790, + 1, 0, 0, 0, 12793, 12796, 1, 0, 0, 0, 12794, 12792, 1, 0, 0, 0, 12794, + 12795, 1, 0, 0, 0, 12795, 12798, 1, 0, 0, 0, 12796, 12794, 1, 0, 0, 0, + 12797, 12788, 1, 0, 0, 0, 12797, 12789, 1, 0, 0, 0, 12798, 12799, 1, 0, + 0, 0, 12799, 13611, 5, 1207, 0, 0, 12800, 12801, 5, 167, 0, 0, 12801, 12802, + 5, 1206, 0, 0, 12802, 12803, 3, 926, 463, 0, 12803, 12804, 5, 1207, 0, + 0, 12804, 13611, 1, 0, 0, 0, 12805, 12806, 5, 178, 0, 0, 12806, 12807, + 5, 1206, 0, 0, 12807, 12808, 5, 1184, 0, 0, 12808, 13611, 5, 1207, 0, 0, + 12809, 12810, 5, 185, 0, 0, 12810, 12811, 5, 1206, 0, 0, 12811, 13611, + 5, 1207, 0, 0, 12812, 12813, 5, 208, 0, 0, 12813, 12814, 5, 1206, 0, 0, + 12814, 13611, 5, 1207, 0, 0, 12815, 12816, 5, 211, 0, 0, 12816, 12817, + 5, 1206, 0, 0, 12817, 13611, 5, 1207, 0, 0, 12818, 12819, 5, 243, 0, 0, + 12819, 12820, 5, 1206, 0, 0, 12820, 12821, 3, 926, 463, 0, 12821, 12822, + 5, 1207, 0, 0, 12822, 13611, 1, 0, 0, 0, 12823, 12824, 5, 305, 0, 0, 12824, + 12825, 5, 1206, 0, 0, 12825, 13611, 5, 1207, 0, 0, 12826, 12827, 5, 306, + 0, 0, 12827, 12828, 5, 1206, 0, 0, 12828, 13611, 5, 1207, 0, 0, 12829, + 12830, 5, 307, 0, 0, 12830, 12831, 5, 1206, 0, 0, 12831, 13611, 5, 1207, + 0, 0, 12832, 12833, 5, 308, 0, 0, 12833, 12834, 5, 1206, 0, 0, 12834, 13611, + 5, 1207, 0, 0, 12835, 12836, 5, 309, 0, 0, 12836, 12837, 5, 1206, 0, 0, + 12837, 13611, 5, 1207, 0, 0, 12838, 12839, 5, 310, 0, 0, 12839, 12840, + 5, 1206, 0, 0, 12840, 13611, 5, 1207, 0, 0, 12841, 12842, 5, 375, 0, 0, + 12842, 12846, 5, 1206, 0, 0, 12843, 12847, 5, 1182, 0, 0, 12844, 12847, + 5, 1184, 0, 0, 12845, 12847, 5, 1180, 0, 0, 12846, 12843, 1, 0, 0, 0, 12846, + 12844, 1, 0, 0, 0, 12846, 12845, 1, 0, 0, 0, 12847, 12848, 1, 0, 0, 0, + 12848, 12849, 5, 1208, 0, 0, 12849, 12854, 3, 926, 463, 0, 12850, 12851, + 5, 1208, 0, 0, 12851, 12853, 3, 926, 463, 0, 12852, 12850, 1, 0, 0, 0, + 12853, 12856, 1, 0, 0, 0, 12854, 12852, 1, 0, 0, 0, 12854, 12855, 1, 0, + 0, 0, 12855, 12857, 1, 0, 0, 0, 12856, 12854, 1, 0, 0, 0, 12857, 12858, + 5, 1207, 0, 0, 12858, 13611, 1, 0, 0, 0, 12859, 12860, 5, 405, 0, 0, 12860, + 12861, 5, 1206, 0, 0, 12861, 13611, 5, 1207, 0, 0, 12862, 12863, 5, 398, + 0, 0, 12863, 12865, 5, 1206, 0, 0, 12864, 12866, 5, 1184, 0, 0, 12865, + 12864, 1, 0, 0, 0, 12865, 12866, 1, 0, 0, 0, 12866, 12867, 1, 0, 0, 0, + 12867, 13611, 5, 1207, 0, 0, 12868, 12869, 5, 430, 0, 0, 12869, 12870, + 5, 1206, 0, 0, 12870, 13611, 5, 1207, 0, 0, 12871, 12872, 5, 431, 0, 0, + 12872, 12873, 5, 1206, 0, 0, 12873, 13611, 5, 1207, 0, 0, 12874, 12875, + 5, 477, 0, 0, 12875, 12876, 5, 1206, 0, 0, 12876, 12877, 3, 926, 463, 0, + 12877, 12878, 5, 1208, 0, 0, 12878, 12879, 3, 926, 463, 0, 12879, 12880, + 5, 1207, 0, 0, 12880, 13611, 1, 0, 0, 0, 12881, 12882, 5, 478, 0, 0, 12882, + 12883, 5, 1206, 0, 0, 12883, 12884, 3, 926, 463, 0, 12884, 12885, 5, 1207, + 0, 0, 12885, 13611, 1, 0, 0, 0, 12886, 12887, 5, 584, 0, 0, 12887, 12888, + 5, 1206, 0, 0, 12888, 13611, 5, 1207, 0, 0, 12889, 12890, 5, 602, 0, 0, + 12890, 12891, 5, 1206, 0, 0, 12891, 13611, 5, 1207, 0, 0, 12892, 12893, + 5, 604, 0, 0, 12893, 12894, 5, 1206, 0, 0, 12894, 13611, 5, 1207, 0, 0, + 12895, 12896, 5, 839, 0, 0, 12896, 12897, 5, 1206, 0, 0, 12897, 13611, + 5, 1207, 0, 0, 12898, 12899, 5, 897, 0, 0, 12899, 12900, 5, 1206, 0, 0, + 12900, 12901, 5, 1184, 0, 0, 12901, 13611, 5, 1207, 0, 0, 12902, 12903, + 5, 1086, 0, 0, 12903, 12904, 5, 1206, 0, 0, 12904, 13611, 5, 1207, 0, 0, + 12905, 12906, 5, 118, 0, 0, 12906, 12907, 5, 1206, 0, 0, 12907, 12908, + 3, 926, 463, 0, 12908, 12909, 5, 56, 0, 0, 12909, 12910, 3, 1222, 611, + 0, 12910, 12911, 5, 1207, 0, 0, 12911, 13611, 1, 0, 0, 0, 12912, 12913, + 5, 1020, 0, 0, 12913, 12914, 5, 1206, 0, 0, 12914, 12915, 3, 926, 463, + 0, 12915, 12916, 5, 56, 0, 0, 12916, 12917, 3, 1222, 611, 0, 12917, 12918, + 5, 1207, 0, 0, 12918, 13611, 1, 0, 0, 0, 12919, 12920, 5, 192, 0, 0, 12920, + 12921, 5, 1206, 0, 0, 12921, 12922, 3, 1222, 611, 0, 12922, 12923, 5, 1208, + 0, 0, 12923, 12926, 3, 926, 463, 0, 12924, 12925, 5, 1208, 0, 0, 12925, + 12927, 3, 926, 463, 0, 12926, 12924, 1, 0, 0, 0, 12926, 12927, 1, 0, 0, + 0, 12927, 12928, 1, 0, 0, 0, 12928, 12929, 5, 1207, 0, 0, 12929, 13611, + 1, 0, 0, 0, 12930, 12931, 5, 152, 0, 0, 12931, 12932, 5, 1206, 0, 0, 12932, + 12933, 3, 1126, 563, 0, 12933, 12934, 5, 1207, 0, 0, 12934, 13611, 1, 0, + 0, 0, 12935, 13611, 5, 1170, 0, 0, 12936, 13611, 5, 1171, 0, 0, 12937, + 12938, 5, 216, 0, 0, 12938, 12939, 5, 1206, 0, 0, 12939, 12940, 5, 1184, + 0, 0, 12940, 12941, 5, 1208, 0, 0, 12941, 12942, 3, 926, 463, 0, 12942, + 12943, 5, 1207, 0, 0, 12943, 13611, 1, 0, 0, 0, 12944, 12945, 5, 125, 0, + 0, 12945, 12946, 5, 1206, 0, 0, 12946, 12947, 3, 926, 463, 0, 12947, 12948, + 5, 1207, 0, 0, 12948, 13611, 1, 0, 0, 0, 12949, 12950, 5, 223, 0, 0, 12950, + 12951, 5, 1206, 0, 0, 12951, 12952, 3, 926, 463, 0, 12952, 12953, 5, 1207, + 0, 0, 12953, 13611, 1, 0, 0, 0, 12954, 12955, 5, 437, 0, 0, 12955, 12956, + 5, 1206, 0, 0, 12956, 12957, 3, 926, 463, 0, 12957, 12958, 5, 1207, 0, + 0, 12958, 13611, 1, 0, 0, 0, 12959, 12960, 5, 438, 0, 0, 12960, 12961, + 5, 1206, 0, 0, 12961, 12962, 3, 926, 463, 0, 12962, 12963, 5, 1207, 0, + 0, 12963, 13611, 1, 0, 0, 0, 12964, 12965, 5, 439, 0, 0, 12965, 12966, + 5, 1206, 0, 0, 12966, 12967, 3, 926, 463, 0, 12967, 12968, 5, 1207, 0, + 0, 12968, 13611, 1, 0, 0, 0, 12969, 12970, 5, 433, 0, 0, 12970, 12971, + 5, 1206, 0, 0, 12971, 12976, 3, 1222, 611, 0, 12972, 12973, 5, 1208, 0, + 0, 12973, 12974, 5, 1182, 0, 0, 12974, 12975, 5, 1208, 0, 0, 12975, 12977, + 5, 1182, 0, 0, 12976, 12972, 1, 0, 0, 0, 12976, 12977, 1, 0, 0, 0, 12977, + 12978, 1, 0, 0, 0, 12978, 12979, 5, 1207, 0, 0, 12979, 13611, 1, 0, 0, + 0, 12980, 12981, 5, 937, 0, 0, 12981, 12982, 5, 1206, 0, 0, 12982, 12983, + 3, 926, 463, 0, 12983, 12984, 5, 1208, 0, 0, 12984, 12985, 5, 1184, 0, + 0, 12985, 12986, 5, 1207, 0, 0, 12986, 13611, 1, 0, 0, 0, 12987, 12988, + 5, 207, 0, 0, 12988, 12989, 5, 1206, 0, 0, 12989, 13611, 5, 1207, 0, 0, + 12990, 13611, 5, 210, 0, 0, 12991, 12992, 5, 1117, 0, 0, 12992, 12993, + 5, 1206, 0, 0, 12993, 13611, 5, 1207, 0, 0, 12994, 12995, 5, 1118, 0, 0, + 12995, 12996, 5, 1206, 0, 0, 12996, 13611, 5, 1207, 0, 0, 12997, 12998, + 5, 1119, 0, 0, 12998, 12999, 5, 1206, 0, 0, 12999, 13000, 3, 1068, 534, + 0, 13000, 13001, 5, 1208, 0, 0, 13001, 13002, 3, 926, 463, 0, 13002, 13003, + 5, 1208, 0, 0, 13003, 13006, 3, 926, 463, 0, 13004, 13005, 5, 1208, 0, + 0, 13005, 13007, 3, 926, 463, 0, 13006, 13004, 1, 0, 0, 0, 13006, 13007, + 1, 0, 0, 0, 13007, 13008, 1, 0, 0, 0, 13008, 13009, 5, 1207, 0, 0, 13009, + 13611, 1, 0, 0, 0, 13010, 13011, 5, 228, 0, 0, 13011, 13012, 5, 1206, 0, + 0, 13012, 13013, 3, 1070, 535, 0, 13013, 13014, 5, 1208, 0, 0, 13014, 13015, + 3, 926, 463, 0, 13015, 13016, 5, 1208, 0, 0, 13016, 13017, 3, 926, 463, + 0, 13017, 13018, 5, 1207, 0, 0, 13018, 13611, 1, 0, 0, 0, 13019, 13020, + 5, 229, 0, 0, 13020, 13021, 5, 1206, 0, 0, 13021, 13022, 3, 1070, 535, + 0, 13022, 13023, 5, 1208, 0, 0, 13023, 13024, 3, 926, 463, 0, 13024, 13025, + 5, 1208, 0, 0, 13025, 13026, 3, 926, 463, 0, 13026, 13027, 5, 1207, 0, + 0, 13027, 13611, 1, 0, 0, 0, 13028, 13029, 5, 1120, 0, 0, 13029, 13030, + 5, 1206, 0, 0, 13030, 13031, 3, 1070, 535, 0, 13031, 13032, 5, 1208, 0, + 0, 13032, 13033, 3, 926, 463, 0, 13033, 13034, 5, 1208, 0, 0, 13034, 13035, + 3, 926, 463, 0, 13035, 13036, 5, 1207, 0, 0, 13036, 13611, 1, 0, 0, 0, + 13037, 13038, 5, 1121, 0, 0, 13038, 13039, 5, 1206, 0, 0, 13039, 13040, + 3, 926, 463, 0, 13040, 13041, 5, 1208, 0, 0, 13041, 13042, 3, 926, 463, + 0, 13042, 13043, 5, 1208, 0, 0, 13043, 13044, 3, 926, 463, 0, 13044, 13045, + 5, 1207, 0, 0, 13045, 13611, 1, 0, 0, 0, 13046, 13047, 5, 230, 0, 0, 13047, + 13048, 5, 1206, 0, 0, 13048, 13049, 3, 1072, 536, 0, 13049, 13050, 5, 1208, + 0, 0, 13050, 13051, 3, 926, 463, 0, 13051, 13052, 5, 1207, 0, 0, 13052, + 13611, 1, 0, 0, 0, 13053, 13054, 5, 231, 0, 0, 13054, 13055, 5, 1206, 0, + 0, 13055, 13056, 3, 1072, 536, 0, 13056, 13057, 5, 1208, 0, 0, 13057, 13058, + 3, 926, 463, 0, 13058, 13059, 5, 1207, 0, 0, 13059, 13611, 1, 0, 0, 0, + 13060, 13061, 5, 1122, 0, 0, 13061, 13062, 5, 1206, 0, 0, 13062, 13063, + 3, 926, 463, 0, 13063, 13064, 5, 1208, 0, 0, 13064, 13065, 3, 926, 463, + 0, 13065, 13066, 5, 1208, 0, 0, 13066, 13067, 3, 926, 463, 0, 13067, 13068, + 5, 1208, 0, 0, 13068, 13069, 3, 926, 463, 0, 13069, 13070, 5, 1208, 0, + 0, 13070, 13071, 3, 926, 463, 0, 13071, 13072, 5, 1208, 0, 0, 13072, 13073, + 3, 926, 463, 0, 13073, 13074, 5, 1208, 0, 0, 13074, 13075, 3, 926, 463, + 0, 13075, 13076, 5, 1208, 0, 0, 13076, 13077, 3, 926, 463, 0, 13077, 13078, + 5, 1207, 0, 0, 13078, 13611, 1, 0, 0, 0, 13079, 13080, 5, 1123, 0, 0, 13080, + 13081, 5, 1206, 0, 0, 13081, 13082, 3, 926, 463, 0, 13082, 13083, 5, 1208, + 0, 0, 13083, 13084, 3, 926, 463, 0, 13084, 13085, 5, 1208, 0, 0, 13085, + 13086, 3, 926, 463, 0, 13086, 13087, 5, 1208, 0, 0, 13087, 13088, 3, 926, + 463, 0, 13088, 13089, 5, 1208, 0, 0, 13089, 13090, 3, 926, 463, 0, 13090, + 13091, 5, 1208, 0, 0, 13091, 13092, 3, 926, 463, 0, 13092, 13093, 5, 1208, + 0, 0, 13093, 13094, 3, 926, 463, 0, 13094, 13095, 5, 1207, 0, 0, 13095, + 13611, 1, 0, 0, 0, 13096, 13097, 5, 1124, 0, 0, 13097, 13098, 5, 1206, + 0, 0, 13098, 13099, 3, 926, 463, 0, 13099, 13100, 5, 1208, 0, 0, 13100, + 13101, 3, 926, 463, 0, 13101, 13102, 5, 1208, 0, 0, 13102, 13103, 3, 926, + 463, 0, 13103, 13104, 5, 1208, 0, 0, 13104, 13105, 3, 926, 463, 0, 13105, + 13106, 5, 1208, 0, 0, 13106, 13107, 3, 926, 463, 0, 13107, 13108, 5, 1208, + 0, 0, 13108, 13109, 3, 926, 463, 0, 13109, 13110, 5, 1208, 0, 0, 13110, + 13111, 3, 926, 463, 0, 13111, 13112, 5, 1208, 0, 0, 13112, 13113, 3, 926, + 463, 0, 13113, 13114, 5, 1208, 0, 0, 13114, 13115, 3, 926, 463, 0, 13115, + 13116, 5, 1208, 0, 0, 13116, 13117, 5, 1182, 0, 0, 13117, 13118, 5, 1207, + 0, 0, 13118, 13611, 1, 0, 0, 0, 13119, 13120, 5, 1125, 0, 0, 13120, 13121, + 5, 1206, 0, 0, 13121, 13122, 3, 1074, 537, 0, 13122, 13123, 5, 1208, 0, + 0, 13123, 13124, 3, 926, 463, 0, 13124, 13125, 5, 1207, 0, 0, 13125, 13611, + 1, 0, 0, 0, 13126, 13127, 5, 1126, 0, 0, 13127, 13128, 5, 1206, 0, 0, 13128, + 13129, 3, 926, 463, 0, 13129, 13130, 5, 1207, 0, 0, 13130, 13611, 1, 0, + 0, 0, 13131, 13132, 5, 1127, 0, 0, 13132, 13133, 5, 1206, 0, 0, 13133, + 13136, 3, 926, 463, 0, 13134, 13135, 5, 1208, 0, 0, 13135, 13137, 3, 926, + 463, 0, 13136, 13134, 1, 0, 0, 0, 13136, 13137, 1, 0, 0, 0, 13137, 13138, + 1, 0, 0, 0, 13138, 13139, 5, 1207, 0, 0, 13139, 13611, 1, 0, 0, 0, 13140, + 13141, 5, 399, 0, 0, 13141, 13142, 5, 1206, 0, 0, 13142, 13611, 5, 1207, + 0, 0, 13143, 13144, 5, 404, 0, 0, 13144, 13145, 5, 1206, 0, 0, 13145, 13611, + 5, 1207, 0, 0, 13146, 13147, 5, 1128, 0, 0, 13147, 13148, 5, 1206, 0, 0, + 13148, 13149, 3, 926, 463, 0, 13149, 13150, 5, 1207, 0, 0, 13150, 13611, + 1, 0, 0, 0, 13151, 13152, 5, 1129, 0, 0, 13152, 13153, 5, 1206, 0, 0, 13153, + 13154, 3, 926, 463, 0, 13154, 13155, 5, 1207, 0, 0, 13155, 13611, 1, 0, + 0, 0, 13156, 13157, 5, 1130, 0, 0, 13157, 13158, 5, 1206, 0, 0, 13158, + 13159, 3, 926, 463, 0, 13159, 13160, 5, 1208, 0, 0, 13160, 13161, 3, 926, + 463, 0, 13161, 13162, 5, 1208, 0, 0, 13162, 13163, 3, 926, 463, 0, 13163, + 13164, 5, 1208, 0, 0, 13164, 13165, 3, 926, 463, 0, 13165, 13166, 5, 1208, + 0, 0, 13166, 13167, 3, 926, 463, 0, 13167, 13168, 5, 1207, 0, 0, 13168, + 13611, 1, 0, 0, 0, 13169, 13170, 5, 1131, 0, 0, 13170, 13171, 5, 1206, + 0, 0, 13171, 13172, 3, 926, 463, 0, 13172, 13173, 5, 1208, 0, 0, 13173, + 13174, 3, 926, 463, 0, 13174, 13175, 5, 1207, 0, 0, 13175, 13611, 1, 0, + 0, 0, 13176, 13177, 5, 1132, 0, 0, 13177, 13178, 5, 1206, 0, 0, 13178, + 13611, 5, 1207, 0, 0, 13179, 13180, 5, 1133, 0, 0, 13180, 13181, 5, 1206, + 0, 0, 13181, 13611, 5, 1207, 0, 0, 13182, 13183, 5, 1134, 0, 0, 13183, + 13184, 5, 1206, 0, 0, 13184, 13611, 5, 1207, 0, 0, 13185, 13186, 5, 1135, + 0, 0, 13186, 13187, 5, 1206, 0, 0, 13187, 13188, 3, 926, 463, 0, 13188, + 13189, 5, 1208, 0, 0, 13189, 13190, 3, 926, 463, 0, 13190, 13191, 5, 1208, + 0, 0, 13191, 13192, 3, 926, 463, 0, 13192, 13193, 5, 1208, 0, 0, 13193, + 13194, 3, 926, 463, 0, 13194, 13195, 5, 1208, 0, 0, 13195, 13196, 5, 1182, + 0, 0, 13196, 13197, 5, 1207, 0, 0, 13197, 13611, 1, 0, 0, 0, 13198, 13199, + 5, 1136, 0, 0, 13199, 13200, 5, 1206, 0, 0, 13200, 13201, 3, 926, 463, + 0, 13201, 13202, 5, 1208, 0, 0, 13202, 13203, 3, 926, 463, 0, 13203, 13204, + 5, 1207, 0, 0, 13204, 13611, 1, 0, 0, 0, 13205, 13206, 5, 1137, 0, 0, 13206, + 13207, 5, 1206, 0, 0, 13207, 13208, 3, 926, 463, 0, 13208, 13209, 5, 1207, + 0, 0, 13209, 13611, 1, 0, 0, 0, 13210, 13211, 5, 433, 0, 0, 13211, 13212, + 5, 1206, 0, 0, 13212, 13215, 3, 1222, 611, 0, 13213, 13214, 5, 1208, 0, + 0, 13214, 13216, 5, 1182, 0, 0, 13215, 13213, 1, 0, 0, 0, 13215, 13216, + 1, 0, 0, 0, 13216, 13219, 1, 0, 0, 0, 13217, 13218, 5, 1208, 0, 0, 13218, + 13220, 5, 1182, 0, 0, 13219, 13217, 1, 0, 0, 0, 13219, 13220, 1, 0, 0, + 0, 13220, 13221, 1, 0, 0, 0, 13221, 13222, 5, 1207, 0, 0, 13222, 13611, + 1, 0, 0, 0, 13223, 13224, 5, 584, 0, 0, 13224, 13225, 5, 1206, 0, 0, 13225, + 13611, 5, 1207, 0, 0, 13226, 13227, 5, 642, 0, 0, 13227, 13228, 5, 1206, + 0, 0, 13228, 13229, 3, 926, 463, 0, 13229, 13230, 5, 1208, 0, 0, 13230, + 13231, 3, 926, 463, 0, 13231, 13232, 5, 1207, 0, 0, 13232, 13611, 1, 0, + 0, 0, 13233, 13234, 5, 696, 0, 0, 13234, 13235, 5, 1206, 0, 0, 13235, 13236, + 3, 926, 463, 0, 13236, 13237, 5, 56, 0, 0, 13237, 13240, 3, 1222, 611, + 0, 13238, 13239, 5, 1052, 0, 0, 13239, 13241, 3, 926, 463, 0, 13240, 13238, + 1, 0, 0, 0, 13240, 13241, 1, 0, 0, 0, 13241, 13242, 1, 0, 0, 0, 13242, + 13243, 5, 1207, 0, 0, 13243, 13611, 1, 0, 0, 0, 13244, 13611, 3, 1066, + 533, 0, 13245, 13246, 5, 446, 0, 0, 13246, 13247, 5, 1206, 0, 0, 13247, + 13248, 3, 950, 475, 0, 13248, 13249, 5, 1208, 0, 0, 13249, 13250, 3, 926, + 463, 0, 13250, 13251, 5, 1208, 0, 0, 13251, 13252, 3, 926, 463, 0, 13252, + 13253, 5, 1207, 0, 0, 13253, 13611, 1, 0, 0, 0, 13254, 13255, 5, 476, 0, + 0, 13255, 13256, 5, 1206, 0, 0, 13256, 13259, 3, 926, 463, 0, 13257, 13258, + 5, 1208, 0, 0, 13258, 13260, 3, 926, 463, 0, 13259, 13257, 1, 0, 0, 0, + 13259, 13260, 1, 0, 0, 0, 13260, 13261, 1, 0, 0, 0, 13261, 13262, 5, 1207, + 0, 0, 13262, 13611, 1, 0, 0, 0, 13263, 13264, 5, 488, 0, 0, 13264, 13273, + 5, 1206, 0, 0, 13265, 13270, 3, 1060, 530, 0, 13266, 13267, 5, 1208, 0, + 0, 13267, 13269, 3, 1060, 530, 0, 13268, 13266, 1, 0, 0, 0, 13269, 13272, + 1, 0, 0, 0, 13270, 13268, 1, 0, 0, 0, 13270, 13271, 1, 0, 0, 0, 13271, + 13274, 1, 0, 0, 0, 13272, 13270, 1, 0, 0, 0, 13273, 13265, 1, 0, 0, 0, + 13273, 13274, 1, 0, 0, 0, 13274, 13276, 1, 0, 0, 0, 13275, 13277, 3, 1062, + 531, 0, 13276, 13275, 1, 0, 0, 0, 13276, 13277, 1, 0, 0, 0, 13277, 13278, + 1, 0, 0, 0, 13278, 13611, 5, 1207, 0, 0, 13279, 13280, 5, 486, 0, 0, 13280, + 13282, 5, 1206, 0, 0, 13281, 13283, 3, 1126, 563, 0, 13282, 13281, 1, 0, + 0, 0, 13282, 13283, 1, 0, 0, 0, 13283, 13285, 1, 0, 0, 0, 13284, 13286, + 3, 1062, 531, 0, 13285, 13284, 1, 0, 0, 0, 13285, 13286, 1, 0, 0, 0, 13286, + 13287, 1, 0, 0, 0, 13287, 13611, 5, 1207, 0, 0, 13288, 13289, 5, 491, 0, + 0, 13289, 13290, 5, 1206, 0, 0, 13290, 13291, 3, 926, 463, 0, 13291, 13292, + 5, 1208, 0, 0, 13292, 13293, 3, 926, 463, 0, 13293, 13294, 5, 1207, 0, + 0, 13294, 13611, 1, 0, 0, 0, 13295, 13296, 5, 490, 0, 0, 13296, 13297, + 5, 1206, 0, 0, 13297, 13300, 3, 926, 463, 0, 13298, 13299, 5, 1208, 0, + 0, 13299, 13301, 3, 926, 463, 0, 13300, 13298, 1, 0, 0, 0, 13300, 13301, + 1, 0, 0, 0, 13301, 13302, 1, 0, 0, 0, 13302, 13303, 5, 1207, 0, 0, 13303, + 13611, 1, 0, 0, 0, 13304, 13305, 5, 487, 0, 0, 13305, 13306, 5, 1206, 0, + 0, 13306, 13307, 3, 926, 463, 0, 13307, 13308, 5, 1208, 0, 0, 13308, 13309, + 3, 926, 463, 0, 13309, 13310, 5, 1208, 0, 0, 13310, 13311, 3, 926, 463, + 0, 13311, 13312, 5, 1207, 0, 0, 13312, 13611, 1, 0, 0, 0, 13313, 13314, + 5, 489, 0, 0, 13314, 13315, 5, 1206, 0, 0, 13315, 13316, 3, 926, 463, 0, + 13316, 13317, 5, 1208, 0, 0, 13317, 13318, 3, 926, 463, 0, 13318, 13319, + 5, 1207, 0, 0, 13319, 13611, 1, 0, 0, 0, 13320, 13321, 5, 1095, 0, 0, 13321, + 13322, 5, 1206, 0, 0, 13322, 13323, 3, 926, 463, 0, 13323, 13324, 5, 1207, + 0, 0, 13324, 13611, 1, 0, 0, 0, 13325, 13326, 5, 1096, 0, 0, 13326, 13327, + 5, 1206, 0, 0, 13327, 13328, 3, 926, 463, 0, 13328, 13329, 5, 1207, 0, + 0, 13329, 13611, 1, 0, 0, 0, 13330, 13331, 5, 1097, 0, 0, 13331, 13332, + 5, 1206, 0, 0, 13332, 13333, 3, 926, 463, 0, 13333, 13334, 5, 1207, 0, + 0, 13334, 13611, 1, 0, 0, 0, 13335, 13336, 5, 1098, 0, 0, 13336, 13337, + 5, 1206, 0, 0, 13337, 13338, 3, 926, 463, 0, 13338, 13339, 5, 1207, 0, + 0, 13339, 13611, 1, 0, 0, 0, 13340, 13341, 5, 1099, 0, 0, 13341, 13342, + 5, 1206, 0, 0, 13342, 13343, 3, 926, 463, 0, 13343, 13344, 5, 1208, 0, + 0, 13344, 13345, 3, 926, 463, 0, 13345, 13346, 5, 1207, 0, 0, 13346, 13611, + 1, 0, 0, 0, 13347, 13348, 5, 1100, 0, 0, 13348, 13349, 5, 1206, 0, 0, 13349, + 13350, 3, 926, 463, 0, 13350, 13351, 5, 1207, 0, 0, 13351, 13611, 1, 0, + 0, 0, 13352, 13353, 5, 1101, 0, 0, 13353, 13354, 5, 1206, 0, 0, 13354, + 13355, 3, 926, 463, 0, 13355, 13356, 5, 1207, 0, 0, 13356, 13611, 1, 0, + 0, 0, 13357, 13358, 5, 1102, 0, 0, 13358, 13359, 5, 1206, 0, 0, 13359, + 13360, 3, 926, 463, 0, 13360, 13361, 5, 1207, 0, 0, 13361, 13611, 1, 0, + 0, 0, 13362, 13363, 5, 1103, 0, 0, 13363, 13364, 5, 1206, 0, 0, 13364, + 13365, 3, 926, 463, 0, 13365, 13366, 5, 1207, 0, 0, 13366, 13611, 1, 0, + 0, 0, 13367, 13368, 5, 1104, 0, 0, 13368, 13369, 5, 1206, 0, 0, 13369, + 13370, 3, 926, 463, 0, 13370, 13371, 5, 1207, 0, 0, 13371, 13611, 1, 0, + 0, 0, 13372, 13373, 5, 1105, 0, 0, 13373, 13374, 5, 1206, 0, 0, 13374, + 13375, 3, 926, 463, 0, 13375, 13376, 5, 1207, 0, 0, 13376, 13611, 1, 0, + 0, 0, 13377, 13378, 5, 536, 0, 0, 13378, 13379, 5, 1206, 0, 0, 13379, 13382, + 3, 926, 463, 0, 13380, 13381, 5, 1208, 0, 0, 13381, 13383, 3, 926, 463, + 0, 13382, 13380, 1, 0, 0, 0, 13382, 13383, 1, 0, 0, 0, 13383, 13384, 1, + 0, 0, 0, 13384, 13385, 5, 1207, 0, 0, 13385, 13611, 1, 0, 0, 0, 13386, + 13387, 5, 1106, 0, 0, 13387, 13388, 5, 1206, 0, 0, 13388, 13389, 3, 926, + 463, 0, 13389, 13390, 5, 1207, 0, 0, 13390, 13611, 1, 0, 0, 0, 13391, 13392, + 5, 1107, 0, 0, 13392, 13393, 5, 1206, 0, 0, 13393, 13611, 5, 1207, 0, 0, + 13394, 13395, 5, 1108, 0, 0, 13395, 13396, 5, 1206, 0, 0, 13396, 13397, + 3, 926, 463, 0, 13397, 13398, 5, 1208, 0, 0, 13398, 13399, 3, 926, 463, + 0, 13399, 13400, 5, 1207, 0, 0, 13400, 13611, 1, 0, 0, 0, 13401, 13402, + 5, 1109, 0, 0, 13402, 13403, 5, 1206, 0, 0, 13403, 13404, 3, 926, 463, + 0, 13404, 13405, 5, 1207, 0, 0, 13405, 13611, 1, 0, 0, 0, 13406, 13407, + 5, 1110, 0, 0, 13407, 13409, 5, 1206, 0, 0, 13408, 13410, 3, 926, 463, + 0, 13409, 13408, 1, 0, 0, 0, 13409, 13410, 1, 0, 0, 0, 13410, 13411, 1, + 0, 0, 0, 13411, 13611, 5, 1207, 0, 0, 13412, 13413, 5, 1111, 0, 0, 13413, + 13414, 5, 1206, 0, 0, 13414, 13415, 3, 926, 463, 0, 13415, 13416, 5, 1208, + 0, 0, 13416, 13419, 3, 926, 463, 0, 13417, 13418, 5, 1208, 0, 0, 13418, + 13420, 3, 926, 463, 0, 13419, 13417, 1, 0, 0, 0, 13419, 13420, 1, 0, 0, + 0, 13420, 13421, 1, 0, 0, 0, 13421, 13422, 5, 1207, 0, 0, 13422, 13611, + 1, 0, 0, 0, 13423, 13424, 5, 1112, 0, 0, 13424, 13425, 5, 1206, 0, 0, 13425, + 13426, 3, 926, 463, 0, 13426, 13427, 5, 1207, 0, 0, 13427, 13611, 1, 0, + 0, 0, 13428, 13429, 5, 1113, 0, 0, 13429, 13430, 5, 1206, 0, 0, 13430, + 13431, 3, 926, 463, 0, 13431, 13432, 5, 1207, 0, 0, 13432, 13611, 1, 0, + 0, 0, 13433, 13434, 5, 1114, 0, 0, 13434, 13435, 5, 1206, 0, 0, 13435, + 13436, 3, 926, 463, 0, 13436, 13437, 5, 1207, 0, 0, 13437, 13611, 1, 0, + 0, 0, 13438, 13439, 5, 1115, 0, 0, 13439, 13440, 5, 1206, 0, 0, 13440, + 13441, 3, 926, 463, 0, 13441, 13442, 5, 1207, 0, 0, 13442, 13611, 1, 0, + 0, 0, 13443, 13444, 5, 1116, 0, 0, 13444, 13445, 5, 1206, 0, 0, 13445, + 13446, 3, 926, 463, 0, 13446, 13447, 5, 1207, 0, 0, 13447, 13611, 1, 0, + 0, 0, 13448, 13449, 5, 411, 0, 0, 13449, 13450, 5, 1206, 0, 0, 13450, 13451, + 3, 1126, 563, 0, 13451, 13452, 5, 1207, 0, 0, 13452, 13611, 1, 0, 0, 0, + 13453, 13454, 5, 510, 0, 0, 13454, 13455, 5, 1206, 0, 0, 13455, 13456, + 3, 1126, 563, 0, 13456, 13457, 5, 1207, 0, 0, 13457, 13611, 1, 0, 0, 0, + 13458, 13459, 5, 122, 0, 0, 13459, 13460, 5, 1206, 0, 0, 13460, 13461, + 3, 926, 463, 0, 13461, 13462, 5, 1207, 0, 0, 13462, 13611, 1, 0, 0, 0, + 13463, 13464, 5, 124, 0, 0, 13464, 13465, 5, 1206, 0, 0, 13465, 13466, + 3, 926, 463, 0, 13466, 13467, 5, 1208, 0, 0, 13467, 13470, 3, 926, 463, + 0, 13468, 13469, 5, 1208, 0, 0, 13469, 13471, 3, 926, 463, 0, 13470, 13468, + 1, 0, 0, 0, 13470, 13471, 1, 0, 0, 0, 13471, 13472, 1, 0, 0, 0, 13472, + 13473, 5, 1207, 0, 0, 13473, 13611, 1, 0, 0, 0, 13474, 13611, 5, 212, 0, + 0, 13475, 13476, 5, 222, 0, 0, 13476, 13478, 5, 1206, 0, 0, 13477, 13479, + 3, 926, 463, 0, 13478, 13477, 1, 0, 0, 0, 13478, 13479, 1, 0, 0, 0, 13479, + 13480, 1, 0, 0, 0, 13480, 13611, 5, 1207, 0, 0, 13481, 13482, 5, 419, 0, + 0, 13482, 13483, 5, 1206, 0, 0, 13483, 13484, 3, 926, 463, 0, 13484, 13485, + 5, 1207, 0, 0, 13485, 13611, 1, 0, 0, 0, 13486, 13487, 5, 420, 0, 0, 13487, + 13488, 5, 1206, 0, 0, 13488, 13489, 3, 926, 463, 0, 13489, 13490, 5, 1208, + 0, 0, 13490, 13491, 3, 926, 463, 0, 13491, 13492, 5, 1208, 0, 0, 13492, + 13499, 3, 926, 463, 0, 13493, 13494, 5, 1208, 0, 0, 13494, 13497, 3, 926, + 463, 0, 13495, 13496, 5, 1208, 0, 0, 13496, 13498, 3, 926, 463, 0, 13497, + 13495, 1, 0, 0, 0, 13497, 13498, 1, 0, 0, 0, 13498, 13500, 1, 0, 0, 0, + 13499, 13493, 1, 0, 0, 0, 13499, 13500, 1, 0, 0, 0, 13500, 13501, 1, 0, + 0, 0, 13501, 13502, 5, 1207, 0, 0, 13502, 13611, 1, 0, 0, 0, 13503, 13504, + 5, 480, 0, 0, 13504, 13505, 5, 1206, 0, 0, 13505, 13506, 3, 926, 463, 0, + 13506, 13507, 5, 1207, 0, 0, 13507, 13611, 1, 0, 0, 0, 13508, 13509, 5, + 481, 0, 0, 13509, 13510, 5, 1206, 0, 0, 13510, 13513, 3, 926, 463, 0, 13511, + 13512, 5, 1208, 0, 0, 13512, 13514, 3, 926, 463, 0, 13513, 13511, 1, 0, + 0, 0, 13513, 13514, 1, 0, 0, 0, 13514, 13515, 1, 0, 0, 0, 13515, 13516, + 5, 1207, 0, 0, 13516, 13611, 1, 0, 0, 0, 13517, 13518, 5, 482, 0, 0, 13518, + 13519, 5, 1206, 0, 0, 13519, 13522, 3, 926, 463, 0, 13520, 13521, 5, 1208, + 0, 0, 13521, 13523, 3, 926, 463, 0, 13522, 13520, 1, 0, 0, 0, 13522, 13523, + 1, 0, 0, 0, 13523, 13524, 1, 0, 0, 0, 13524, 13525, 5, 1207, 0, 0, 13525, + 13611, 1, 0, 0, 0, 13526, 13527, 5, 538, 0, 0, 13527, 13528, 5, 1206, 0, + 0, 13528, 13529, 3, 926, 463, 0, 13529, 13530, 5, 1208, 0, 0, 13530, 13531, + 3, 926, 463, 0, 13531, 13532, 5, 1207, 0, 0, 13532, 13611, 1, 0, 0, 0, + 13533, 13534, 5, 681, 0, 0, 13534, 13535, 5, 1206, 0, 0, 13535, 13611, + 5, 1207, 0, 0, 13536, 13537, 5, 712, 0, 0, 13537, 13543, 5, 1206, 0, 0, + 13538, 13541, 3, 926, 463, 0, 13539, 13540, 5, 1208, 0, 0, 13540, 13542, + 3, 926, 463, 0, 13541, 13539, 1, 0, 0, 0, 13541, 13542, 1, 0, 0, 0, 13542, + 13544, 1, 0, 0, 0, 13543, 13538, 1, 0, 0, 0, 13543, 13544, 1, 0, 0, 0, + 13544, 13545, 1, 0, 0, 0, 13545, 13611, 5, 1207, 0, 0, 13546, 13547, 5, + 750, 0, 0, 13547, 13548, 5, 1206, 0, 0, 13548, 13549, 3, 926, 463, 0, 13549, + 13550, 5, 1207, 0, 0, 13550, 13611, 1, 0, 0, 0, 13551, 13552, 5, 749, 0, + 0, 13552, 13553, 5, 1206, 0, 0, 13553, 13554, 3, 926, 463, 0, 13554, 13555, + 5, 1208, 0, 0, 13555, 13558, 3, 926, 463, 0, 13556, 13557, 5, 1208, 0, + 0, 13557, 13559, 3, 926, 463, 0, 13558, 13556, 1, 0, 0, 0, 13558, 13559, + 1, 0, 0, 0, 13559, 13560, 1, 0, 0, 0, 13560, 13561, 5, 1207, 0, 0, 13561, + 13611, 1, 0, 0, 0, 13562, 13611, 5, 899, 0, 0, 13563, 13564, 5, 896, 0, + 0, 13564, 13565, 5, 1206, 0, 0, 13565, 13566, 3, 926, 463, 0, 13566, 13567, + 5, 1207, 0, 0, 13567, 13611, 1, 0, 0, 0, 13568, 13569, 5, 969, 0, 0, 13569, + 13571, 5, 1206, 0, 0, 13570, 13572, 3, 926, 463, 0, 13571, 13570, 1, 0, + 0, 0, 13571, 13572, 1, 0, 0, 0, 13572, 13573, 1, 0, 0, 0, 13573, 13611, + 5, 1207, 0, 0, 13574, 13575, 5, 970, 0, 0, 13575, 13577, 5, 1206, 0, 0, + 13576, 13578, 3, 926, 463, 0, 13577, 13576, 1, 0, 0, 0, 13577, 13578, 1, + 0, 0, 0, 13578, 13579, 1, 0, 0, 0, 13579, 13611, 5, 1207, 0, 0, 13580, + 13581, 5, 971, 0, 0, 13581, 13587, 5, 1206, 0, 0, 13582, 13585, 3, 926, + 463, 0, 13583, 13584, 5, 1208, 0, 0, 13584, 13586, 3, 926, 463, 0, 13585, + 13583, 1, 0, 0, 0, 13585, 13586, 1, 0, 0, 0, 13586, 13588, 1, 0, 0, 0, + 13587, 13582, 1, 0, 0, 0, 13587, 13588, 1, 0, 0, 0, 13588, 13589, 1, 0, + 0, 0, 13589, 13611, 5, 1207, 0, 0, 13590, 13591, 5, 972, 0, 0, 13591, 13593, + 5, 1206, 0, 0, 13592, 13594, 3, 926, 463, 0, 13593, 13592, 1, 0, 0, 0, + 13593, 13594, 1, 0, 0, 0, 13594, 13595, 1, 0, 0, 0, 13595, 13611, 5, 1207, + 0, 0, 13596, 13611, 5, 979, 0, 0, 13597, 13611, 5, 1049, 0, 0, 13598, 13599, + 5, 1050, 0, 0, 13599, 13601, 5, 1206, 0, 0, 13600, 13602, 3, 926, 463, + 0, 13601, 13600, 1, 0, 0, 0, 13601, 13602, 1, 0, 0, 0, 13602, 13603, 1, + 0, 0, 0, 13603, 13611, 5, 1207, 0, 0, 13604, 13605, 5, 1051, 0, 0, 13605, + 13607, 5, 1206, 0, 0, 13606, 13608, 3, 926, 463, 0, 13607, 13606, 1, 0, + 0, 0, 13607, 13608, 1, 0, 0, 0, 13608, 13609, 1, 0, 0, 0, 13609, 13611, + 5, 1207, 0, 0, 13610, 12264, 1, 0, 0, 0, 13610, 12267, 1, 0, 0, 0, 13610, + 12276, 1, 0, 0, 0, 13610, 12287, 1, 0, 0, 0, 13610, 12294, 1, 0, 0, 0, + 13610, 12301, 1, 0, 0, 0, 13610, 12308, 1, 0, 0, 0, 13610, 12317, 1, 0, + 0, 0, 13610, 12324, 1, 0, 0, 0, 13610, 12330, 1, 0, 0, 0, 13610, 12336, + 1, 0, 0, 0, 13610, 12341, 1, 0, 0, 0, 13610, 12346, 1, 0, 0, 0, 13610, + 12351, 1, 0, 0, 0, 13610, 12356, 1, 0, 0, 0, 13610, 12361, 1, 0, 0, 0, + 13610, 12368, 1, 0, 0, 0, 13610, 12375, 1, 0, 0, 0, 13610, 12382, 1, 0, + 0, 0, 13610, 12389, 1, 0, 0, 0, 13610, 12394, 1, 0, 0, 0, 13610, 12403, + 1, 0, 0, 0, 13610, 12414, 1, 0, 0, 0, 13610, 12423, 1, 0, 0, 0, 13610, + 12434, 1, 0, 0, 0, 13610, 12439, 1, 0, 0, 0, 13610, 12448, 1, 0, 0, 0, + 13610, 12457, 1, 0, 0, 0, 13610, 12466, 1, 0, 0, 0, 13610, 12473, 1, 0, + 0, 0, 13610, 12480, 1, 0, 0, 0, 13610, 12483, 1, 0, 0, 0, 13610, 12490, + 1, 0, 0, 0, 13610, 12496, 1, 0, 0, 0, 13610, 12502, 1, 0, 0, 0, 13610, + 12505, 1, 0, 0, 0, 13610, 12510, 1, 0, 0, 0, 13610, 12517, 1, 0, 0, 0, + 13610, 12522, 1, 0, 0, 0, 13610, 12527, 1, 0, 0, 0, 13610, 12534, 1, 0, + 0, 0, 13610, 12539, 1, 0, 0, 0, 13610, 12544, 1, 0, 0, 0, 13610, 12555, + 1, 0, 0, 0, 13610, 12569, 1, 0, 0, 0, 13610, 12585, 1, 0, 0, 0, 13610, + 12592, 1, 0, 0, 0, 13610, 12603, 1, 0, 0, 0, 13610, 12610, 1, 0, 0, 0, + 13610, 12615, 1, 0, 0, 0, 13610, 12620, 1, 0, 0, 0, 13610, 12625, 1, 0, + 0, 0, 13610, 12630, 1, 0, 0, 0, 13610, 12637, 1, 0, 0, 0, 13610, 12646, + 1, 0, 0, 0, 13610, 12655, 1, 0, 0, 0, 13610, 12662, 1, 0, 0, 0, 13610, + 12667, 1, 0, 0, 0, 13610, 12674, 1, 0, 0, 0, 13610, 12679, 1, 0, 0, 0, + 13610, 12684, 1, 0, 0, 0, 13610, 12689, 1, 0, 0, 0, 13610, 12702, 1, 0, + 0, 0, 13610, 12716, 1, 0, 0, 0, 13610, 12723, 1, 0, 0, 0, 13610, 12734, + 1, 0, 0, 0, 13610, 12743, 1, 0, 0, 0, 13610, 12752, 1, 0, 0, 0, 13610, + 12762, 1, 0, 0, 0, 13610, 12767, 1, 0, 0, 0, 13610, 12772, 1, 0, 0, 0, + 13610, 12786, 1, 0, 0, 0, 13610, 12800, 1, 0, 0, 0, 13610, 12805, 1, 0, + 0, 0, 13610, 12809, 1, 0, 0, 0, 13610, 12812, 1, 0, 0, 0, 13610, 12815, + 1, 0, 0, 0, 13610, 12818, 1, 0, 0, 0, 13610, 12823, 1, 0, 0, 0, 13610, + 12826, 1, 0, 0, 0, 13610, 12829, 1, 0, 0, 0, 13610, 12832, 1, 0, 0, 0, + 13610, 12835, 1, 0, 0, 0, 13610, 12838, 1, 0, 0, 0, 13610, 12841, 1, 0, + 0, 0, 13610, 12859, 1, 0, 0, 0, 13610, 12862, 1, 0, 0, 0, 13610, 12868, + 1, 0, 0, 0, 13610, 12871, 1, 0, 0, 0, 13610, 12874, 1, 0, 0, 0, 13610, + 12881, 1, 0, 0, 0, 13610, 12886, 1, 0, 0, 0, 13610, 12889, 1, 0, 0, 0, + 13610, 12892, 1, 0, 0, 0, 13610, 12895, 1, 0, 0, 0, 13610, 12898, 1, 0, + 0, 0, 13610, 12902, 1, 0, 0, 0, 13610, 12905, 1, 0, 0, 0, 13610, 12912, + 1, 0, 0, 0, 13610, 12919, 1, 0, 0, 0, 13610, 12930, 1, 0, 0, 0, 13610, + 12935, 1, 0, 0, 0, 13610, 12936, 1, 0, 0, 0, 13610, 12937, 1, 0, 0, 0, + 13610, 12944, 1, 0, 0, 0, 13610, 12949, 1, 0, 0, 0, 13610, 12954, 1, 0, + 0, 0, 13610, 12959, 1, 0, 0, 0, 13610, 12964, 1, 0, 0, 0, 13610, 12969, + 1, 0, 0, 0, 13610, 12980, 1, 0, 0, 0, 13610, 12987, 1, 0, 0, 0, 13610, + 12990, 1, 0, 0, 0, 13610, 12991, 1, 0, 0, 0, 13610, 12994, 1, 0, 0, 0, + 13610, 12997, 1, 0, 0, 0, 13610, 13010, 1, 0, 0, 0, 13610, 13019, 1, 0, + 0, 0, 13610, 13028, 1, 0, 0, 0, 13610, 13037, 1, 0, 0, 0, 13610, 13046, + 1, 0, 0, 0, 13610, 13053, 1, 0, 0, 0, 13610, 13060, 1, 0, 0, 0, 13610, + 13079, 1, 0, 0, 0, 13610, 13096, 1, 0, 0, 0, 13610, 13119, 1, 0, 0, 0, + 13610, 13126, 1, 0, 0, 0, 13610, 13131, 1, 0, 0, 0, 13610, 13140, 1, 0, + 0, 0, 13610, 13143, 1, 0, 0, 0, 13610, 13146, 1, 0, 0, 0, 13610, 13151, + 1, 0, 0, 0, 13610, 13156, 1, 0, 0, 0, 13610, 13169, 1, 0, 0, 0, 13610, + 13176, 1, 0, 0, 0, 13610, 13179, 1, 0, 0, 0, 13610, 13182, 1, 0, 0, 0, + 13610, 13185, 1, 0, 0, 0, 13610, 13198, 1, 0, 0, 0, 13610, 13205, 1, 0, + 0, 0, 13610, 13210, 1, 0, 0, 0, 13610, 13223, 1, 0, 0, 0, 13610, 13226, + 1, 0, 0, 0, 13610, 13233, 1, 0, 0, 0, 13610, 13244, 1, 0, 0, 0, 13610, + 13245, 1, 0, 0, 0, 13610, 13254, 1, 0, 0, 0, 13610, 13263, 1, 0, 0, 0, + 13610, 13279, 1, 0, 0, 0, 13610, 13288, 1, 0, 0, 0, 13610, 13295, 1, 0, + 0, 0, 13610, 13304, 1, 0, 0, 0, 13610, 13313, 1, 0, 0, 0, 13610, 13320, + 1, 0, 0, 0, 13610, 13325, 1, 0, 0, 0, 13610, 13330, 1, 0, 0, 0, 13610, + 13335, 1, 0, 0, 0, 13610, 13340, 1, 0, 0, 0, 13610, 13347, 1, 0, 0, 0, + 13610, 13352, 1, 0, 0, 0, 13610, 13357, 1, 0, 0, 0, 13610, 13362, 1, 0, + 0, 0, 13610, 13367, 1, 0, 0, 0, 13610, 13372, 1, 0, 0, 0, 13610, 13377, + 1, 0, 0, 0, 13610, 13386, 1, 0, 0, 0, 13610, 13391, 1, 0, 0, 0, 13610, + 13394, 1, 0, 0, 0, 13610, 13401, 1, 0, 0, 0, 13610, 13406, 1, 0, 0, 0, + 13610, 13412, 1, 0, 0, 0, 13610, 13423, 1, 0, 0, 0, 13610, 13428, 1, 0, + 0, 0, 13610, 13433, 1, 0, 0, 0, 13610, 13438, 1, 0, 0, 0, 13610, 13443, + 1, 0, 0, 0, 13610, 13448, 1, 0, 0, 0, 13610, 13453, 1, 0, 0, 0, 13610, + 13458, 1, 0, 0, 0, 13610, 13463, 1, 0, 0, 0, 13610, 13474, 1, 0, 0, 0, + 13610, 13475, 1, 0, 0, 0, 13610, 13481, 1, 0, 0, 0, 13610, 13486, 1, 0, + 0, 0, 13610, 13503, 1, 0, 0, 0, 13610, 13508, 1, 0, 0, 0, 13610, 13517, + 1, 0, 0, 0, 13610, 13526, 1, 0, 0, 0, 13610, 13533, 1, 0, 0, 0, 13610, + 13536, 1, 0, 0, 0, 13610, 13546, 1, 0, 0, 0, 13610, 13551, 1, 0, 0, 0, + 13610, 13562, 1, 0, 0, 0, 13610, 13563, 1, 0, 0, 0, 13610, 13568, 1, 0, + 0, 0, 13610, 13574, 1, 0, 0, 0, 13610, 13580, 1, 0, 0, 0, 13610, 13590, + 1, 0, 0, 0, 13610, 13596, 1, 0, 0, 0, 13610, 13597, 1, 0, 0, 0, 13610, + 13598, 1, 0, 0, 0, 13610, 13604, 1, 0, 0, 0, 13611, 1065, 1, 0, 0, 0, 13612, + 13617, 3, 1076, 538, 0, 13613, 13617, 3, 1080, 540, 0, 13614, 13617, 3, + 1084, 542, 0, 13615, 13617, 3, 1088, 544, 0, 13616, 13612, 1, 0, 0, 0, + 13616, 13613, 1, 0, 0, 0, 13616, 13614, 1, 0, 0, 0, 13616, 13615, 1, 0, + 0, 0, 13617, 1067, 1, 0, 0, 0, 13618, 13619, 7, 154, 0, 0, 13619, 1069, + 1, 0, 0, 0, 13620, 13628, 3, 1068, 534, 0, 13621, 13628, 5, 1139, 0, 0, + 13622, 13628, 5, 1153, 0, 0, 13623, 13628, 5, 1145, 0, 0, 13624, 13628, + 5, 1160, 0, 0, 13625, 13628, 5, 1146, 0, 0, 13626, 13628, 5, 1161, 0, 0, + 13627, 13620, 1, 0, 0, 0, 13627, 13621, 1, 0, 0, 0, 13627, 13622, 1, 0, + 0, 0, 13627, 13623, 1, 0, 0, 0, 13627, 13624, 1, 0, 0, 0, 13627, 13625, + 1, 0, 0, 0, 13627, 13626, 1, 0, 0, 0, 13628, 1071, 1, 0, 0, 0, 13629, 13637, + 3, 1070, 535, 0, 13630, 13637, 5, 1149, 0, 0, 13631, 13637, 5, 1164, 0, + 0, 13632, 13637, 5, 1147, 0, 0, 13633, 13637, 5, 1162, 0, 0, 13634, 13637, + 5, 1148, 0, 0, 13635, 13637, 5, 1163, 0, 0, 13636, 13629, 1, 0, 0, 0, 13636, + 13630, 1, 0, 0, 0, 13636, 13631, 1, 0, 0, 0, 13636, 13632, 1, 0, 0, 0, + 13636, 13633, 1, 0, 0, 0, 13636, 13634, 1, 0, 0, 0, 13636, 13635, 1, 0, + 0, 0, 13637, 1073, 1, 0, 0, 0, 13638, 13646, 3, 1068, 534, 0, 13639, 13646, + 5, 1139, 0, 0, 13640, 13646, 5, 1153, 0, 0, 13641, 13646, 5, 1145, 0, 0, + 13642, 13646, 5, 1160, 0, 0, 13643, 13646, 5, 1148, 0, 0, 13644, 13646, + 5, 1163, 0, 0, 13645, 13638, 1, 0, 0, 0, 13645, 13639, 1, 0, 0, 0, 13645, + 13640, 1, 0, 0, 0, 13645, 13641, 1, 0, 0, 0, 13645, 13642, 1, 0, 0, 0, + 13645, 13643, 1, 0, 0, 0, 13645, 13644, 1, 0, 0, 0, 13646, 1075, 1, 0, + 0, 0, 13647, 13658, 5, 1180, 0, 0, 13648, 13658, 3, 1182, 591, 0, 13649, + 13650, 5, 314, 0, 0, 13650, 13651, 5, 1206, 0, 0, 13651, 13658, 5, 1207, + 0, 0, 13652, 13658, 3, 1080, 540, 0, 13653, 13654, 5, 1206, 0, 0, 13654, + 13655, 3, 940, 470, 0, 13655, 13656, 5, 1207, 0, 0, 13656, 13658, 1, 0, + 0, 0, 13657, 13647, 1, 0, 0, 0, 13657, 13648, 1, 0, 0, 0, 13657, 13649, + 1, 0, 0, 0, 13657, 13652, 1, 0, 0, 0, 13657, 13653, 1, 0, 0, 0, 13658, + 13659, 1, 0, 0, 0, 13659, 13660, 5, 1201, 0, 0, 13660, 13661, 3, 1078, + 539, 0, 13661, 1077, 1, 0, 0, 0, 13662, 13663, 7, 155, 0, 0, 13663, 13664, + 5, 1206, 0, 0, 13664, 13665, 5, 1184, 0, 0, 13665, 13666, 5, 1208, 0, 0, + 13666, 13667, 5, 1184, 0, 0, 13667, 13668, 5, 1207, 0, 0, 13668, 1079, + 1, 0, 0, 0, 13669, 13676, 5, 1180, 0, 0, 13670, 13676, 3, 1182, 591, 0, + 13671, 13672, 5, 1206, 0, 0, 13672, 13673, 3, 940, 470, 0, 13673, 13674, + 5, 1207, 0, 0, 13674, 13676, 1, 0, 0, 0, 13675, 13669, 1, 0, 0, 0, 13675, + 13670, 1, 0, 0, 0, 13675, 13671, 1, 0, 0, 0, 13676, 13677, 1, 0, 0, 0, + 13677, 13678, 5, 1201, 0, 0, 13678, 13679, 3, 1082, 541, 0, 13679, 1081, + 1, 0, 0, 0, 13680, 13681, 7, 156, 0, 0, 13681, 13682, 5, 1206, 0, 0, 13682, + 13683, 5, 1184, 0, 0, 13683, 13684, 5, 1207, 0, 0, 13684, 1083, 1, 0, 0, + 0, 13685, 13692, 5, 1180, 0, 0, 13686, 13692, 3, 1182, 591, 0, 13687, 13688, + 5, 1206, 0, 0, 13688, 13689, 3, 940, 470, 0, 13689, 13690, 5, 1207, 0, + 0, 13690, 13692, 1, 0, 0, 0, 13691, 13685, 1, 0, 0, 0, 13691, 13686, 1, + 0, 0, 0, 13691, 13687, 1, 0, 0, 0, 13692, 13693, 1, 0, 0, 0, 13693, 13694, + 5, 1201, 0, 0, 13694, 13695, 3, 1086, 543, 0, 13695, 1085, 1, 0, 0, 0, + 13696, 13697, 7, 157, 0, 0, 13697, 13698, 5, 1206, 0, 0, 13698, 13699, + 5, 1184, 0, 0, 13699, 13700, 5, 1207, 0, 0, 13700, 1087, 1, 0, 0, 0, 13701, + 13708, 5, 1180, 0, 0, 13702, 13708, 3, 1182, 591, 0, 13703, 13704, 5, 1206, + 0, 0, 13704, 13705, 3, 940, 470, 0, 13705, 13706, 5, 1207, 0, 0, 13706, + 13708, 1, 0, 0, 0, 13707, 13701, 1, 0, 0, 0, 13707, 13702, 1, 0, 0, 0, + 13707, 13703, 1, 0, 0, 0, 13708, 13709, 1, 0, 0, 0, 13709, 13710, 5, 1201, + 0, 0, 13710, 13711, 3, 1090, 545, 0, 13711, 1089, 1, 0, 0, 0, 13712, 13713, + 7, 158, 0, 0, 13713, 13714, 5, 1206, 0, 0, 13714, 13715, 5, 1184, 0, 0, + 13715, 13716, 5, 1207, 0, 0, 13716, 1091, 1, 0, 0, 0, 13717, 13718, 5, + 397, 0, 0, 13718, 13719, 5, 1206, 0, 0, 13719, 13720, 3, 926, 463, 0, 13720, + 13721, 5, 1207, 0, 0, 13721, 13748, 1, 0, 0, 0, 13722, 13723, 5, 400, 0, + 0, 13723, 13724, 5, 1206, 0, 0, 13724, 13725, 3, 926, 463, 0, 13725, 13726, + 5, 1208, 0, 0, 13726, 13727, 3, 926, 463, 0, 13727, 13728, 5, 1207, 0, + 0, 13728, 13748, 1, 0, 0, 0, 13729, 13730, 5, 401, 0, 0, 13730, 13731, + 5, 1206, 0, 0, 13731, 13748, 5, 1207, 0, 0, 13732, 13733, 5, 475, 0, 0, + 13733, 13734, 5, 1206, 0, 0, 13734, 13735, 3, 926, 463, 0, 13735, 13736, + 5, 1207, 0, 0, 13736, 13748, 1, 0, 0, 0, 13737, 13738, 5, 402, 0, 0, 13738, + 13739, 5, 1206, 0, 0, 13739, 13740, 3, 926, 463, 0, 13740, 13741, 5, 1208, + 0, 0, 13741, 13742, 3, 926, 463, 0, 13742, 13743, 5, 1207, 0, 0, 13743, + 13748, 1, 0, 0, 0, 13744, 13745, 5, 1003, 0, 0, 13745, 13746, 5, 1206, + 0, 0, 13746, 13748, 5, 1207, 0, 0, 13747, 13717, 1, 0, 0, 0, 13747, 13722, + 1, 0, 0, 0, 13747, 13729, 1, 0, 0, 0, 13747, 13732, 1, 0, 0, 0, 13747, + 13737, 1, 0, 0, 0, 13747, 13744, 1, 0, 0, 0, 13748, 1093, 1, 0, 0, 0, 13749, + 13750, 5, 426, 0, 0, 13750, 13759, 5, 1211, 0, 0, 13751, 13752, 5, 403, + 0, 0, 13752, 13753, 5, 1206, 0, 0, 13753, 13760, 5, 1207, 0, 0, 13754, + 13755, 5, 696, 0, 0, 13755, 13756, 5, 1206, 0, 0, 13756, 13757, 3, 926, + 463, 0, 13757, 13758, 5, 1207, 0, 0, 13758, 13760, 1, 0, 0, 0, 13759, 13751, + 1, 0, 0, 0, 13759, 13754, 1, 0, 0, 0, 13760, 1095, 1, 0, 0, 0, 13761, 13768, + 5, 1180, 0, 0, 13762, 13768, 3, 1182, 591, 0, 13763, 13764, 5, 1206, 0, + 0, 13764, 13765, 3, 940, 470, 0, 13765, 13766, 5, 1207, 0, 0, 13766, 13768, + 1, 0, 0, 0, 13767, 13761, 1, 0, 0, 0, 13767, 13762, 1, 0, 0, 0, 13767, + 13763, 1, 0, 0, 0, 13768, 13769, 1, 0, 0, 0, 13769, 13770, 5, 1201, 0, + 0, 13770, 13771, 5, 612, 0, 0, 13771, 13772, 5, 1206, 0, 0, 13772, 13773, + 5, 1184, 0, 0, 13773, 13774, 5, 1207, 0, 0, 13774, 1097, 1, 0, 0, 0, 13775, + 13776, 5, 1073, 0, 0, 13776, 13777, 3, 926, 463, 0, 13777, 13778, 5, 993, + 0, 0, 13778, 13779, 3, 926, 463, 0, 13779, 1099, 1, 0, 0, 0, 13780, 13781, + 5, 1073, 0, 0, 13781, 13782, 3, 950, 475, 0, 13782, 13783, 5, 993, 0, 0, + 13783, 13784, 3, 926, 463, 0, 13784, 1101, 1, 0, 0, 0, 13785, 13787, 5, + 56, 0, 0, 13786, 13785, 1, 0, 0, 0, 13786, 13787, 1, 0, 0, 0, 13787, 13788, + 1, 0, 0, 0, 13788, 13789, 3, 1122, 561, 0, 13789, 1103, 1, 0, 0, 0, 13790, + 13792, 5, 56, 0, 0, 13791, 13790, 1, 0, 0, 0, 13791, 13792, 1, 0, 0, 0, + 13792, 13793, 1, 0, 0, 0, 13793, 13794, 3, 1106, 553, 0, 13794, 1105, 1, + 0, 0, 0, 13795, 13796, 3, 1230, 615, 0, 13796, 1107, 1, 0, 0, 0, 13797, + 13798, 5, 1077, 0, 0, 13798, 13799, 5, 1206, 0, 0, 13799, 13806, 3, 1116, + 558, 0, 13800, 13802, 5, 1208, 0, 0, 13801, 13800, 1, 0, 0, 0, 13801, 13802, + 1, 0, 0, 0, 13802, 13803, 1, 0, 0, 0, 13803, 13805, 3, 1116, 558, 0, 13804, + 13801, 1, 0, 0, 0, 13805, 13808, 1, 0, 0, 0, 13806, 13804, 1, 0, 0, 0, + 13806, 13807, 1, 0, 0, 0, 13807, 13809, 1, 0, 0, 0, 13808, 13806, 1, 0, + 0, 0, 13809, 13810, 5, 1207, 0, 0, 13810, 1109, 1, 0, 0, 0, 13811, 13812, + 5, 1206, 0, 0, 13812, 13813, 3, 1116, 558, 0, 13813, 13814, 5, 1207, 0, + 0, 13814, 1111, 1, 0, 0, 0, 13815, 13817, 3, 1114, 557, 0, 13816, 13815, + 1, 0, 0, 0, 13817, 13818, 1, 0, 0, 0, 13818, 13816, 1, 0, 0, 0, 13818, + 13819, 1, 0, 0, 0, 13819, 1113, 1, 0, 0, 0, 13820, 13821, 7, 159, 0, 0, + 13821, 1115, 1, 0, 0, 0, 13822, 13879, 5, 614, 0, 0, 13823, 13842, 5, 456, + 0, 0, 13824, 13825, 5, 1206, 0, 0, 13825, 13830, 3, 1118, 559, 0, 13826, + 13827, 5, 1208, 0, 0, 13827, 13829, 3, 1118, 559, 0, 13828, 13826, 1, 0, + 0, 0, 13829, 13832, 1, 0, 0, 0, 13830, 13828, 1, 0, 0, 0, 13830, 13831, + 1, 0, 0, 0, 13831, 13833, 1, 0, 0, 0, 13832, 13830, 1, 0, 0, 0, 13833, + 13834, 5, 1207, 0, 0, 13834, 13843, 1, 0, 0, 0, 13835, 13836, 5, 1188, + 0, 0, 13836, 13837, 5, 1206, 0, 0, 13837, 13838, 3, 1118, 559, 0, 13838, + 13839, 5, 1207, 0, 0, 13839, 13843, 1, 0, 0, 0, 13840, 13841, 5, 1188, + 0, 0, 13841, 13843, 3, 1118, 559, 0, 13842, 13824, 1, 0, 0, 0, 13842, 13835, + 1, 0, 0, 0, 13842, 13840, 1, 0, 0, 0, 13843, 13879, 1, 0, 0, 0, 13844, + 13852, 5, 370, 0, 0, 13845, 13846, 5, 1206, 0, 0, 13846, 13847, 3, 1118, + 559, 0, 13847, 13848, 5, 1206, 0, 0, 13848, 13849, 3, 1192, 596, 0, 13849, + 13850, 5, 1207, 0, 0, 13850, 13851, 5, 1207, 0, 0, 13851, 13853, 1, 0, + 0, 0, 13852, 13845, 1, 0, 0, 0, 13852, 13853, 1, 0, 0, 0, 13853, 13879, + 1, 0, 0, 0, 13854, 13879, 5, 369, 0, 0, 13855, 13879, 5, 428, 0, 0, 13856, + 13879, 5, 619, 0, 0, 13857, 13879, 5, 631, 0, 0, 13858, 13879, 5, 693, + 0, 0, 13859, 13879, 5, 768, 0, 0, 13860, 13879, 5, 769, 0, 0, 13861, 13879, + 5, 771, 0, 0, 13862, 13879, 5, 773, 0, 0, 13863, 13879, 5, 800, 0, 0, 13864, + 13879, 5, 842, 0, 0, 13865, 13879, 5, 888, 0, 0, 13866, 13879, 5, 921, + 0, 0, 13867, 13868, 5, 930, 0, 0, 13868, 13869, 5, 1188, 0, 0, 13869, 13879, + 5, 1182, 0, 0, 13870, 13879, 5, 983, 0, 0, 13871, 13879, 5, 984, 0, 0, + 13872, 13879, 5, 1044, 0, 0, 13873, 13879, 5, 1087, 0, 0, 13874, 13879, + 5, 496, 0, 0, 13875, 13879, 5, 494, 0, 0, 13876, 13879, 5, 441, 0, 0, 13877, + 13879, 5, 445, 0, 0, 13878, 13822, 1, 0, 0, 0, 13878, 13823, 1, 0, 0, 0, + 13878, 13844, 1, 0, 0, 0, 13878, 13854, 1, 0, 0, 0, 13878, 13855, 1, 0, + 0, 0, 13878, 13856, 1, 0, 0, 0, 13878, 13857, 1, 0, 0, 0, 13878, 13858, + 1, 0, 0, 0, 13878, 13859, 1, 0, 0, 0, 13878, 13860, 1, 0, 0, 0, 13878, + 13861, 1, 0, 0, 0, 13878, 13862, 1, 0, 0, 0, 13878, 13863, 1, 0, 0, 0, + 13878, 13864, 1, 0, 0, 0, 13878, 13865, 1, 0, 0, 0, 13878, 13866, 1, 0, + 0, 0, 13878, 13867, 1, 0, 0, 0, 13878, 13870, 1, 0, 0, 0, 13878, 13871, + 1, 0, 0, 0, 13878, 13872, 1, 0, 0, 0, 13878, 13873, 1, 0, 0, 0, 13878, + 13874, 1, 0, 0, 0, 13878, 13875, 1, 0, 0, 0, 13878, 13876, 1, 0, 0, 0, + 13878, 13877, 1, 0, 0, 0, 13879, 1117, 1, 0, 0, 0, 13880, 13883, 3, 1230, + 615, 0, 13881, 13883, 5, 1182, 0, 0, 13882, 13880, 1, 0, 0, 0, 13882, 13881, + 1, 0, 0, 0, 13883, 1119, 1, 0, 0, 0, 13884, 13885, 5, 1206, 0, 0, 13885, + 13890, 3, 1122, 561, 0, 13886, 13887, 5, 1208, 0, 0, 13887, 13889, 3, 1122, + 561, 0, 13888, 13886, 1, 0, 0, 0, 13889, 13892, 1, 0, 0, 0, 13890, 13888, + 1, 0, 0, 0, 13890, 13891, 1, 0, 0, 0, 13891, 13893, 1, 0, 0, 0, 13892, + 13890, 1, 0, 0, 0, 13893, 13894, 5, 1207, 0, 0, 13894, 1121, 1, 0, 0, 0, + 13895, 13898, 3, 1230, 615, 0, 13896, 13898, 5, 1184, 0, 0, 13897, 13895, + 1, 0, 0, 0, 13897, 13896, 1, 0, 0, 0, 13898, 1123, 1, 0, 0, 0, 13899, 13900, + 5, 1056, 0, 0, 13900, 13901, 5, 1206, 0, 0, 13901, 13902, 3, 1126, 563, + 0, 13902, 13910, 5, 1207, 0, 0, 13903, 13904, 5, 1208, 0, 0, 13904, 13905, + 5, 1206, 0, 0, 13905, 13906, 3, 1126, 563, 0, 13906, 13907, 5, 1207, 0, + 0, 13907, 13909, 1, 0, 0, 0, 13908, 13903, 1, 0, 0, 0, 13909, 13912, 1, + 0, 0, 0, 13910, 13908, 1, 0, 0, 0, 13910, 13911, 1, 0, 0, 0, 13911, 1125, + 1, 0, 0, 0, 13912, 13910, 1, 0, 0, 0, 13913, 13918, 3, 926, 463, 0, 13914, + 13915, 5, 1208, 0, 0, 13915, 13917, 3, 926, 463, 0, 13916, 13914, 1, 0, + 0, 0, 13917, 13920, 1, 0, 0, 0, 13918, 13916, 1, 0, 0, 0, 13918, 13919, + 1, 0, 0, 0, 13919, 1127, 1, 0, 0, 0, 13920, 13918, 1, 0, 0, 0, 13921, 13922, + 7, 160, 0, 0, 13922, 13923, 5, 1206, 0, 0, 13923, 13924, 5, 1207, 0, 0, + 13924, 13932, 3, 1136, 568, 0, 13925, 13926, 5, 640, 0, 0, 13926, 13927, + 5, 1206, 0, 0, 13927, 13928, 3, 926, 463, 0, 13928, 13929, 5, 1207, 0, + 0, 13929, 13930, 3, 1136, 568, 0, 13930, 13932, 1, 0, 0, 0, 13931, 13921, + 1, 0, 0, 0, 13931, 13925, 1, 0, 0, 0, 13932, 1129, 1, 0, 0, 0, 13933, 13934, + 7, 161, 0, 0, 13934, 13935, 5, 1206, 0, 0, 13935, 13936, 3, 1134, 567, + 0, 13936, 13938, 5, 1207, 0, 0, 13937, 13939, 3, 1136, 568, 0, 13938, 13937, + 1, 0, 0, 0, 13938, 13939, 1, 0, 0, 0, 13939, 13966, 1, 0, 0, 0, 13940, + 13941, 7, 162, 0, 0, 13941, 13944, 5, 1206, 0, 0, 13942, 13945, 5, 1212, + 0, 0, 13943, 13945, 3, 1134, 567, 0, 13944, 13942, 1, 0, 0, 0, 13944, 13943, + 1, 0, 0, 0, 13945, 13946, 1, 0, 0, 0, 13946, 13948, 5, 1207, 0, 0, 13947, + 13949, 3, 1136, 568, 0, 13948, 13947, 1, 0, 0, 0, 13948, 13949, 1, 0, 0, + 0, 13949, 13966, 1, 0, 0, 0, 13950, 13951, 5, 141, 0, 0, 13951, 13952, + 5, 1206, 0, 0, 13952, 13953, 3, 1134, 567, 0, 13953, 13954, 5, 1207, 0, + 0, 13954, 13966, 1, 0, 0, 0, 13955, 13956, 5, 413, 0, 0, 13956, 13957, + 5, 1206, 0, 0, 13957, 13958, 3, 926, 463, 0, 13958, 13959, 5, 1207, 0, + 0, 13959, 13966, 1, 0, 0, 0, 13960, 13961, 5, 414, 0, 0, 13961, 13962, + 5, 1206, 0, 0, 13962, 13963, 3, 1126, 563, 0, 13963, 13964, 5, 1207, 0, + 0, 13964, 13966, 1, 0, 0, 0, 13965, 13933, 1, 0, 0, 0, 13965, 13940, 1, + 0, 0, 0, 13965, 13950, 1, 0, 0, 0, 13965, 13955, 1, 0, 0, 0, 13965, 13960, + 1, 0, 0, 0, 13966, 1131, 1, 0, 0, 0, 13967, 13968, 7, 163, 0, 0, 13968, + 13969, 5, 1206, 0, 0, 13969, 13970, 3, 926, 463, 0, 13970, 13971, 5, 1207, + 0, 0, 13971, 13972, 3, 1136, 568, 0, 13972, 14019, 1, 0, 0, 0, 13973, 13974, + 7, 164, 0, 0, 13974, 13975, 5, 1206, 0, 0, 13975, 13982, 3, 926, 463, 0, + 13976, 13977, 5, 1208, 0, 0, 13977, 13980, 3, 926, 463, 0, 13978, 13979, + 5, 1208, 0, 0, 13979, 13981, 3, 926, 463, 0, 13980, 13978, 1, 0, 0, 0, + 13980, 13981, 1, 0, 0, 0, 13981, 13983, 1, 0, 0, 0, 13982, 13976, 1, 0, + 0, 0, 13982, 13983, 1, 0, 0, 0, 13983, 13984, 1, 0, 0, 0, 13984, 13985, + 5, 1207, 0, 0, 13985, 13986, 3, 1136, 568, 0, 13986, 14019, 1, 0, 0, 0, + 13987, 13988, 7, 165, 0, 0, 13988, 13989, 5, 1206, 0, 0, 13989, 13990, + 5, 1207, 0, 0, 13990, 13991, 5, 685, 0, 0, 13991, 13995, 5, 1206, 0, 0, + 13992, 13993, 5, 700, 0, 0, 13993, 13994, 5, 111, 0, 0, 13994, 13996, 3, + 1126, 563, 0, 13995, 13992, 1, 0, 0, 0, 13995, 13996, 1, 0, 0, 0, 13996, + 13997, 1, 0, 0, 0, 13997, 13998, 3, 972, 486, 0, 13998, 13999, 5, 1207, + 0, 0, 13999, 14019, 1, 0, 0, 0, 14000, 14001, 7, 166, 0, 0, 14001, 14002, + 5, 1206, 0, 0, 14002, 14003, 3, 926, 463, 0, 14003, 14004, 5, 1207, 0, + 0, 14004, 14005, 5, 1078, 0, 0, 14005, 14006, 5, 412, 0, 0, 14006, 14007, + 5, 1206, 0, 0, 14007, 14008, 3, 972, 486, 0, 14008, 14009, 5, 1207, 0, + 0, 14009, 14010, 5, 685, 0, 0, 14010, 14014, 5, 1206, 0, 0, 14011, 14012, + 5, 700, 0, 0, 14012, 14013, 5, 111, 0, 0, 14013, 14015, 3, 1126, 563, 0, + 14014, 14011, 1, 0, 0, 0, 14014, 14015, 1, 0, 0, 0, 14015, 14016, 1, 0, + 0, 0, 14016, 14017, 5, 1207, 0, 0, 14017, 14019, 1, 0, 0, 0, 14018, 13967, + 1, 0, 0, 0, 14018, 13973, 1, 0, 0, 0, 14018, 13987, 1, 0, 0, 0, 14018, + 14000, 1, 0, 0, 0, 14019, 1133, 1, 0, 0, 0, 14020, 14022, 7, 138, 0, 0, + 14021, 14020, 1, 0, 0, 0, 14021, 14022, 1, 0, 0, 0, 14022, 14023, 1, 0, + 0, 0, 14023, 14024, 3, 926, 463, 0, 14024, 1135, 1, 0, 0, 0, 14025, 14026, + 5, 685, 0, 0, 14026, 14030, 5, 1206, 0, 0, 14027, 14028, 5, 700, 0, 0, + 14028, 14029, 5, 111, 0, 0, 14029, 14031, 3, 1126, 563, 0, 14030, 14027, + 1, 0, 0, 0, 14030, 14031, 1, 0, 0, 0, 14031, 14033, 1, 0, 0, 0, 14032, + 14034, 3, 972, 486, 0, 14033, 14032, 1, 0, 0, 0, 14033, 14034, 1, 0, 0, + 0, 14034, 14036, 1, 0, 0, 0, 14035, 14037, 3, 1138, 569, 0, 14036, 14035, + 1, 0, 0, 0, 14036, 14037, 1, 0, 0, 0, 14037, 14038, 1, 0, 0, 0, 14038, + 14039, 5, 1207, 0, 0, 14039, 1137, 1, 0, 0, 0, 14040, 14041, 7, 167, 0, + 0, 14041, 14042, 3, 1140, 570, 0, 14042, 1139, 1, 0, 0, 0, 14043, 14050, + 3, 1144, 572, 0, 14044, 14045, 5, 92, 0, 0, 14045, 14046, 3, 1142, 571, + 0, 14046, 14047, 5, 37, 0, 0, 14047, 14048, 3, 1142, 571, 0, 14048, 14050, + 1, 0, 0, 0, 14049, 14043, 1, 0, 0, 0, 14049, 14044, 1, 0, 0, 0, 14050, + 1141, 1, 0, 0, 0, 14051, 14054, 3, 1144, 572, 0, 14052, 14054, 3, 1146, + 573, 0, 14053, 14051, 1, 0, 0, 0, 14053, 14052, 1, 0, 0, 0, 14054, 1143, + 1, 0, 0, 0, 14055, 14056, 5, 1029, 0, 0, 14056, 14062, 5, 727, 0, 0, 14057, + 14058, 5, 1182, 0, 0, 14058, 14062, 5, 727, 0, 0, 14059, 14060, 5, 206, + 0, 0, 14060, 14062, 5, 837, 0, 0, 14061, 14055, 1, 0, 0, 0, 14061, 14057, + 1, 0, 0, 0, 14061, 14059, 1, 0, 0, 0, 14062, 1145, 1, 0, 0, 0, 14063, 14064, + 5, 1029, 0, 0, 14064, 14068, 5, 364, 0, 0, 14065, 14066, 5, 1182, 0, 0, + 14066, 14068, 5, 364, 0, 0, 14067, 14063, 1, 0, 0, 0, 14067, 14065, 1, + 0, 0, 0, 14068, 1147, 1, 0, 0, 0, 14069, 14070, 5, 353, 0, 0, 14070, 14075, + 3, 1150, 575, 0, 14071, 14072, 5, 1208, 0, 0, 14072, 14074, 3, 1150, 575, + 0, 14073, 14071, 1, 0, 0, 0, 14074, 14077, 1, 0, 0, 0, 14075, 14073, 1, + 0, 0, 0, 14075, 14076, 1, 0, 0, 0, 14076, 14104, 1, 0, 0, 0, 14077, 14075, + 1, 0, 0, 0, 14078, 14079, 5, 249, 0, 0, 14079, 14082, 5, 1188, 0, 0, 14080, + 14083, 3, 1230, 615, 0, 14081, 14083, 5, 1184, 0, 0, 14082, 14080, 1, 0, + 0, 0, 14082, 14081, 1, 0, 0, 0, 14083, 14104, 1, 0, 0, 0, 14084, 14085, + 5, 248, 0, 0, 14085, 14088, 5, 1188, 0, 0, 14086, 14089, 3, 1230, 615, + 0, 14087, 14089, 5, 1184, 0, 0, 14088, 14086, 1, 0, 0, 0, 14088, 14087, + 1, 0, 0, 0, 14089, 14104, 1, 0, 0, 0, 14090, 14091, 5, 601, 0, 0, 14091, + 14092, 5, 1188, 0, 0, 14092, 14104, 7, 17, 0, 0, 14093, 14094, 5, 1011, + 0, 0, 14094, 14095, 5, 1188, 0, 0, 14095, 14104, 7, 17, 0, 0, 14096, 14097, + 5, 1023, 0, 0, 14097, 14098, 5, 1188, 0, 0, 14098, 14104, 5, 1182, 0, 0, + 14099, 14100, 5, 236, 0, 0, 14100, 14104, 7, 17, 0, 0, 14101, 14102, 5, + 1018, 0, 0, 14102, 14104, 7, 17, 0, 0, 14103, 14069, 1, 0, 0, 0, 14103, + 14078, 1, 0, 0, 0, 14103, 14084, 1, 0, 0, 0, 14103, 14090, 1, 0, 0, 0, + 14103, 14093, 1, 0, 0, 0, 14103, 14096, 1, 0, 0, 0, 14103, 14099, 1, 0, + 0, 0, 14103, 14101, 1, 0, 0, 0, 14104, 1149, 1, 0, 0, 0, 14105, 14112, + 5, 1206, 0, 0, 14106, 14107, 5, 622, 0, 0, 14107, 14108, 5, 1188, 0, 0, + 14108, 14113, 7, 168, 0, 0, 14109, 14110, 5, 269, 0, 0, 14110, 14111, 5, + 1188, 0, 0, 14111, 14113, 5, 1184, 0, 0, 14112, 14106, 1, 0, 0, 0, 14112, + 14109, 1, 0, 0, 0, 14113, 14114, 1, 0, 0, 0, 14114, 14115, 5, 1207, 0, + 0, 14115, 1151, 1, 0, 0, 0, 14116, 14119, 3, 1154, 577, 0, 14117, 14119, + 3, 1156, 578, 0, 14118, 14116, 1, 0, 0, 0, 14118, 14117, 1, 0, 0, 0, 14119, + 1153, 1, 0, 0, 0, 14120, 14121, 5, 344, 0, 0, 14121, 14124, 3, 1230, 615, + 0, 14122, 14123, 5, 181, 0, 0, 14123, 14125, 5, 353, 0, 0, 14124, 14122, + 1, 0, 0, 0, 14124, 14125, 1, 0, 0, 0, 14125, 14127, 1, 0, 0, 0, 14126, + 14128, 5, 245, 0, 0, 14127, 14126, 1, 0, 0, 0, 14127, 14128, 1, 0, 0, 0, + 14128, 14131, 1, 0, 0, 0, 14129, 14130, 5, 181, 0, 0, 14130, 14132, 5, + 575, 0, 0, 14131, 14129, 1, 0, 0, 0, 14131, 14132, 1, 0, 0, 0, 14132, 14133, + 1, 0, 0, 0, 14133, 14138, 3, 1156, 578, 0, 14134, 14135, 5, 1208, 0, 0, + 14135, 14137, 3, 1156, 578, 0, 14136, 14134, 1, 0, 0, 0, 14137, 14140, + 1, 0, 0, 0, 14138, 14136, 1, 0, 0, 0, 14138, 14139, 1, 0, 0, 0, 14139, + 1155, 1, 0, 0, 0, 14140, 14138, 1, 0, 0, 0, 14141, 14142, 5, 1206, 0, 0, + 14142, 14143, 5, 597, 0, 0, 14143, 14146, 5, 1188, 0, 0, 14144, 14147, + 3, 1230, 615, 0, 14145, 14147, 5, 1184, 0, 0, 14146, 14144, 1, 0, 0, 0, + 14146, 14145, 1, 0, 0, 0, 14147, 14149, 1, 0, 0, 0, 14148, 14150, 5, 1208, + 0, 0, 14149, 14148, 1, 0, 0, 0, 14149, 14150, 1, 0, 0, 0, 14150, 14151, + 1, 0, 0, 0, 14151, 14152, 5, 349, 0, 0, 14152, 14153, 5, 1188, 0, 0, 14153, + 14155, 5, 1184, 0, 0, 14154, 14156, 5, 1208, 0, 0, 14155, 14154, 1, 0, + 0, 0, 14155, 14156, 1, 0, 0, 0, 14156, 14163, 1, 0, 0, 0, 14157, 14158, + 5, 918, 0, 0, 14158, 14159, 5, 1188, 0, 0, 14159, 14161, 3, 1240, 620, + 0, 14160, 14162, 5, 1208, 0, 0, 14161, 14160, 1, 0, 0, 0, 14161, 14162, + 1, 0, 0, 0, 14162, 14164, 1, 0, 0, 0, 14163, 14157, 1, 0, 0, 0, 14163, + 14164, 1, 0, 0, 0, 14164, 14174, 1, 0, 0, 0, 14165, 14166, 5, 553, 0, 0, + 14166, 14169, 5, 1188, 0, 0, 14167, 14170, 3, 1240, 620, 0, 14168, 14170, + 5, 1036, 0, 0, 14169, 14167, 1, 0, 0, 0, 14169, 14168, 1, 0, 0, 0, 14170, + 14172, 1, 0, 0, 0, 14171, 14173, 5, 1208, 0, 0, 14172, 14171, 1, 0, 0, + 0, 14172, 14173, 1, 0, 0, 0, 14173, 14175, 1, 0, 0, 0, 14174, 14165, 1, + 0, 0, 0, 14174, 14175, 1, 0, 0, 0, 14175, 14182, 1, 0, 0, 0, 14176, 14177, + 5, 348, 0, 0, 14177, 14178, 5, 1188, 0, 0, 14178, 14180, 3, 1240, 620, + 0, 14179, 14181, 5, 1208, 0, 0, 14180, 14179, 1, 0, 0, 0, 14180, 14181, + 1, 0, 0, 0, 14181, 14183, 1, 0, 0, 0, 14182, 14176, 1, 0, 0, 0, 14182, + 14183, 1, 0, 0, 0, 14183, 14184, 1, 0, 0, 0, 14184, 14185, 5, 1207, 0, + 0, 14185, 1157, 1, 0, 0, 0, 14186, 14187, 3, 1230, 615, 0, 14187, 14188, + 5, 1201, 0, 0, 14188, 14189, 3, 1230, 615, 0, 14189, 14190, 5, 1201, 0, + 0, 14190, 14191, 3, 1230, 615, 0, 14191, 14192, 5, 1201, 0, 0, 14192, 14204, + 1, 0, 0, 0, 14193, 14194, 3, 1230, 615, 0, 14194, 14196, 5, 1201, 0, 0, + 14195, 14197, 3, 1230, 615, 0, 14196, 14195, 1, 0, 0, 0, 14196, 14197, + 1, 0, 0, 0, 14197, 14198, 1, 0, 0, 0, 14198, 14199, 5, 1201, 0, 0, 14199, + 14204, 1, 0, 0, 0, 14200, 14201, 3, 1230, 615, 0, 14201, 14202, 5, 1201, + 0, 0, 14202, 14204, 1, 0, 0, 0, 14203, 14186, 1, 0, 0, 0, 14203, 14193, + 1, 0, 0, 0, 14203, 14200, 1, 0, 0, 0, 14203, 14204, 1, 0, 0, 0, 14204, + 14205, 1, 0, 0, 0, 14205, 14206, 3, 1230, 615, 0, 14206, 1159, 1, 0, 0, + 0, 14207, 14213, 3, 1230, 615, 0, 14208, 14209, 3, 1230, 615, 0, 14209, + 14210, 5, 1201, 0, 0, 14210, 14211, 3, 1230, 615, 0, 14211, 14213, 1, 0, + 0, 0, 14212, 14207, 1, 0, 0, 0, 14212, 14208, 1, 0, 0, 0, 14213, 1161, + 1, 0, 0, 0, 14214, 14220, 3, 1230, 615, 0, 14215, 14216, 3, 1230, 615, + 0, 14216, 14217, 5, 1201, 0, 0, 14217, 14218, 3, 1230, 615, 0, 14218, 14220, + 1, 0, 0, 0, 14219, 14214, 1, 0, 0, 0, 14219, 14215, 1, 0, 0, 0, 14220, + 1163, 1, 0, 0, 0, 14221, 14231, 3, 1230, 615, 0, 14222, 14224, 3, 1166, + 583, 0, 14223, 14222, 1, 0, 0, 0, 14224, 14225, 1, 0, 0, 0, 14225, 14223, + 1, 0, 0, 0, 14225, 14226, 1, 0, 0, 0, 14226, 14232, 1, 0, 0, 0, 14227, + 14229, 3, 1168, 584, 0, 14228, 14230, 3, 1166, 583, 0, 14229, 14228, 1, + 0, 0, 0, 14229, 14230, 1, 0, 0, 0, 14230, 14232, 1, 0, 0, 0, 14231, 14223, + 1, 0, 0, 0, 14231, 14227, 1, 0, 0, 0, 14231, 14232, 1, 0, 0, 0, 14232, + 1165, 1, 0, 0, 0, 14233, 14234, 5, 1201, 0, 0, 14234, 14235, 3, 1230, 615, + 0, 14235, 1167, 1, 0, 0, 0, 14236, 14237, 5, 1201, 0, 0, 14237, 14238, + 5, 1201, 0, 0, 14238, 14239, 3, 1230, 615, 0, 14239, 1169, 1, 0, 0, 0, + 14240, 14241, 3, 1230, 615, 0, 14241, 14243, 5, 1201, 0, 0, 14242, 14244, + 3, 1230, 615, 0, 14243, 14242, 1, 0, 0, 0, 14243, 14244, 1, 0, 0, 0, 14244, + 14245, 1, 0, 0, 0, 14245, 14246, 5, 1201, 0, 0, 14246, 14251, 1, 0, 0, + 0, 14247, 14248, 3, 1230, 615, 0, 14248, 14249, 5, 1201, 0, 0, 14249, 14251, + 1, 0, 0, 0, 14250, 14240, 1, 0, 0, 0, 14250, 14247, 1, 0, 0, 0, 14250, + 14251, 1, 0, 0, 0, 14251, 14254, 1, 0, 0, 0, 14252, 14255, 3, 1230, 615, + 0, 14253, 14255, 5, 100, 0, 0, 14254, 14252, 1, 0, 0, 0, 14254, 14253, + 1, 0, 0, 0, 14255, 1171, 1, 0, 0, 0, 14256, 14257, 3, 1230, 615, 0, 14257, + 14258, 5, 1201, 0, 0, 14258, 14260, 1, 0, 0, 0, 14259, 14256, 1, 0, 0, + 0, 14259, 14260, 1, 0, 0, 0, 14260, 14261, 1, 0, 0, 0, 14261, 14262, 3, + 1230, 615, 0, 14262, 1173, 1, 0, 0, 0, 14263, 14264, 3, 1230, 615, 0, 14264, + 14265, 5, 1201, 0, 0, 14265, 14267, 1, 0, 0, 0, 14266, 14263, 1, 0, 0, + 0, 14266, 14267, 1, 0, 0, 0, 14267, 14268, 1, 0, 0, 0, 14268, 14269, 3, + 1230, 615, 0, 14269, 1175, 1, 0, 0, 0, 14270, 14272, 3, 1230, 615, 0, 14271, + 14270, 1, 0, 0, 0, 14271, 14272, 1, 0, 0, 0, 14272, 14273, 1, 0, 0, 0, + 14273, 14275, 5, 1201, 0, 0, 14274, 14276, 3, 1230, 615, 0, 14275, 14274, + 1, 0, 0, 0, 14275, 14276, 1, 0, 0, 0, 14276, 14277, 1, 0, 0, 0, 14277, + 14278, 5, 1201, 0, 0, 14278, 14281, 3, 1230, 615, 0, 14279, 14281, 3, 1174, + 587, 0, 14280, 14271, 1, 0, 0, 0, 14280, 14279, 1, 0, 0, 0, 14281, 1177, + 1, 0, 0, 0, 14282, 14284, 3, 1230, 615, 0, 14283, 14282, 1, 0, 0, 0, 14283, + 14284, 1, 0, 0, 0, 14284, 14285, 1, 0, 0, 0, 14285, 14287, 5, 1201, 0, + 0, 14286, 14288, 3, 1230, 615, 0, 14287, 14286, 1, 0, 0, 0, 14287, 14288, + 1, 0, 0, 0, 14288, 14289, 1, 0, 0, 0, 14289, 14291, 5, 1201, 0, 0, 14290, + 14292, 3, 1230, 615, 0, 14291, 14290, 1, 0, 0, 0, 14291, 14292, 1, 0, 0, + 0, 14292, 14293, 1, 0, 0, 0, 14293, 14294, 5, 1201, 0, 0, 14294, 14297, + 3, 1230, 615, 0, 14295, 14297, 3, 1176, 588, 0, 14296, 14283, 1, 0, 0, + 0, 14296, 14295, 1, 0, 0, 0, 14297, 1179, 1, 0, 0, 0, 14298, 14301, 3, + 1164, 582, 0, 14299, 14301, 5, 1180, 0, 0, 14300, 14298, 1, 0, 0, 0, 14300, + 14299, 1, 0, 0, 0, 14301, 1181, 1, 0, 0, 0, 14302, 14306, 7, 146, 0, 0, + 14303, 14307, 3, 1230, 615, 0, 14304, 14305, 5, 1205, 0, 0, 14305, 14307, + 7, 169, 0, 0, 14306, 14303, 1, 0, 0, 0, 14306, 14304, 1, 0, 0, 0, 14307, + 14321, 1, 0, 0, 0, 14308, 14309, 3, 1164, 582, 0, 14309, 14313, 5, 1201, + 0, 0, 14310, 14314, 3, 1230, 615, 0, 14311, 14312, 5, 1205, 0, 0, 14312, + 14314, 7, 169, 0, 0, 14313, 14310, 1, 0, 0, 0, 14313, 14311, 1, 0, 0, 0, + 14314, 14321, 1, 0, 0, 0, 14315, 14319, 3, 1230, 615, 0, 14316, 14317, + 5, 1205, 0, 0, 14317, 14319, 7, 169, 0, 0, 14318, 14315, 1, 0, 0, 0, 14318, + 14316, 1, 0, 0, 0, 14319, 14321, 1, 0, 0, 0, 14320, 14302, 1, 0, 0, 0, + 14320, 14308, 1, 0, 0, 0, 14320, 14318, 1, 0, 0, 0, 14321, 1183, 1, 0, + 0, 0, 14322, 14327, 3, 1186, 593, 0, 14323, 14324, 5, 1208, 0, 0, 14324, + 14326, 3, 1186, 593, 0, 14325, 14323, 1, 0, 0, 0, 14326, 14329, 1, 0, 0, + 0, 14327, 14325, 1, 0, 0, 0, 14327, 14328, 1, 0, 0, 0, 14328, 1185, 1, + 0, 0, 0, 14329, 14327, 1, 0, 0, 0, 14330, 14332, 3, 1230, 615, 0, 14331, + 14333, 7, 74, 0, 0, 14332, 14331, 1, 0, 0, 0, 14332, 14333, 1, 0, 0, 0, + 14333, 1187, 1, 0, 0, 0, 14334, 14339, 3, 1190, 595, 0, 14335, 14336, 5, + 1208, 0, 0, 14336, 14338, 3, 1190, 595, 0, 14337, 14335, 1, 0, 0, 0, 14338, + 14341, 1, 0, 0, 0, 14339, 14337, 1, 0, 0, 0, 14339, 14340, 1, 0, 0, 0, + 14340, 1189, 1, 0, 0, 0, 14341, 14339, 1, 0, 0, 0, 14342, 14344, 3, 1230, + 615, 0, 14343, 14342, 1, 0, 0, 0, 14343, 14344, 1, 0, 0, 0, 14344, 14345, + 1, 0, 0, 0, 14345, 14347, 5, 1201, 0, 0, 14346, 14343, 1, 0, 0, 0, 14347, + 14350, 1, 0, 0, 0, 14348, 14346, 1, 0, 0, 0, 14348, 14349, 1, 0, 0, 0, + 14349, 14351, 1, 0, 0, 0, 14350, 14348, 1, 0, 0, 0, 14351, 14352, 3, 1230, + 615, 0, 14352, 1191, 1, 0, 0, 0, 14353, 14358, 3, 1230, 615, 0, 14354, + 14355, 5, 1208, 0, 0, 14355, 14357, 3, 1230, 615, 0, 14356, 14354, 1, 0, + 0, 0, 14357, 14360, 1, 0, 0, 0, 14358, 14356, 1, 0, 0, 0, 14358, 14359, + 1, 0, 0, 0, 14359, 1193, 1, 0, 0, 0, 14360, 14358, 1, 0, 0, 0, 14361, 14364, + 3, 1230, 615, 0, 14362, 14364, 5, 1180, 0, 0, 14363, 14361, 1, 0, 0, 0, + 14363, 14362, 1, 0, 0, 0, 14364, 1195, 1, 0, 0, 0, 14365, 14366, 7, 17, + 0, 0, 14366, 1197, 1, 0, 0, 0, 14367, 14368, 7, 121, 0, 0, 14368, 1199, + 1, 0, 0, 0, 14369, 14371, 5, 627, 0, 0, 14370, 14369, 1, 0, 0, 0, 14370, + 14371, 1, 0, 0, 0, 14371, 14372, 1, 0, 0, 0, 14372, 14373, 5, 643, 0, 0, + 14373, 1201, 1, 0, 0, 0, 14374, 14380, 3, 1178, 589, 0, 14375, 14380, 5, + 830, 0, 0, 14376, 14380, 5, 511, 0, 0, 14377, 14380, 5, 94, 0, 0, 14378, + 14380, 5, 140, 0, 0, 14379, 14374, 1, 0, 0, 0, 14379, 14375, 1, 0, 0, 0, + 14379, 14376, 1, 0, 0, 0, 14379, 14377, 1, 0, 0, 0, 14379, 14378, 1, 0, + 0, 0, 14380, 1203, 1, 0, 0, 0, 14381, 14382, 5, 90, 0, 0, 14382, 14383, + 5, 191, 0, 0, 14383, 14384, 5, 998, 0, 0, 14384, 14385, 5, 1206, 0, 0, + 14385, 14386, 5, 1180, 0, 0, 14386, 14387, 5, 1207, 0, 0, 14387, 14388, + 5, 997, 0, 0, 14388, 14389, 5, 1188, 0, 0, 14389, 14391, 3, 486, 243, 0, + 14390, 14392, 5, 1209, 0, 0, 14391, 14390, 1, 0, 0, 0, 14391, 14392, 1, + 0, 0, 0, 14392, 1205, 1, 0, 0, 0, 14393, 14394, 5, 90, 0, 0, 14394, 14396, + 5, 266, 0, 0, 14395, 14397, 5, 191, 0, 0, 14396, 14395, 1, 0, 0, 0, 14396, + 14397, 1, 0, 0, 0, 14397, 14398, 1, 0, 0, 0, 14398, 14399, 5, 1180, 0, + 0, 14399, 14400, 5, 380, 0, 0, 14400, 14401, 5, 891, 0, 0, 14401, 14402, + 3, 1210, 605, 0, 14402, 14403, 5, 1000, 0, 0, 14403, 14404, 5, 891, 0, + 0, 14404, 14407, 3, 1210, 605, 0, 14405, 14406, 5, 1208, 0, 0, 14406, 14408, + 5, 1184, 0, 0, 14407, 14405, 1, 0, 0, 0, 14407, 14408, 1, 0, 0, 0, 14408, + 14409, 1, 0, 0, 0, 14409, 14410, 5, 662, 0, 0, 14410, 14411, 5, 188, 0, + 0, 14411, 14434, 3, 1208, 604, 0, 14412, 14419, 5, 1077, 0, 0, 14413, 14414, + 7, 170, 0, 0, 14414, 14415, 5, 1188, 0, 0, 14415, 14417, 5, 1180, 0, 0, + 14416, 14418, 5, 1208, 0, 0, 14417, 14416, 1, 0, 0, 0, 14417, 14418, 1, + 0, 0, 0, 14418, 14420, 1, 0, 0, 0, 14419, 14413, 1, 0, 0, 0, 14419, 14420, + 1, 0, 0, 0, 14420, 14427, 1, 0, 0, 0, 14421, 14422, 5, 519, 0, 0, 14422, + 14423, 5, 1188, 0, 0, 14423, 14425, 7, 0, 0, 0, 14424, 14426, 5, 1208, + 0, 0, 14425, 14424, 1, 0, 0, 0, 14425, 14426, 1, 0, 0, 0, 14426, 14428, + 1, 0, 0, 0, 14427, 14421, 1, 0, 0, 0, 14427, 14428, 1, 0, 0, 0, 14428, + 14432, 1, 0, 0, 0, 14429, 14430, 5, 297, 0, 0, 14430, 14431, 5, 1188, 0, + 0, 14431, 14433, 3, 1196, 598, 0, 14432, 14429, 1, 0, 0, 0, 14432, 14433, + 1, 0, 0, 0, 14433, 14435, 1, 0, 0, 0, 14434, 14412, 1, 0, 0, 0, 14434, + 14435, 1, 0, 0, 0, 14435, 14437, 1, 0, 0, 0, 14436, 14438, 5, 1209, 0, + 0, 14437, 14436, 1, 0, 0, 0, 14437, 14438, 1, 0, 0, 0, 14438, 1207, 1, + 0, 0, 0, 14439, 14442, 3, 1230, 615, 0, 14440, 14442, 3, 926, 463, 0, 14441, + 14439, 1, 0, 0, 0, 14441, 14440, 1, 0, 0, 0, 14442, 1209, 1, 0, 0, 0, 14443, + 14446, 3, 1230, 615, 0, 14444, 14446, 3, 926, 463, 0, 14445, 14443, 1, + 0, 0, 0, 14445, 14444, 1, 0, 0, 0, 14446, 1211, 1, 0, 0, 0, 14447, 14448, + 5, 299, 0, 0, 14448, 14449, 5, 191, 0, 0, 14449, 14451, 5, 1180, 0, 0, + 14450, 14452, 5, 1209, 0, 0, 14451, 14450, 1, 0, 0, 0, 14451, 14452, 1, + 0, 0, 0, 14452, 14465, 1, 0, 0, 0, 14453, 14460, 5, 1077, 0, 0, 14454, + 14455, 5, 303, 0, 0, 14455, 14456, 5, 1188, 0, 0, 14456, 14457, 7, 1, 0, + 0, 14457, 14458, 5, 261, 0, 0, 14458, 14459, 5, 1188, 0, 0, 14459, 14461, + 7, 1, 0, 0, 14460, 14454, 1, 0, 0, 0, 14460, 14461, 1, 0, 0, 0, 14461, + 14463, 1, 0, 0, 0, 14462, 14464, 5, 147, 0, 0, 14463, 14462, 1, 0, 0, 0, + 14463, 14464, 1, 0, 0, 0, 14464, 14466, 1, 0, 0, 0, 14465, 14453, 1, 0, + 0, 0, 14465, 14466, 1, 0, 0, 0, 14466, 1213, 1, 0, 0, 0, 14467, 14469, + 5, 1070, 0, 0, 14468, 14467, 1, 0, 0, 0, 14468, 14469, 1, 0, 0, 0, 14469, + 14470, 1, 0, 0, 0, 14470, 14471, 5, 1206, 0, 0, 14471, 14472, 3, 1216, + 608, 0, 14472, 14478, 5, 1207, 0, 0, 14473, 14475, 5, 1208, 0, 0, 14474, + 14473, 1, 0, 0, 0, 14474, 14475, 1, 0, 0, 0, 14475, 14476, 1, 0, 0, 0, + 14476, 14477, 5, 997, 0, 0, 14477, 14479, 3, 486, 243, 0, 14478, 14474, + 1, 0, 0, 0, 14478, 14479, 1, 0, 0, 0, 14479, 14481, 1, 0, 0, 0, 14480, + 14482, 5, 1209, 0, 0, 14481, 14480, 1, 0, 0, 0, 14481, 14482, 1, 0, 0, + 0, 14482, 1215, 1, 0, 0, 0, 14483, 14484, 5, 395, 0, 0, 14484, 14485, 5, + 191, 0, 0, 14485, 14486, 5, 412, 0, 0, 14486, 14487, 7, 1, 0, 0, 14487, + 14488, 5, 380, 0, 0, 14488, 14490, 3, 1218, 609, 0, 14489, 14491, 5, 1209, + 0, 0, 14490, 14489, 1, 0, 0, 0, 14490, 14491, 1, 0, 0, 0, 14491, 1217, + 1, 0, 0, 0, 14492, 14493, 3, 1230, 615, 0, 14493, 14494, 5, 1201, 0, 0, + 14494, 14495, 3, 1230, 615, 0, 14495, 14496, 5, 1201, 0, 0, 14496, 14497, + 3, 1230, 615, 0, 14497, 14500, 1, 0, 0, 0, 14498, 14500, 3, 1230, 615, + 0, 14499, 14492, 1, 0, 0, 0, 14499, 14498, 1, 0, 0, 0, 14500, 1219, 1, + 0, 0, 0, 14501, 14502, 5, 884, 0, 0, 14502, 14503, 5, 662, 0, 0, 14503, + 14504, 5, 191, 0, 0, 14504, 14505, 7, 1, 0, 0, 14505, 14506, 5, 578, 0, + 0, 14506, 14507, 5, 1024, 0, 0, 14507, 14511, 3, 926, 463, 0, 14508, 14509, + 5, 1206, 0, 0, 14509, 14510, 7, 1, 0, 0, 14510, 14512, 5, 1207, 0, 0, 14511, + 14508, 1, 0, 0, 0, 14511, 14512, 1, 0, 0, 0, 14512, 14514, 1, 0, 0, 0, + 14513, 14515, 5, 1209, 0, 0, 14514, 14513, 1, 0, 0, 0, 14514, 14515, 1, + 0, 0, 0, 14515, 1221, 1, 0, 0, 0, 14516, 14517, 7, 171, 0, 0, 14517, 14518, + 5, 1206, 0, 0, 14518, 14519, 5, 550, 0, 0, 14519, 14548, 5, 1207, 0, 0, + 14520, 14521, 3, 1230, 615, 0, 14521, 14522, 5, 1206, 0, 0, 14522, 14523, + 5, 1182, 0, 0, 14523, 14524, 5, 1208, 0, 0, 14524, 14525, 5, 1182, 0, 0, + 14525, 14526, 5, 1207, 0, 0, 14526, 14548, 1, 0, 0, 0, 14527, 14528, 3, + 1230, 615, 0, 14528, 14529, 5, 1206, 0, 0, 14529, 14530, 5, 1182, 0, 0, + 14530, 14531, 5, 1207, 0, 0, 14531, 14548, 1, 0, 0, 0, 14532, 14533, 3, + 1230, 615, 0, 14533, 14539, 5, 433, 0, 0, 14534, 14535, 5, 1206, 0, 0, + 14535, 14536, 5, 1182, 0, 0, 14536, 14537, 5, 1208, 0, 0, 14537, 14538, + 5, 1182, 0, 0, 14538, 14540, 5, 1207, 0, 0, 14539, 14534, 1, 0, 0, 0, 14539, + 14540, 1, 0, 0, 0, 14540, 14548, 1, 0, 0, 0, 14541, 14543, 5, 279, 0, 0, + 14542, 14544, 5, 728, 0, 0, 14543, 14542, 1, 0, 0, 0, 14543, 14544, 1, + 0, 0, 0, 14544, 14548, 1, 0, 0, 0, 14545, 14548, 7, 172, 0, 0, 14546, 14548, + 3, 1230, 615, 0, 14547, 14516, 1, 0, 0, 0, 14547, 14520, 1, 0, 0, 0, 14547, + 14527, 1, 0, 0, 0, 14547, 14532, 1, 0, 0, 0, 14547, 14541, 1, 0, 0, 0, + 14547, 14545, 1, 0, 0, 0, 14547, 14546, 1, 0, 0, 0, 14548, 1223, 1, 0, + 0, 0, 14549, 14565, 5, 1184, 0, 0, 14550, 14565, 5, 1185, 0, 0, 14551, + 14553, 5, 1216, 0, 0, 14552, 14551, 1, 0, 0, 0, 14552, 14553, 1, 0, 0, + 0, 14553, 14554, 1, 0, 0, 0, 14554, 14565, 7, 64, 0, 0, 14555, 14557, 5, + 1216, 0, 0, 14556, 14555, 1, 0, 0, 0, 14556, 14557, 1, 0, 0, 0, 14557, + 14558, 1, 0, 0, 0, 14558, 14560, 5, 1205, 0, 0, 14559, 14561, 7, 136, 0, + 0, 14560, 14559, 1, 0, 0, 0, 14560, 14561, 1, 0, 0, 0, 14561, 14562, 1, + 0, 0, 0, 14562, 14565, 7, 173, 0, 0, 14563, 14565, 3, 928, 464, 0, 14564, + 14549, 1, 0, 0, 0, 14564, 14550, 1, 0, 0, 0, 14564, 14552, 1, 0, 0, 0, + 14564, 14556, 1, 0, 0, 0, 14564, 14563, 1, 0, 0, 0, 14565, 1225, 1, 0, + 0, 0, 14566, 14576, 5, 1184, 0, 0, 14567, 14576, 5, 1185, 0, 0, 14568, + 14576, 7, 64, 0, 0, 14569, 14571, 5, 1205, 0, 0, 14570, 14572, 7, 136, + 0, 0, 14571, 14570, 1, 0, 0, 0, 14571, 14572, 1, 0, 0, 0, 14572, 14573, + 1, 0, 0, 0, 14573, 14576, 7, 173, 0, 0, 14574, 14576, 3, 928, 464, 0, 14575, + 14566, 1, 0, 0, 0, 14575, 14567, 1, 0, 0, 0, 14575, 14568, 1, 0, 0, 0, + 14575, 14569, 1, 0, 0, 0, 14575, 14574, 1, 0, 0, 0, 14576, 1227, 1, 0, + 0, 0, 14577, 14578, 7, 174, 0, 0, 14578, 1229, 1, 0, 0, 0, 14579, 14587, + 5, 1183, 0, 0, 14580, 14587, 5, 1181, 0, 0, 14581, 14587, 5, 1176, 0, 0, + 14582, 14587, 5, 1177, 0, 0, 14583, 14587, 5, 1179, 0, 0, 14584, 14587, + 3, 1228, 614, 0, 14585, 14587, 5, 763, 0, 0, 14586, 14579, 1, 0, 0, 0, + 14586, 14580, 1, 0, 0, 0, 14586, 14581, 1, 0, 0, 0, 14586, 14582, 1, 0, + 0, 0, 14586, 14583, 1, 0, 0, 0, 14586, 14584, 1, 0, 0, 0, 14586, 14585, + 1, 0, 0, 0, 14587, 1231, 1, 0, 0, 0, 14588, 14589, 5, 1183, 0, 0, 14589, + 1233, 1, 0, 0, 0, 14590, 14593, 3, 1230, 615, 0, 14591, 14593, 5, 1184, + 0, 0, 14592, 14590, 1, 0, 0, 0, 14592, 14591, 1, 0, 0, 0, 14593, 1235, + 1, 0, 0, 0, 14594, 14610, 5, 1188, 0, 0, 14595, 14610, 5, 1189, 0, 0, 14596, + 14610, 5, 1190, 0, 0, 14597, 14598, 5, 1190, 0, 0, 14598, 14610, 5, 1188, + 0, 0, 14599, 14600, 5, 1189, 0, 0, 14600, 14610, 5, 1188, 0, 0, 14601, + 14602, 5, 1190, 0, 0, 14602, 14610, 5, 1189, 0, 0, 14603, 14604, 5, 1191, + 0, 0, 14604, 14610, 5, 1188, 0, 0, 14605, 14606, 5, 1191, 0, 0, 14606, + 14610, 5, 1189, 0, 0, 14607, 14608, 5, 1191, 0, 0, 14608, 14610, 5, 1190, + 0, 0, 14609, 14594, 1, 0, 0, 0, 14609, 14595, 1, 0, 0, 0, 14609, 14596, + 1, 0, 0, 0, 14609, 14597, 1, 0, 0, 0, 14609, 14599, 1, 0, 0, 0, 14609, + 14601, 1, 0, 0, 0, 14609, 14603, 1, 0, 0, 0, 14609, 14605, 1, 0, 0, 0, + 14609, 14607, 1, 0, 0, 0, 14610, 1237, 1, 0, 0, 0, 14611, 14612, 7, 175, + 0, 0, 14612, 1239, 1, 0, 0, 0, 14613, 14615, 5, 1182, 0, 0, 14614, 14616, + 7, 176, 0, 0, 14615, 14614, 1, 0, 0, 0, 14615, 14616, 1, 0, 0, 0, 14616, + 1241, 1, 0, 0, 0, 1848, 1245, 1252, 1256, 1260, 1264, 1269, 1276, 1279, + 1285, 1289, 1293, 1297, 1301, 1305, 1309, 1312, 1319, 1487, 1494, 1508, + 1512, 1517, 1522, 1526, 1530, 1535, 1540, 1542, 1546, 1549, 1556, 1559, + 1568, 1571, 1582, 1587, 1592, 1597, 1602, 1608, 1612, 1615, 1619, 1622, + 1625, 1632, 1636, 1638, 1643, 1649, 1653, 1665, 1669, 1675, 1678, 1687, + 1690, 1711, 1719, 1724, 1727, 1732, 1735, 1740, 1749, 1761, 1766, 1769, + 1774, 1780, 1785, 1802, 1805, 1808, 1811, 1816, 1825, 1840, 1857, 1868, + 1874, 1889, 1904, 1913, 1917, 1922, 1928, 1934, 1937, 1942, 1947, 1955, + 1965, 1984, 1992, 2005, 2007, 2019, 2021, 2028, 2037, 2043, 2052, 2066, + 2076, 2086, 2126, 2149, 2185, 2187, 2205, 2229, 2232, 2246, 2278, 2296, + 2299, 2304, 2307, 2312, 2315, 2320, 2323, 2328, 2331, 2339, 2342, 2350, + 2363, 2374, 2379, 2383, 2389, 2412, 2424, 2435, 2440, 2444, 2450, 2452, + 2465, 2488, 2495, 2504, 2509, 2512, 2517, 2520, 2525, 2530, 2558, 2566, + 2572, 2579, 2581, 2594, 2601, 2616, 2634, 2637, 2639, 2644, 2648, 2651, + 2653, 2659, 2662, 2664, 2670, 2672, 2694, 2702, 2710, 2712, 2714, 2723, + 2744, 2757, 2772, 2776, 2811, 2814, 2819, 2842, 2845, 2850, 2876, 2890, + 2895, 2903, 2908, 2915, 2936, 2973, 2978, 2997, 3009, 3012, 3017, 3020, + 3026, 3041, 3046, 3054, 3057, 3062, 3067, 3070, 3094, 3101, 3106, 3111, + 3116, 3118, 3125, 3138, 3144, 3149, 3157, 3173, 3180, 3185, 3190, 3193, + 3199, 3205, 3210, 3215, 3220, 3223, 3229, 3235, 3246, 3249, 3259, 3265, + 3269, 3273, 3302, 3315, 3321, 3331, 3334, 3350, 3355, 3371, 3374, 3377, + 3382, 3385, 3390, 3399, 3402, 3405, 3412, 3420, 3424, 3426, 3428, 3434, + 3438, 3443, 3446, 3448, 3460, 3463, 3465, 3476, 3480, 3484, 3489, 3504, + 3511, 3520, 3528, 3531, 3536, 3541, 3549, 3555, 3559, 3565, 3570, 3574, + 3581, 3589, 3597, 3606, 3611, 3615, 3618, 3622, 3628, 3633, 3641, 3649, + 3655, 3661, 3664, 3669, 3672, 3679, 3681, 3684, 3690, 3693, 3698, 3701, + 3706, 3709, 3714, 3717, 3722, 3725, 3728, 3731, 3738, 3742, 3749, 3756, + 3762, 3775, 3779, 3784, 3794, 3803, 3807, 3819, 3825, 3830, 3832, 3852, + 3856, 3864, 3873, 3879, 3885, 3893, 3895, 3905, 3909, 3912, 3916, 3921, + 3927, 3930, 3934, 3942, 3944, 3947, 3955, 3963, 3970, 3977, 3979, 3981, + 3986, 3992, 3995, 3997, 3999, 4002, 4007, 4010, 4015, 4030, 4037, 4044, + 4046, 4048, 4053, 4059, 4062, 4064, 4066, 4069, 4074, 4077, 4082, 4095, + 4100, 4109, 4114, 4120, 4124, 4128, 4145, 4147, 4157, 4162, 4164, 4168, + 4174, 4182, 4187, 4190, 4198, 4201, 4206, 4211, 4216, 4221, 4226, 4231, + 4235, 4240, 4251, 4256, 4259, 4262, 4267, 4270, 4275, 4278, 4283, 4286, + 4291, 4294, 4299, 4302, 4307, 4313, 4318, 4321, 4326, 4333, 4335, 4341, + 4350, 4355, 4357, 4369, 4375, 4387, 4390, 4395, 4397, 4407, 4412, 4414, + 4418, 4424, 4442, 4444, 4459, 4477, 4485, 4495, 4511, 4532, 4543, 4549, + 4558, 4567, 4573, 4582, 4587, 4590, 4595, 4598, 4603, 4606, 4614, 4620, + 4624, 4631, 4637, 4641, 4644, 4646, 4649, 4654, 4657, 4662, 4665, 4670, + 4673, 4678, 4681, 4696, 4707, 4718, 4725, 4728, 4736, 4742, 4751, 4758, + 4767, 4777, 4782, 4796, 4807, 4814, 4817, 4825, 4832, 4839, 4843, 4848, + 4851, 4856, 4859, 4864, 4867, 4876, 4883, 4898, 4901, 4906, 4917, 4926, + 4937, 4943, 4945, 4953, 4961, 4966, 4977, 4980, 4984, 4992, 4996, 5000, + 5008, 5013, 5021, 5026, 5030, 5032, 5037, 5046, 5049, 5054, 5061, 5067, + 5069, 5074, 5080, 5086, 5091, 5097, 5104, 5109, 5114, 5119, 5122, 5126, + 5129, 5133, 5137, 5140, 5144, 5149, 5153, 5157, 5167, 5173, 5180, 5183, + 5189, 5195, 5200, 5202, 5208, 5210, 5215, 5221, 5227, 5232, 5234, 5238, + 5242, 5245, 5259, 5264, 5268, 5281, 5284, 5286, 5294, 5304, 5310, 5317, + 5320, 5326, 5332, 5337, 5339, 5345, 5347, 5352, 5358, 5364, 5370, 5375, + 5377, 5381, 5385, 5388, 5402, 5407, 5411, 5424, 5427, 5429, 5437, 5448, + 5457, 5466, 5477, 5486, 5495, 5507, 5511, 5516, 5518, 5520, 5525, 5529, + 5534, 5536, 5538, 5552, 5557, 5579, 5601, 5606, 5619, 5627, 5645, 5648, + 5656, 5661, 5672, 5679, 5684, 5688, 5692, 5695, 5702, 5720, 5722, 5742, + 5749, 5756, 5761, 5766, 5772, 5777, 5779, 5786, 5792, 5798, 5801, 5807, + 5817, 5820, 5827, 5830, 5835, 5837, 5845, 5849, 5855, 5860, 5862, 5865, + 5872, 5878, 5885, 5888, 5894, 5899, 5901, 5904, 5912, 5918, 5925, 5928, + 5934, 5939, 5941, 5949, 5957, 5963, 5968, 5970, 5980, 5985, 5995, 6001, + 6013, 6015, 6022, 6028, 6034, 6040, 6045, 6047, 6054, 6062, 6068, 6082, + 6084, 6087, 6092, 6094, 6106, 6112, 6126, 6128, 6131, 6136, 6139, 6144, + 6146, 6155, 6162, 6174, 6190, 6199, 6208, 6211, 6216, 6223, 6225, 6231, + 6233, 6241, 6243, 6249, 6251, 6257, 6259, 6266, 6269, 6271, 6274, 6278, + 6280, 6290, 6296, 6300, 6308, 6315, 6321, 6323, 6334, 6339, 6345, 6349, + 6359, 6367, 6379, 6382, 6390, 6392, 6395, 6399, 6402, 6411, 6414, 6417, + 6425, 6431, 6438, 6442, 6453, 6459, 6461, 6470, 6474, 6481, 6486, 6489, + 6497, 6501, 6504, 6508, 6511, 6514, 6521, 6525, 6527, 6529, 6532, 6535, + 6538, 6543, 6546, 6554, 6556, 6559, 6563, 6566, 6572, 6575, 6579, 6582, + 6585, 6591, 6594, 6601, 6607, 6611, 6621, 6624, 6627, 6633, 6636, 6639, + 6642, 6646, 6649, 6657, 6659, 6663, 6666, 6674, 6678, 6682, 6689, 6693, + 6695, 6697, 6700, 6703, 6706, 6714, 6720, 6726, 6728, 6732, 6735, 6743, + 6747, 6754, 6757, 6766, 6769, 6773, 6781, 6784, 6788, 6791, 6805, 6809, + 6812, 6816, 6819, 6831, 6834, 6838, 6841, 6853, 6878, 6887, 6890, 6906, + 6917, 6929, 6935, 6944, 6949, 6958, 6970, 6973, 6979, 6982, 6991, 7002, + 7011, 7035, 7037, 7043, 7046, 7053, 7055, 7064, 7094, 7097, 7106, 7121, + 7127, 7129, 7138, 7156, 7162, 7171, 7174, 7176, 7184, 7190, 7194, 7207, + 7211, 7214, 7223, 7241, 7247, 7249, 7253, 7265, 7268, 7272, 7275, 7279, + 7295, 7297, 7299, 7302, 7305, 7314, 7341, 7344, 7358, 7363, 7366, 7372, + 7375, 7382, 7386, 7388, 7396, 7399, 7403, 7410, 7413, 7425, 7430, 7433, + 7445, 7448, 7454, 7461, 7466, 7471, 7477, 7481, 7488, 7491, 7499, 7507, + 7510, 7518, 7525, 7532, 7535, 7545, 7552, 7557, 7560, 7570, 7573, 7576, + 7585, 7587, 7598, 7601, 7604, 7611, 7616, 7620, 7622, 7632, 7635, 7638, + 7645, 7651, 7655, 7661, 7665, 7670, 7674, 7678, 7681, 7686, 7700, 7716, + 7720, 7726, 7728, 7731, 7743, 7748, 7751, 7759, 7764, 7769, 7775, 7780, + 7784, 7808, 7816, 7821, 7825, 7830, 7835, 7842, 7847, 7850, 7855, 7858, + 7872, 7879, 7883, 7885, 7894, 7904, 7907, 7911, 7918, 7939, 7944, 7948, + 7957, 7963, 7965, 7974, 8007, 8013, 8015, 8020, 8023, 8031, 8039, 8042, + 8049, 8052, 8071, 8080, 8091, 8104, 8108, 8110, 8118, 8126, 8132, 8135, + 8138, 8141, 8147, 8151, 8159, 8171, 8183, 8187, 8190, 8199, 8205, 8215, + 8224, 8234, 8240, 8246, 8253, 8259, 8263, 8274, 8289, 8291, 8318, 8329, + 8337, 8349, 8354, 8358, 8367, 8377, 8384, 8389, 8405, 8408, 8411, 8416, + 8419, 8424, 8433, 8436, 8439, 8446, 8456, 8476, 8482, 8507, 8509, 8535, + 8541, 8552, 8560, 8563, 8580, 8588, 8595, 8618, 8631, 8637, 8644, 8652, + 8655, 8658, 8667, 8677, 8684, 8688, 8692, 8698, 8705, 8709, 8715, 8722, + 8729, 8732, 8738, 8745, 8749, 8754, 8759, 8764, 8772, 8779, 8783, 8789, + 8796, 8800, 8808, 8810, 8818, 8824, 8830, 8847, 8851, 8859, 8864, 8872, + 8878, 8889, 8894, 8901, 8905, 8909, 8913, 8916, 8920, 8926, 8930, 8932, + 8939, 8946, 8949, 8952, 8959, 8964, 8969, 8973, 8979, 8983, 8985, 8990, + 8995, 8999, 9004, 9010, 9014, 9018, 9020, 9024, 9028, 9032, 9036, 9042, + 9045, 9051, 9055, 9059, 9065, 9071, 9073, 9076, 9080, 9084, 9088, 9094, + 9097, 9103, 9109, 9112, 9118, 9121, 9127, 9130, 9134, 9138, 9142, 9147, + 9150, 9154, 9158, 9175, 9177, 9179, 9182, 9189, 9194, 9198, 9204, 9208, + 9210, 9215, 9220, 9224, 9229, 9235, 9239, 9243, 9245, 9249, 9253, 9257, + 9261, 9267, 9270, 9276, 9280, 9284, 9290, 9296, 9298, 9301, 9305, 9309, + 9313, 9319, 9322, 9328, 9334, 9337, 9343, 9346, 9352, 9355, 9359, 9363, + 9367, 9372, 9375, 9379, 9383, 9389, 9392, 9396, 9413, 9415, 9417, 9420, + 9434, 9440, 9448, 9455, 9457, 9460, 9493, 9497, 9501, 9508, 9517, 9525, + 9528, 9531, 9535, 9539, 9542, 9550, 9558, 9562, 9569, 9571, 9578, 9586, + 9589, 9600, 9605, 9609, 9615, 9617, 9624, 9626, 9628, 9632, 9637, 9644, + 9646, 9652, 9655, 9663, 9669, 9673, 9676, 9683, 9686, 9692, 9696, 9703, + 9708, 9716, 9721, 9733, 9735, 9746, 9753, 9763, 9786, 9799, 9815, 9820, + 9827, 9830, 9834, 9836, 9853, 9868, 9876, 9885, 9893, 9901, 9918, 9931, + 9943, 9967, 9974, 9978, 9988, 9992, 10009, 10048, 10055, 10063, 10075, + 10097, 10106, 10108, 10114, 10134, 10136, 10138, 10141, 10148, 10154, 10159, + 10161, 10167, 10175, 10177, 10181, 10191, 10195, 10201, 10203, 10207, 10214, + 10219, 10224, 10228, 10237, 10243, 10252, 10255, 10257, 10264, 10267, 10271, + 10279, 10282, 10290, 10293, 10305, 10312, 10316, 10319, 10327, 10330, 10340, + 10346, 10350, 10353, 10361, 10364, 10375, 10377, 10386, 10389, 10396, 10401, + 10405, 10410, 10426, 10429, 10436, 10440, 10445, 10454, 10458, 10466, 10469, + 10478, 10481, 10485, 10494, 10496, 10501, 10509, 10516, 10520, 10538, 10546, + 10551, 10557, 10562, 10571, 10574, 10577, 10588, 10593, 10604, 10609, 10615, + 10622, 10624, 10629, 10633, 10648, 10658, 10669, 10688, 10709, 10711, 10713, + 10721, 10725, 10731, 10734, 10739, 10743, 10748, 10751, 10754, 10759, 10761, + 10771, 10775, 10780, 10783, 10804, 10815, 10818, 10828, 10831, 10834, 10843, + 10845, 10851, 10857, 10872, 10883, 10892, 10928, 10934, 10948, 10953, 10957, + 10969, 10972, 10981, 10983, 10993, 10995, 10997, 11000, 11003, 11014, 11016, + 11018, 11021, 11026, 11037, 11046, 11049, 11052, 11061, 11064, 11067, 11074, + 11077, 11084, 11090, 11096, 11111, 11114, 11121, 11129, 11136, 11142, 11153, + 11167, 11177, 11179, 11193, 11200, 11204, 11212, 11216, 11220, 11226, 11236, + 11246, 11254, 11266, 11272, 11276, 11286, 11290, 11294, 11304, 11310, 11318, + 11326, 11328, 11356, 11368, 11375, 11383, 11390, 11396, 11400, 11405, 11413, + 11416, 11418, 11422, 11426, 11433, 11437, 11440, 11445, 11448, 11452, 11455, + 11458, 11463, 11470, 11481, 11486, 11497, 11501, 11510, 11517, 11526, 11539, + 11541, 11551, 11554, 11559, 11568, 11570, 11572, 11577, 11579, 11587, 11592, + 11600, 11605, 11611, 11613, 11625, 11629, 11632, 11642, 11644, 11649, 11652, + 11659, 11663, 11667, 11678, 11712, 11728, 11735, 11737, 11744, 11753, 11761, + 11767, 11774, 11780, 11783, 11785, 11793, 11795, 11802, 11806, 11813, 11820, + 11829, 11834, 11838, 11845, 11847, 11851, 11856, 11858, 11863, 11865, 11869, + 11876, 11878, 11885, 11891, 11900, 11908, 11911, 11918, 11926, 11929, 11936, + 11942, 11949, 11955, 11959, 11984, 11987, 11991, 11993, 11996, 12042, 12063, + 12067, 12071, 12085, 12095, 12104, 12111, 12116, 12136, 12142, 12149, 12153, + 12168, 12174, 12193, 12204, 12217, 12228, 12237, 12243, 12250, 12254, 12327, + 12333, 12432, 12444, 12453, 12462, 12493, 12499, 12551, 12564, 12580, 12599, + 12642, 12696, 12698, 12714, 12757, 12780, 12783, 12794, 12797, 12846, 12854, + 12865, 12926, 12976, 13006, 13136, 13215, 13219, 13240, 13259, 13270, 13273, + 13276, 13282, 13285, 13300, 13382, 13409, 13419, 13470, 13478, 13497, 13499, + 13513, 13522, 13541, 13543, 13558, 13571, 13577, 13585, 13587, 13593, 13601, + 13607, 13610, 13616, 13627, 13636, 13645, 13657, 13675, 13691, 13707, 13747, + 13759, 13767, 13786, 13791, 13801, 13806, 13818, 13830, 13842, 13852, 13878, + 13882, 13890, 13897, 13910, 13918, 13931, 13938, 13944, 13948, 13965, 13980, + 13982, 13995, 14014, 14018, 14021, 14030, 14033, 14036, 14049, 14053, 14061, + 14067, 14075, 14082, 14088, 14103, 14112, 14118, 14124, 14127, 14131, 14138, + 14146, 14149, 14155, 14161, 14163, 14169, 14172, 14174, 14180, 14182, 14196, + 14203, 14212, 14219, 14225, 14229, 14231, 14243, 14250, 14254, 14259, 14266, + 14271, 14275, 14280, 14283, 14287, 14291, 14296, 14300, 14306, 14313, 14318, + 14320, 14327, 14332, 14339, 14343, 14348, 14358, 14363, 14370, 14379, 14391, + 14396, 14407, 14417, 14419, 14425, 14427, 14432, 14434, 14437, 14441, 14445, + 14451, 14460, 14463, 14465, 14468, 14474, 14478, 14481, 14490, 14499, 14511, + 14514, 14539, 14543, 14547, 14552, 14556, 14560, 14564, 14571, 14575, 14586, + 14592, 14609, 14615, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// TSqlParserInit initializes any static state used to implement TSqlParser. By default the +// static state used to implement the parser is lazily initialized during the first call to +// NewTSqlParser(). You can call this function if you wish to initialize the static state ahead +// of time. +func TSqlParserInit() { + staticData := &TSqlParserParserStaticData + staticData.once.Do(tsqlparserParserInit) +} + +// NewTSqlParser produces a new parser instance for the optional input antlr.TokenStream. +func NewTSqlParser(input antlr.TokenStream) *TSqlParser { + TSqlParserInit() + this := new(TSqlParser) + this.BaseParser = antlr.NewBaseParser(input) + staticData := &TSqlParserParserStaticData + this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) + this.RuleNames = staticData.RuleNames + this.LiteralNames = staticData.LiteralNames + this.SymbolicNames = staticData.SymbolicNames + this.GrammarFileName = "TSqlParser.g4" + + return this +} + +// TSqlParser tokens. +const ( + TSqlParserEOF = antlr.TokenEOF + TSqlParserABORT = 1 + TSqlParserABORT_AFTER_WAIT = 2 + TSqlParserABSENT = 3 + TSqlParserABSOLUTE = 4 + TSqlParserACCELERATED_DATABASE_RECOVERY = 5 + TSqlParserACCENT_SENSITIVITY = 6 + TSqlParserACCESS = 7 + TSqlParserACTION = 8 + TSqlParserACTIVATION = 9 + TSqlParserACTIVE = 10 + TSqlParserADD = 11 + TSqlParserADDRESS = 12 + TSqlParserADMINISTER = 13 + TSqlParserAES = 14 + TSqlParserAES_128 = 15 + TSqlParserAES_192 = 16 + TSqlParserAES_256 = 17 + TSqlParserAFFINITY = 18 + TSqlParserAFTER = 19 + TSqlParserAGGREGATE = 20 + TSqlParserALGORITHM = 21 + TSqlParserALL = 22 + TSqlParserALLOWED = 23 + TSqlParserALLOW_CONNECTIONS = 24 + TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS = 25 + TSqlParserALLOW_MULTIPLE_EVENT_LOSS = 26 + TSqlParserALLOW_PAGE_LOCKS = 27 + TSqlParserALLOW_ROW_LOCKS = 28 + TSqlParserALLOW_SINGLE_EVENT_LOSS = 29 + TSqlParserALLOW_SNAPSHOT_ISOLATION = 30 + TSqlParserALL_CONSTRAINTS = 31 + TSqlParserALL_ERRORMSGS = 32 + TSqlParserALL_INDEXES = 33 + TSqlParserALL_LEVELS = 34 + TSqlParserALTER = 35 + TSqlParserALWAYS = 36 + TSqlParserAND = 37 + TSqlParserANONYMOUS = 38 + TSqlParserANSI_DEFAULTS = 39 + TSqlParserANSI_NULLS = 40 + TSqlParserANSI_NULL_DEFAULT = 41 + TSqlParserANSI_NULL_DFLT_OFF = 42 + TSqlParserANSI_NULL_DFLT_ON = 43 + TSqlParserANSI_PADDING = 44 + TSqlParserANSI_WARNINGS = 45 + TSqlParserANY = 46 + TSqlParserAPPEND = 47 + TSqlParserAPPLICATION = 48 + TSqlParserAPPLICATION_LOG = 49 + TSqlParserAPPLOCK_MODE = 50 + TSqlParserAPPLOCK_TEST = 51 + TSqlParserAPPLY = 52 + TSqlParserAPP_NAME = 53 + TSqlParserARITHABORT = 54 + TSqlParserARITHIGNORE = 55 + TSqlParserAS = 56 + TSqlParserASC = 57 + TSqlParserASCII = 58 + TSqlParserASSEMBLY = 59 + TSqlParserASSEMBLYPROPERTY = 60 + TSqlParserASYMMETRIC = 61 + TSqlParserASYNCHRONOUS_COMMIT = 62 + TSqlParserAT_KEYWORD = 63 + TSqlParserAUDIT = 64 + TSqlParserAUDIT_GUID = 65 + TSqlParserAUTHENTICATE = 66 + TSqlParserAUTHENTICATION = 67 + TSqlParserAUTHORIZATION = 68 + TSqlParserAUTO = 69 + TSqlParserAUTOGROW_ALL_FILES = 70 + TSqlParserAUTOGROW_SINGLE_FILE = 71 + TSqlParserAUTOMATED_BACKUP_PREFERENCE = 72 + TSqlParserAUTOMATIC = 73 + TSqlParserAUTO_CLEANUP = 74 + TSqlParserAUTO_CLOSE = 75 + TSqlParserAUTO_CREATE_STATISTICS = 76 + TSqlParserAUTO_DROP = 77 + TSqlParserAUTO_SHRINK = 78 + TSqlParserAUTO_UPDATE_STATISTICS = 79 + TSqlParserAUTO_UPDATE_STATISTICS_ASYNC = 80 + TSqlParserAVAILABILITY = 81 + TSqlParserAVAILABILITY_MODE = 82 + TSqlParserAVG = 83 + TSqlParserBACKSLASH = 84 + TSqlParserBACKUP = 85 + TSqlParserBACKUP_CLONEDB = 86 + TSqlParserBACKUP_PRIORITY = 87 + TSqlParserBASE64 = 88 + TSqlParserBEFORE = 89 + TSqlParserBEGIN = 90 + TSqlParserBEGIN_DIALOG = 91 + TSqlParserBETWEEN = 92 + TSqlParserBIGINT = 93 + TSqlParserBINARY_CHECKSUM = 94 + TSqlParserBINARY_KEYWORD = 95 + TSqlParserBINDING = 96 + TSqlParserBLOB_STORAGE = 97 + TSqlParserBLOCK = 98 + TSqlParserBLOCKERS = 99 + TSqlParserBLOCKING_HIERARCHY = 100 + TSqlParserBLOCKSIZE = 101 + TSqlParserBOUNDING_BOX = 102 + TSqlParserBREAK = 103 + TSqlParserBROKER = 104 + TSqlParserBROKER_INSTANCE = 105 + TSqlParserBROWSE = 106 + TSqlParserBUFFER = 107 + TSqlParserBUFFERCOUNT = 108 + TSqlParserBULK = 109 + TSqlParserBULK_LOGGED = 110 + TSqlParserBY = 111 + TSqlParserCACHE = 112 + TSqlParserCALLED = 113 + TSqlParserCALLER = 114 + TSqlParserCAP_CPU_PERCENT = 115 + TSqlParserCASCADE = 116 + TSqlParserCASE = 117 + TSqlParserCAST = 118 + TSqlParserCATALOG = 119 + TSqlParserCATCH = 120 + TSqlParserCELLS_PER_OBJECT = 121 + TSqlParserCERTENCODED = 122 + TSqlParserCERTIFICATE = 123 + TSqlParserCERTPRIVATEKEY = 124 + TSqlParserCERT_ID = 125 + TSqlParserCHANGE = 126 + TSqlParserCHANGES = 127 + TSqlParserCHANGETABLE = 128 + TSqlParserCHANGE_RETENTION = 129 + TSqlParserCHANGE_TRACKING = 130 + TSqlParserCHAR = 131 + TSqlParserCHARINDEX = 132 + TSqlParserCHECK = 133 + TSqlParserCHECKALLOC = 134 + TSqlParserCHECKCATALOG = 135 + TSqlParserCHECKCONSTRAINTS = 136 + TSqlParserCHECKDB = 137 + TSqlParserCHECKFILEGROUP = 138 + TSqlParserCHECKPOINT = 139 + TSqlParserCHECKSUM = 140 + TSqlParserCHECKSUM_AGG = 141 + TSqlParserCHECKTABLE = 142 + TSqlParserCHECK_EXPIRATION = 143 + TSqlParserCHECK_POLICY = 144 + TSqlParserCLASSIFIER_FUNCTION = 145 + TSqlParserCLEANTABLE = 146 + TSqlParserCLEANUP = 147 + TSqlParserCLONEDATABASE = 148 + TSqlParserCLOSE = 149 + TSqlParserCLUSTER = 150 + TSqlParserCLUSTERED = 151 + TSqlParserCOALESCE = 152 + TSqlParserCOLLATE = 153 + TSqlParserCOLLECTION = 154 + TSqlParserCOLUMN = 155 + TSqlParserCOLUMNPROPERTY = 156 + TSqlParserCOLUMNS = 157 + TSqlParserCOLUMNSTORE = 158 + TSqlParserCOLUMNSTORE_ARCHIVE = 159 + TSqlParserCOLUMN_ENCRYPTION_KEY = 160 + TSqlParserCOLUMN_MASTER_KEY = 161 + TSqlParserCOL_LENGTH = 162 + TSqlParserCOL_NAME = 163 + TSqlParserCOMMIT = 164 + TSqlParserCOMMITTED = 165 + TSqlParserCOMPATIBILITY_LEVEL = 166 + TSqlParserCOMPRESS = 167 + TSqlParserCOMPRESSION = 168 + TSqlParserCOMPRESSION_DELAY = 169 + TSqlParserCOMPRESS_ALL_ROW_GROUPS = 170 + TSqlParserCOMPUTE = 171 + TSqlParserCONCAT = 172 + TSqlParserCONCAT_NULL_YIELDS_NULL = 173 + TSqlParserCONCAT_WS = 174 + TSqlParserCONFIGURATION = 175 + TSqlParserCONNECT = 176 + TSqlParserCONNECTION = 177 + TSqlParserCONNECTIONPROPERTY = 178 + TSqlParserCONSTRAINT = 179 + TSqlParserCONTAINMENT = 180 + TSqlParserCONTAINS = 181 + TSqlParserCONTAINSTABLE = 182 + TSqlParserCONTENT = 183 + TSqlParserCONTEXT = 184 + TSqlParserCONTEXT_INFO = 185 + TSqlParserCONTINUE = 186 + TSqlParserCONTINUE_AFTER_ERROR = 187 + TSqlParserCONTRACT = 188 + TSqlParserCONTRACT_NAME = 189 + TSqlParserCONTROL = 190 + TSqlParserCONVERSATION = 191 + TSqlParserCONVERT = 192 + TSqlParserCOOKIE = 193 + TSqlParserCOPY_ONLY = 194 + TSqlParserCOUNT = 195 + TSqlParserCOUNTER = 196 + TSqlParserCOUNT_BIG = 197 + TSqlParserCPU = 198 + TSqlParserCREATE = 199 + TSqlParserCREATE_NEW = 200 + TSqlParserCREATION_DISPOSITION = 201 + TSqlParserCREDENTIAL = 202 + TSqlParserCROSS = 203 + TSqlParserCRYPTOGRAPHIC = 204 + TSqlParserCUME_DIST = 205 + TSqlParserCURRENT = 206 + TSqlParserCURRENT_DATE = 207 + TSqlParserCURRENT_REQUEST_ID = 208 + TSqlParserCURRENT_TIME = 209 + TSqlParserCURRENT_TIMESTAMP = 210 + TSqlParserCURRENT_TRANSACTION_ID = 211 + TSqlParserCURRENT_USER = 212 + TSqlParserCURSOR = 213 + TSqlParserCURSOR_CLOSE_ON_COMMIT = 214 + TSqlParserCURSOR_DEFAULT = 215 + TSqlParserCURSOR_STATUS = 216 + TSqlParserCYCLE = 217 + TSqlParserDATA = 218 + TSqlParserDATABASE = 219 + TSqlParserDATABASEPROPERTYEX = 220 + TSqlParserDATABASE_MIRRORING = 221 + TSqlParserDATABASE_PRINCIPAL_ID = 222 + TSqlParserDATALENGTH = 223 + TSqlParserDATASPACE = 224 + TSqlParserDATA_COMPRESSION = 225 + TSqlParserDATA_PURITY = 226 + TSqlParserDATA_SOURCE = 227 + TSqlParserDATEADD = 228 + TSqlParserDATEDIFF = 229 + TSqlParserDATENAME = 230 + TSqlParserDATEPART = 231 + TSqlParserDATE_CORRELATION_OPTIMIZATION = 232 + TSqlParserDAYS = 233 + TSqlParserDBCC = 234 + TSqlParserDBREINDEX = 235 + TSqlParserDB_CHAINING = 236 + TSqlParserDB_FAILOVER = 237 + TSqlParserDB_ID = 238 + TSqlParserDB_NAME = 239 + TSqlParserDDL = 240 + TSqlParserDEALLOCATE = 241 + TSqlParserDECLARE = 242 + TSqlParserDECOMPRESS = 243 + TSqlParserDECRYPTION = 244 + TSqlParserDEFAULT = 245 + TSqlParserDEFAULT_DATABASE = 246 + TSqlParserDEFAULT_DOUBLE_QUOTE = 247 + TSqlParserDEFAULT_FULLTEXT_LANGUAGE = 248 + TSqlParserDEFAULT_LANGUAGE = 249 + TSqlParserDEFAULT_SCHEMA = 250 + TSqlParserDEFINITION = 251 + TSqlParserDELAY = 252 + TSqlParserDELAYED_DURABILITY = 253 + TSqlParserDELETE = 254 + TSqlParserDELETED = 255 + TSqlParserDENSE_RANK = 256 + TSqlParserDENY = 257 + TSqlParserDEPENDENTS = 258 + TSqlParserDES = 259 + TSqlParserDESC = 260 + TSqlParserDESCRIPTION = 261 + TSqlParserDESX = 262 + TSqlParserDETERMINISTIC = 263 + TSqlParserDHCP = 264 + TSqlParserDIAGNOSTICS = 265 + TSqlParserDIALOG = 266 + TSqlParserDIFFERENCE = 267 + TSqlParserDIFFERENTIAL = 268 + TSqlParserDIRECTORY_NAME = 269 + TSqlParserDISABLE = 270 + TSqlParserDISABLED = 271 + TSqlParserDISABLE_BROKER = 272 + TSqlParserDISK = 273 + TSqlParserDISTINCT = 274 + TSqlParserDISTRIBUTED = 275 + TSqlParserDISTRIBUTION = 276 + TSqlParserDOCUMENT = 277 + TSqlParserDOLLAR_PARTITION = 278 + TSqlParserDOUBLE = 279 + TSqlParserDOUBLE_BACK_SLASH = 280 + TSqlParserDOUBLE_FORWARD_SLASH = 281 + TSqlParserDROP = 282 + TSqlParserDROPCLEANBUFFERS = 283 + TSqlParserDROP_EXISTING = 284 + TSqlParserDTC_SUPPORT = 285 + TSqlParserDUMP = 286 + TSqlParserDYNAMIC = 287 + TSqlParserELEMENTS = 288 + TSqlParserELSE = 289 + TSqlParserEMERGENCY = 290 + TSqlParserEMPTY = 291 + TSqlParserENABLE = 292 + TSqlParserENABLED = 293 + TSqlParserENABLE_BROKER = 294 + TSqlParserENCRYPTED = 295 + TSqlParserENCRYPTED_VALUE = 296 + TSqlParserENCRYPTION = 297 + TSqlParserENCRYPTION_TYPE = 298 + TSqlParserEND = 299 + TSqlParserENDPOINT = 300 + TSqlParserENDPOINT_URL = 301 + TSqlParserERRLVL = 302 + TSqlParserERROR = 303 + TSqlParserERROR_BROKER_CONVERSATIONS = 304 + TSqlParserERROR_LINE = 305 + TSqlParserERROR_MESSAGE = 306 + TSqlParserERROR_NUMBER = 307 + TSqlParserERROR_PROCEDURE = 308 + TSqlParserERROR_SEVERITY = 309 + TSqlParserERROR_STATE = 310 + TSqlParserESCAPE = 311 + TSqlParserESTIMATEONLY = 312 + TSqlParserEVENT = 313 + TSqlParserEVENTDATA = 314 + TSqlParserEVENT_RETENTION_MODE = 315 + TSqlParserEXCEPT = 316 + TSqlParserEXCLUSIVE = 317 + TSqlParserEXECUTABLE = 318 + TSqlParserEXECUTABLE_FILE = 319 + TSqlParserEXECUTE = 320 + TSqlParserEXIST = 321 + TSqlParserEXISTS = 322 + TSqlParserEXIST_SQUARE_BRACKET = 323 + TSqlParserEXIT = 324 + TSqlParserEXPAND = 325 + TSqlParserEXPIREDATE = 326 + TSqlParserEXPIRY_DATE = 327 + TSqlParserEXPLICIT = 328 + TSqlParserEXTENDED_LOGICAL_CHECKS = 329 + TSqlParserEXTENSION = 330 + TSqlParserEXTERNAL = 331 + TSqlParserEXTERNAL_ACCESS = 332 + TSqlParserFAILOVER = 333 + TSqlParserFAILOVER_MODE = 334 + TSqlParserFAILURE = 335 + TSqlParserFAILURECONDITIONLEVEL = 336 + TSqlParserFAILURE_CONDITION_LEVEL = 337 + TSqlParserFAIL_OPERATION = 338 + TSqlParserFAN_IN = 339 + TSqlParserFAST = 340 + TSqlParserFAST_FORWARD = 341 + TSqlParserFETCH = 342 + TSqlParserFILE = 343 + TSqlParserFILEGROUP = 344 + TSqlParserFILEGROUPPROPERTY = 345 + TSqlParserFILEGROUP_ID = 346 + TSqlParserFILEGROUP_NAME = 347 + TSqlParserFILEGROWTH = 348 + TSqlParserFILENAME = 349 + TSqlParserFILEPATH = 350 + TSqlParserFILEPROPERTY = 351 + TSqlParserFILEPROPERTYEX = 352 + TSqlParserFILESTREAM = 353 + TSqlParserFILESTREAM_ON = 354 + TSqlParserFILE_ID = 355 + TSqlParserFILE_IDEX = 356 + TSqlParserFILE_NAME = 357 + TSqlParserFILE_SNAPSHOT = 358 + TSqlParserFILLFACTOR = 359 + TSqlParserFILTER = 360 + TSqlParserFIRST = 361 + TSqlParserFIRST_VALUE = 362 + TSqlParserFMTONLY = 363 + TSqlParserFOLLOWING = 364 + TSqlParserFOR = 365 + TSqlParserFORCE = 366 + TSqlParserFORCED = 367 + TSqlParserFORCEPLAN = 368 + TSqlParserFORCESCAN = 369 + TSqlParserFORCESEEK = 370 + TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS = 371 + TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS = 372 + TSqlParserFOREIGN = 373 + TSqlParserFORMAT = 374 + TSqlParserFORMATMESSAGE = 375 + TSqlParserFORWARD_ONLY = 376 + TSqlParserFREE = 377 + TSqlParserFREETEXT = 378 + TSqlParserFREETEXTTABLE = 379 + TSqlParserFROM = 380 + TSqlParserFULL = 381 + TSqlParserFULLSCAN = 382 + TSqlParserFULLTEXT = 383 + TSqlParserFULLTEXTCATALOGPROPERTY = 384 + TSqlParserFULLTEXTSERVICEPROPERTY = 385 + TSqlParserFUNCTION = 386 + TSqlParserGB = 387 + TSqlParserGENERATED = 388 + TSqlParserGEOGRAPHY = 389 + TSqlParserGEOGRAPHY_AUTO_GRID = 390 + TSqlParserGEOGRAPHY_GRID = 391 + TSqlParserGEOMETRY = 392 + TSqlParserGEOMETRY_AUTO_GRID = 393 + TSqlParserGEOMETRY_GRID = 394 + TSqlParserGET = 395 + TSqlParserGRIDS = 396 + TSqlParserGETANCESTOR = 397 + TSqlParserGETANSINULL = 398 + TSqlParserGETDATE = 399 + TSqlParserGETDESCENDANT = 400 + TSqlParserGETLEVEL = 401 + TSqlParserGETREPARENTEDVALUE = 402 + TSqlParserGETROOT = 403 + TSqlParserGETUTCDATE = 404 + TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT = 405 + TSqlParserGLOBAL = 406 + TSqlParserGO = 407 + TSqlParserGOTO = 408 + TSqlParserGOVERNOR = 409 + TSqlParserGRANT = 410 + TSqlParserGREATEST = 411 + TSqlParserGROUP = 412 + TSqlParserGROUPING = 413 + TSqlParserGROUPING_ID = 414 + TSqlParserGROUP_MAX_REQUESTS = 415 + TSqlParserHADR = 416 + TSqlParserHASH = 417 + TSqlParserHASHED = 418 + TSqlParserHAS_DBACCESS = 419 + TSqlParserHAS_PERMS_BY_NAME = 420 + TSqlParserHAVING = 421 + TSqlParserHEALTHCHECKTIMEOUT = 422 + TSqlParserHEALTH_CHECK_TIMEOUT = 423 + TSqlParserHEAP = 424 + TSqlParserHIDDEN_KEYWORD = 425 + TSqlParserHIERARCHYID = 426 + TSqlParserHIGH = 427 + TSqlParserHOLDLOCK = 428 + TSqlParserHONOR_BROKER_PRIORITY = 429 + TSqlParserHOST_ID = 430 + TSqlParserHOST_NAME = 431 + TSqlParserHOURS = 432 + TSqlParserIDENTITY = 433 + TSqlParserIDENTITYCOL = 434 + TSqlParserIDENTITY_INSERT = 435 + TSqlParserIDENTITY_VALUE = 436 + TSqlParserIDENT_CURRENT = 437 + TSqlParserIDENT_INCR = 438 + TSqlParserIDENT_SEED = 439 + TSqlParserIF = 440 + TSqlParserIGNORE_CONSTRAINTS = 441 + TSqlParserIGNORE_DUP_KEY = 442 + TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX = 443 + TSqlParserIGNORE_REPLICATED_TABLE_CACHE = 444 + TSqlParserIGNORE_TRIGGERS = 445 + TSqlParserIIF = 446 + TSqlParserIMMEDIATE = 447 + TSqlParserIMPERSONATE = 448 + TSqlParserIMPLICIT_TRANSACTIONS = 449 + TSqlParserIMPORTANCE = 450 + TSqlParserIN = 451 + TSqlParserINCLUDE = 452 + TSqlParserINCLUDE_NULL_VALUES = 453 + TSqlParserINCREMENT = 454 + TSqlParserINCREMENTAL = 455 + TSqlParserINDEX = 456 + TSqlParserINDEXKEY_PROPERTY = 457 + TSqlParserINDEXPROPERTY = 458 + TSqlParserINDEX_COL = 459 + TSqlParserINFINITE = 460 + TSqlParserINIT = 461 + TSqlParserINITIATOR = 462 + TSqlParserINNER = 463 + TSqlParserINPUT = 464 + TSqlParserINSENSITIVE = 465 + TSqlParserINSERT = 466 + TSqlParserINSERTED = 467 + TSqlParserINSTEAD = 468 + TSqlParserINT = 469 + TSqlParserINTERSECT = 470 + TSqlParserINTO = 471 + TSqlParserIO = 472 + TSqlParserIP = 473 + TSqlParserIS = 474 + TSqlParserISDESCENDANTOF = 475 + TSqlParserISJSON = 476 + TSqlParserISNULL = 477 + TSqlParserISNUMERIC = 478 + TSqlParserISOLATION = 479 + TSqlParserIS_MEMBER = 480 + TSqlParserIS_ROLEMEMBER = 481 + TSqlParserIS_SRVROLEMEMBER = 482 + TSqlParserJOB = 483 + TSqlParserJOIN = 484 + TSqlParserJSON = 485 + TSqlParserJSON_ARRAY = 486 + TSqlParserJSON_MODIFY = 487 + TSqlParserJSON_OBJECT = 488 + TSqlParserJSON_PATH_EXISTS = 489 + TSqlParserJSON_QUERY = 490 + TSqlParserJSON_VALUE = 491 + TSqlParserKB = 492 + TSqlParserKEEP = 493 + TSqlParserKEEPDEFAULTS = 494 + TSqlParserKEEPFIXED = 495 + TSqlParserKEEPIDENTITY = 496 + TSqlParserKERBEROS = 497 + TSqlParserKEY = 498 + TSqlParserKEYS = 499 + TSqlParserKEYSET = 500 + TSqlParserKEY_PATH = 501 + TSqlParserKEY_SOURCE = 502 + TSqlParserKEY_STORE_PROVIDER_NAME = 503 + TSqlParserKILL = 504 + TSqlParserLAG = 505 + TSqlParserLANGUAGE = 506 + TSqlParserLAST = 507 + TSqlParserLAST_VALUE = 508 + TSqlParserLEAD = 509 + TSqlParserLEAST = 510 + TSqlParserLEFT = 511 + TSqlParserLEN = 512 + TSqlParserLEVEL = 513 + TSqlParserLEVEL_1 = 514 + TSqlParserLEVEL_2 = 515 + TSqlParserLEVEL_3 = 516 + TSqlParserLEVEL_4 = 517 + TSqlParserLIBRARY = 518 + TSqlParserLIFETIME = 519 + TSqlParserLIKE = 520 + TSqlParserLINENO = 521 + TSqlParserLINKED = 522 + TSqlParserLINUX = 523 + TSqlParserLIST = 524 + TSqlParserLISTENER = 525 + TSqlParserLISTENER_IP = 526 + TSqlParserLISTENER_PORT = 527 + TSqlParserLISTENER_URL = 528 + TSqlParserLOAD = 529 + TSqlParserLOB_COMPACTION = 530 + TSqlParserLOCAL = 531 + TSqlParserLOCAL_SERVICE_NAME = 532 + TSqlParserLOCATION = 533 + TSqlParserLOCK = 534 + TSqlParserLOCK_ESCALATION = 535 + TSqlParserLOG = 536 + TSqlParserLOGIN = 537 + TSqlParserLOGINPROPERTY = 538 + TSqlParserLOOP = 539 + TSqlParserLOW = 540 + TSqlParserLOWER = 541 + TSqlParserLTRIM = 542 + TSqlParserMANUAL = 543 + TSqlParserMARK = 544 + TSqlParserMASK = 545 + TSqlParserMASKED = 546 + TSqlParserMASTER = 547 + TSqlParserMATCHED = 548 + TSqlParserMATERIALIZED = 549 + TSqlParserMAX = 550 + TSqlParserMAXDOP = 551 + TSqlParserMAXRECURSION = 552 + TSqlParserMAXSIZE = 553 + TSqlParserMAXTRANSFER = 554 + TSqlParserMAXVALUE = 555 + TSqlParserMAX_CPU_PERCENT = 556 + TSqlParserMAX_DISPATCH_LATENCY = 557 + TSqlParserMAX_DOP = 558 + TSqlParserMAX_DURATION = 559 + TSqlParserMAX_EVENT_SIZE = 560 + TSqlParserMAX_FILES = 561 + TSqlParserMAX_IOPS_PER_VOLUME = 562 + TSqlParserMAX_MEMORY = 563 + TSqlParserMAX_MEMORY_PERCENT = 564 + TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME = 565 + TSqlParserMAX_PROCESSES = 566 + TSqlParserMAX_QUEUE_READERS = 567 + TSqlParserMAX_ROLLOVER_FILES = 568 + TSqlParserMAX_SIZE = 569 + TSqlParserMB = 570 + TSqlParserMEDIADESCRIPTION = 571 + TSqlParserMEDIANAME = 572 + TSqlParserMEDIUM = 573 + TSqlParserMEMBER = 574 + TSqlParserMEMORY_OPTIMIZED_DATA = 575 + TSqlParserMEMORY_PARTITION_MODE = 576 + TSqlParserMERGE = 577 + TSqlParserMESSAGE = 578 + TSqlParserMESSAGE_FORWARDING = 579 + TSqlParserMESSAGE_FORWARD_SIZE = 580 + TSqlParserMIN = 581 + TSqlParserMINUTES = 582 + TSqlParserMINVALUE = 583 + TSqlParserMIN_ACTIVE_ROWVERSION = 584 + TSqlParserMIN_CPU_PERCENT = 585 + TSqlParserMIN_IOPS_PER_VOLUME = 586 + TSqlParserMIN_MEMORY_PERCENT = 587 + TSqlParserMIRROR = 588 + TSqlParserMIRROR_ADDRESS = 589 + TSqlParserMIXED_PAGE_ALLOCATION = 590 + TSqlParserMODE = 591 + TSqlParserMODIFY = 592 + TSqlParserMODIFY_SQUARE_BRACKET = 593 + TSqlParserMOVE = 594 + TSqlParserMULTI_USER = 595 + TSqlParserMUST_CHANGE = 596 + TSqlParserNAME = 597 + TSqlParserNATIONAL = 598 + TSqlParserNCHAR = 599 + TSqlParserNEGOTIATE = 600 + TSqlParserNESTED_TRIGGERS = 601 + TSqlParserNEWID = 602 + TSqlParserNEWNAME = 603 + TSqlParserNEWSEQUENTIALID = 604 + TSqlParserNEW_ACCOUNT = 605 + TSqlParserNEW_BROKER = 606 + TSqlParserNEW_PASSWORD = 607 + TSqlParserNEXT = 608 + TSqlParserNO = 609 + TSqlParserNOCHECK = 610 + TSqlParserNOCOUNT = 611 + TSqlParserNODES = 612 + TSqlParserNOEXEC = 613 + TSqlParserNOEXPAND = 614 + TSqlParserNOFORMAT = 615 + TSqlParserNOHOLDLOCK = 616 + TSqlParserNOINDEX = 617 + TSqlParserNOINIT = 618 + TSqlParserNOLOCK = 619 + TSqlParserNONCLUSTERED = 620 + TSqlParserNONE = 621 + TSqlParserNON_TRANSACTED_ACCESS = 622 + TSqlParserNORECOMPUTE = 623 + TSqlParserNORECOVERY = 624 + TSqlParserNOREWIND = 625 + TSqlParserNOSKIP = 626 + TSqlParserNOT = 627 + TSqlParserNOTIFICATION = 628 + TSqlParserNOTIFICATIONS = 629 + TSqlParserNOUNLOAD = 630 + TSqlParserNOWAIT = 631 + TSqlParserNO_CHECKSUM = 632 + TSqlParserNO_COMPRESSION = 633 + TSqlParserNO_EVENT_LOSS = 634 + TSqlParserNO_INFOMSGS = 635 + TSqlParserNO_QUERYSTORE = 636 + TSqlParserNO_STATISTICS = 637 + TSqlParserNO_TRUNCATE = 638 + TSqlParserNO_WAIT = 639 + TSqlParserNTILE = 640 + TSqlParserNTLM = 641 + TSqlParserNULLIF = 642 + TSqlParserNULL_ = 643 + TSqlParserNULL_DOUBLE_QUOTE = 644 + TSqlParserNUMANODE = 645 + TSqlParserNUMBER = 646 + TSqlParserNUMERIC_ROUNDABORT = 647 + TSqlParserOBJECT = 648 + TSqlParserOBJECTPROPERTY = 649 + TSqlParserOBJECTPROPERTYEX = 650 + TSqlParserOBJECT_DEFINITION = 651 + TSqlParserOBJECT_ID = 652 + TSqlParserOBJECT_NAME = 653 + TSqlParserOBJECT_SCHEMA_NAME = 654 + TSqlParserOF = 655 + TSqlParserOFF = 656 + TSqlParserOFFLINE = 657 + TSqlParserOFFSET = 658 + TSqlParserOFFSETS = 659 + TSqlParserOLD_ACCOUNT = 660 + TSqlParserOLD_PASSWORD = 661 + TSqlParserON = 662 + TSqlParserONLINE = 663 + TSqlParserONLY = 664 + TSqlParserON_FAILURE = 665 + TSqlParserOPEN = 666 + TSqlParserOPENDATASOURCE = 667 + TSqlParserOPENJSON = 668 + TSqlParserOPENQUERY = 669 + TSqlParserOPENROWSET = 670 + TSqlParserOPENXML = 671 + TSqlParserOPEN_EXISTING = 672 + TSqlParserOPERATIONS = 673 + TSqlParserOPTIMISTIC = 674 + TSqlParserOPTIMIZE = 675 + TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY = 676 + TSqlParserOPTION = 677 + TSqlParserOR = 678 + TSqlParserORDER = 679 + TSqlParserORIGINAL_DB_NAME = 680 + TSqlParserORIGINAL_LOGIN = 681 + TSqlParserOUT = 682 + TSqlParserOUTER = 683 + TSqlParserOUTPUT = 684 + TSqlParserOVER = 685 + TSqlParserOVERRIDE = 686 + TSqlParserOWNER = 687 + TSqlParserOWNERSHIP = 688 + TSqlParserPAD_INDEX = 689 + TSqlParserPAGE = 690 + TSqlParserPAGECOUNT = 691 + TSqlParserPAGE_VERIFY = 692 + TSqlParserPAGLOCK = 693 + TSqlParserPARAMETERIZATION = 694 + TSqlParserPARAM_NODE = 695 + TSqlParserPARSE = 696 + TSqlParserPARSENAME = 697 + TSqlParserPARSEONLY = 698 + TSqlParserPARTIAL = 699 + TSqlParserPARTITION = 700 + TSqlParserPARTITIONS = 701 + TSqlParserPARTNER = 702 + TSqlParserPASSWORD = 703 + TSqlParserPATH = 704 + TSqlParserPATINDEX = 705 + TSqlParserPAUSE = 706 + TSqlParserPDW_SHOWSPACEUSED = 707 + TSqlParserPERCENT = 708 + TSqlParserPERCENTILE_CONT = 709 + TSqlParserPERCENTILE_DISC = 710 + TSqlParserPERCENT_RANK = 711 + TSqlParserPERMISSIONS = 712 + TSqlParserPERMISSION_SET = 713 + TSqlParserPERSISTED = 714 + TSqlParserPERSIST_SAMPLE_PERCENT = 715 + TSqlParserPER_CPU = 716 + TSqlParserPER_DB = 717 + TSqlParserPER_NODE = 718 + TSqlParserPHYSICAL_ONLY = 719 + TSqlParserPIVOT = 720 + TSqlParserPLAN = 721 + TSqlParserPLATFORM = 722 + TSqlParserPOISON_MESSAGE_HANDLING = 723 + TSqlParserPOLICY = 724 + TSqlParserPOOL = 725 + TSqlParserPORT = 726 + TSqlParserPRECEDING = 727 + TSqlParserPRECISION = 728 + TSqlParserPREDICATE = 729 + TSqlParserPRIMARY = 730 + TSqlParserPRIMARY_ROLE = 731 + TSqlParserPRINT = 732 + TSqlParserPRIOR = 733 + TSqlParserPRIORITY = 734 + TSqlParserPRIORITY_LEVEL = 735 + TSqlParserPRIVATE = 736 + TSqlParserPRIVATE_KEY = 737 + TSqlParserPRIVILEGES = 738 + TSqlParserPROC = 739 + TSqlParserPROCCACHE = 740 + TSqlParserPROCEDURE = 741 + TSqlParserPROCEDURE_NAME = 742 + TSqlParserPROCESS = 743 + TSqlParserPROFILE = 744 + TSqlParserPROPERTY = 745 + TSqlParserPROVIDER = 746 + TSqlParserPROVIDER_KEY_NAME = 747 + TSqlParserPUBLIC = 748 + TSqlParserPWDCOMPARE = 749 + TSqlParserPWDENCRYPT = 750 + TSqlParserPYTHON = 751 + TSqlParserQUERY = 752 + TSqlParserQUERY_SQUARE_BRACKET = 753 + TSqlParserQUEUE = 754 + TSqlParserQUEUE_DELAY = 755 + TSqlParserQUOTED_IDENTIFIER = 756 + TSqlParserQUOTENAME = 757 + TSqlParserR = 758 + TSqlParserRAISERROR = 759 + TSqlParserRANDOMIZED = 760 + TSqlParserRANGE = 761 + TSqlParserRANK = 762 + TSqlParserRAW = 763 + TSqlParserRC2 = 764 + TSqlParserRC4 = 765 + TSqlParserRC4_128 = 766 + TSqlParserREAD = 767 + TSqlParserREADCOMMITTED = 768 + TSqlParserREADCOMMITTEDLOCK = 769 + TSqlParserREADONLY = 770 + TSqlParserREADPAST = 771 + TSqlParserREADTEXT = 772 + TSqlParserREADUNCOMMITTED = 773 + TSqlParserREADWRITE = 774 + TSqlParserREAD_COMMITTED_SNAPSHOT = 775 + TSqlParserREAD_ONLY = 776 + TSqlParserREAD_ONLY_ROUTING_LIST = 777 + TSqlParserREAD_WRITE = 778 + TSqlParserREAD_WRITE_FILEGROUPS = 779 + TSqlParserREBUILD = 780 + TSqlParserRECEIVE = 781 + TSqlParserRECOMPILE = 782 + TSqlParserRECONFIGURE = 783 + TSqlParserRECOVERY = 784 + TSqlParserRECURSIVE_TRIGGERS = 785 + TSqlParserREFERENCES = 786 + TSqlParserREGENERATE = 787 + TSqlParserRELATED_CONVERSATION = 788 + TSqlParserRELATED_CONVERSATION_GROUP = 789 + TSqlParserRELATIVE = 790 + TSqlParserREMOTE = 791 + TSqlParserREMOTE_PROC_TRANSACTIONS = 792 + TSqlParserREMOTE_SERVICE_NAME = 793 + TSqlParserREMOVE = 794 + TSqlParserREORGANIZE = 795 + TSqlParserREPAIR_ALLOW_DATA_LOSS = 796 + TSqlParserREPAIR_FAST = 797 + TSqlParserREPAIR_REBUILD = 798 + TSqlParserREPEATABLE = 799 + TSqlParserREPEATABLEREAD = 800 + TSqlParserREPLACE = 801 + TSqlParserREPLICA = 802 + TSqlParserREPLICATE = 803 + TSqlParserREPLICATION = 804 + TSqlParserREQUEST_MAX_CPU_TIME_SEC = 805 + TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT = 806 + TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC = 807 + TSqlParserREQUIRED = 808 + TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT = 809 + TSqlParserRESAMPLE = 810 + TSqlParserRESERVE_DISK_SPACE = 811 + TSqlParserRESET = 812 + TSqlParserRESOURCE = 813 + TSqlParserRESOURCES = 814 + TSqlParserRESOURCE_MANAGER_LOCATION = 815 + TSqlParserRESTART = 816 + TSqlParserRESTORE = 817 + TSqlParserRESTRICT = 818 + TSqlParserRESTRICTED_USER = 819 + TSqlParserRESUMABLE = 820 + TSqlParserRESUME = 821 + TSqlParserRETAINDAYS = 822 + TSqlParserRETENTION = 823 + TSqlParserRETURN = 824 + TSqlParserRETURNS = 825 + TSqlParserREVERSE = 826 + TSqlParserREVERT = 827 + TSqlParserREVOKE = 828 + TSqlParserREWIND = 829 + TSqlParserRIGHT = 830 + TSqlParserROBUST = 831 + TSqlParserROLE = 832 + TSqlParserROLLBACK = 833 + TSqlParserROOT = 834 + TSqlParserROUND_ROBIN = 835 + TSqlParserROUTE = 836 + TSqlParserROW = 837 + TSqlParserROWCOUNT = 838 + TSqlParserROWCOUNT_BIG = 839 + TSqlParserROWGUID = 840 + TSqlParserROWGUIDCOL = 841 + TSqlParserROWLOCK = 842 + TSqlParserROWS = 843 + TSqlParserROW_NUMBER = 844 + TSqlParserRSA_1024 = 845 + TSqlParserRSA_2048 = 846 + TSqlParserRSA_3072 = 847 + TSqlParserRSA_4096 = 848 + TSqlParserRSA_512 = 849 + TSqlParserRTRIM = 850 + TSqlParserRULE = 851 + TSqlParserSAFE = 852 + TSqlParserSAFETY = 853 + TSqlParserSAMPLE = 854 + TSqlParserSAVE = 855 + TSqlParserSCHEDULER = 856 + TSqlParserSCHEMA = 857 + TSqlParserSCHEMABINDING = 858 + TSqlParserSCHEMA_ID = 859 + TSqlParserSCHEMA_NAME = 860 + TSqlParserSCHEME = 861 + TSqlParserSCOPED = 862 + TSqlParserSCOPE_IDENTITY = 863 + TSqlParserSCRIPT = 864 + TSqlParserSCROLL = 865 + TSqlParserSCROLL_LOCKS = 866 + TSqlParserSEARCH = 867 + TSqlParserSECONDARY = 868 + TSqlParserSECONDARY_ONLY = 869 + TSqlParserSECONDARY_ROLE = 870 + TSqlParserSECONDS = 871 + TSqlParserSECRET = 872 + TSqlParserSECURABLES = 873 + TSqlParserSECURITY = 874 + TSqlParserSECURITYAUDIT = 875 + TSqlParserSECURITY_LOG = 876 + TSqlParserSEEDING_MODE = 877 + TSqlParserSELECT = 878 + TSqlParserSELF = 879 + TSqlParserSEMANTICKEYPHRASETABLE = 880 + TSqlParserSEMANTICSIMILARITYDETAILSTABLE = 881 + TSqlParserSEMANTICSIMILARITYTABLE = 882 + TSqlParserSEMI_SENSITIVE = 883 + TSqlParserSEND = 884 + TSqlParserSENT = 885 + TSqlParserSEQUENCE = 886 + TSqlParserSEQUENCE_NUMBER = 887 + TSqlParserSERIALIZABLE = 888 + TSqlParserSERVER = 889 + TSqlParserSERVERPROPERTY = 890 + TSqlParserSERVICE = 891 + TSqlParserSERVICEBROKER = 892 + TSqlParserSERVICE_BROKER = 893 + TSqlParserSERVICE_NAME = 894 + TSqlParserSESSION = 895 + TSqlParserSESSIONPROPERTY = 896 + TSqlParserSESSION_CONTEXT = 897 + TSqlParserSESSION_TIMEOUT = 898 + TSqlParserSESSION_USER = 899 + TSqlParserSET = 900 + TSqlParserSETERROR = 901 + TSqlParserSETS = 902 + TSqlParserSETTINGS = 903 + TSqlParserSETUSER = 904 + TSqlParserSHARE = 905 + TSqlParserSHARED = 906 + TSqlParserSHOWCONTIG = 907 + TSqlParserSHOWPLAN = 908 + TSqlParserSHOWPLAN_ALL = 909 + TSqlParserSHOWPLAN_TEXT = 910 + TSqlParserSHOWPLAN_XML = 911 + TSqlParserSHRINKLOG = 912 + TSqlParserSHUTDOWN = 913 + TSqlParserSID = 914 + TSqlParserSIGNATURE = 915 + TSqlParserSIMPLE = 916 + TSqlParserSINGLE_USER = 917 + TSqlParserSIZE = 918 + TSqlParserSKIP_KEYWORD = 919 + TSqlParserSMALLINT = 920 + TSqlParserSNAPSHOT = 921 + TSqlParserSOFTNUMA = 922 + TSqlParserSOME = 923 + TSqlParserSORT_IN_TEMPDB = 924 + TSqlParserSOUNDEX = 925 + TSqlParserSOURCE = 926 + TSqlParserSPACE_KEYWORD = 927 + TSqlParserSPARSE = 928 + TSqlParserSPATIAL = 929 + TSqlParserSPATIAL_WINDOW_MAX_CELLS = 930 + TSqlParserSPECIFICATION = 931 + TSqlParserSPLIT = 932 + TSqlParserSQL = 933 + TSqlParserSQLDUMPERFLAGS = 934 + TSqlParserSQLDUMPERPATH = 935 + TSqlParserSQLDUMPERTIMEOUT = 936 + TSqlParserSQL_VARIANT_PROPERTY = 937 + TSqlParserSTANDBY = 938 + TSqlParserSTART = 939 + TSqlParserSTARTED = 940 + TSqlParserSTARTUP_STATE = 941 + TSqlParserSTART_DATE = 942 + TSqlParserSTATE = 943 + TSqlParserSTATIC = 944 + TSqlParserSTATISTICS = 945 + TSqlParserSTATISTICS_INCREMENTAL = 946 + TSqlParserSTATISTICS_NORECOMPUTE = 947 + TSqlParserSTATS = 948 + TSqlParserSTATS_DATE = 949 + TSqlParserSTATS_STREAM = 950 + TSqlParserSTATUS = 951 + TSqlParserSTATUSONLY = 952 + TSqlParserSTDEV = 953 + TSqlParserSTDEVP = 954 + TSqlParserSTOP = 955 + TSqlParserSTOPLIST = 956 + TSqlParserSTOPPED = 957 + TSqlParserSTOP_ON_ERROR = 958 + TSqlParserSTR = 959 + TSqlParserSTRING_AGG = 960 + TSqlParserSTRING_ESCAPE = 961 + TSqlParserSTUFF = 962 + TSqlParserSUBJECT = 963 + TSqlParserSUBSCRIBE = 964 + TSqlParserSUBSCRIPTION = 965 + TSqlParserSUBSTRING = 966 + TSqlParserSUM = 967 + TSqlParserSUPPORTED = 968 + TSqlParserSUSER_ID = 969 + TSqlParserSUSER_NAME = 970 + TSqlParserSUSER_SID = 971 + TSqlParserSUSER_SNAME = 972 + TSqlParserSUSPEND = 973 + TSqlParserSWITCH = 974 + TSqlParserSYMMETRIC = 975 + TSqlParserSYNCHRONOUS_COMMIT = 976 + TSqlParserSYNONYM = 977 + TSqlParserSYSTEM = 978 + TSqlParserSYSTEM_USER = 979 + TSqlParserTABLE = 980 + TSqlParserTABLERESULTS = 981 + TSqlParserTABLESAMPLE = 982 + TSqlParserTABLOCK = 983 + TSqlParserTABLOCKX = 984 + TSqlParserTAKE = 985 + TSqlParserTAPE = 986 + TSqlParserTARGET = 987 + TSqlParserTARGET_RECOVERY_TIME = 988 + TSqlParserTB = 989 + TSqlParserTCP = 990 + TSqlParserTEXTIMAGE_ON = 991 + TSqlParserTEXTSIZE = 992 + TSqlParserTHEN = 993 + TSqlParserTHROW = 994 + TSqlParserTIES = 995 + TSqlParserTIME = 996 + TSqlParserTIMEOUT = 997 + TSqlParserTIMER = 998 + TSqlParserTINYINT = 999 + TSqlParserTO = 1000 + TSqlParserTOP = 1001 + TSqlParserTORN_PAGE_DETECTION = 1002 + TSqlParserTOSTRING = 1003 + TSqlParserTRACE = 1004 + TSqlParserTRACKING = 1005 + TSqlParserTRACK_CAUSALITY = 1006 + TSqlParserTRAN = 1007 + TSqlParserTRANSACTION = 1008 + TSqlParserTRANSACTION_ID = 1009 + TSqlParserTRANSFER = 1010 + TSqlParserTRANSFORM_NOISE_WORDS = 1011 + TSqlParserTRANSLATE = 1012 + TSqlParserTRIGGER = 1013 + TSqlParserTRIM = 1014 + TSqlParserTRIPLE_DES = 1015 + TSqlParserTRIPLE_DES_3KEY = 1016 + TSqlParserTRUNCATE = 1017 + TSqlParserTRUSTWORTHY = 1018 + TSqlParserTRY = 1019 + TSqlParserTRY_CAST = 1020 + TSqlParserTSEQUAL = 1021 + TSqlParserTSQL = 1022 + TSqlParserTWO_DIGIT_YEAR_CUTOFF = 1023 + TSqlParserTYPE = 1024 + TSqlParserTYPEPROPERTY = 1025 + TSqlParserTYPE_ID = 1026 + TSqlParserTYPE_NAME = 1027 + TSqlParserTYPE_WARNING = 1028 + TSqlParserUNBOUNDED = 1029 + TSqlParserUNCHECKED = 1030 + TSqlParserUNCOMMITTED = 1031 + TSqlParserUNICODE = 1032 + TSqlParserUNION = 1033 + TSqlParserUNIQUE = 1034 + TSqlParserUNKNOWN = 1035 + TSqlParserUNLIMITED = 1036 + TSqlParserUNLOCK = 1037 + TSqlParserUNMASK = 1038 + TSqlParserUNPIVOT = 1039 + TSqlParserUNSAFE = 1040 + TSqlParserUOW = 1041 + TSqlParserUPDATE = 1042 + TSqlParserUPDATETEXT = 1043 + TSqlParserUPDLOCK = 1044 + TSqlParserUPPER = 1045 + TSqlParserURL = 1046 + TSqlParserUSE = 1047 + TSqlParserUSED = 1048 + TSqlParserUSER = 1049 + TSqlParserUSER_ID = 1050 + TSqlParserUSER_NAME = 1051 + TSqlParserUSING = 1052 + TSqlParserVALIDATION = 1053 + TSqlParserVALID_XML = 1054 + TSqlParserVALUE = 1055 + TSqlParserVALUES = 1056 + TSqlParserVALUE_SQUARE_BRACKET = 1057 + TSqlParserVAR = 1058 + TSqlParserVARBINARY_KEYWORD = 1059 + TSqlParserVARP = 1060 + TSqlParserVARYING = 1061 + TSqlParserVERBOSELOGGING = 1062 + TSqlParserVERIFY_CLONEDB = 1063 + TSqlParserVERSION = 1064 + TSqlParserVIEW = 1065 + TSqlParserVIEWS = 1066 + TSqlParserVIEW_METADATA = 1067 + TSqlParserVISIBILITY = 1068 + TSqlParserWAIT = 1069 + TSqlParserWAITFOR = 1070 + TSqlParserWAIT_AT_LOW_PRIORITY = 1071 + TSqlParserWELL_FORMED_XML = 1072 + TSqlParserWHEN = 1073 + TSqlParserWHERE = 1074 + TSqlParserWHILE = 1075 + TSqlParserWINDOWS = 1076 + TSqlParserWITH = 1077 + TSqlParserWITHIN = 1078 + TSqlParserWITHOUT = 1079 + TSqlParserWITHOUT_ARRAY_WRAPPER = 1080 + TSqlParserWITNESS = 1081 + TSqlParserWORK = 1082 + TSqlParserWORKLOAD = 1083 + TSqlParserWRITETEXT = 1084 + TSqlParserXACT_ABORT = 1085 + TSqlParserXACT_STATE = 1086 + TSqlParserXLOCK = 1087 + TSqlParserXML = 1088 + TSqlParserXMLDATA = 1089 + TSqlParserXMLNAMESPACES = 1090 + TSqlParserXMLSCHEMA = 1091 + TSqlParserXML_COMPRESSION = 1092 + TSqlParserXSINIL = 1093 + TSqlParserZONE = 1094 + TSqlParserABS = 1095 + TSqlParserACOS = 1096 + TSqlParserASIN = 1097 + TSqlParserATAN = 1098 + TSqlParserATN2 = 1099 + TSqlParserCEILING = 1100 + TSqlParserCOS = 1101 + TSqlParserCOT = 1102 + TSqlParserDEGREES = 1103 + TSqlParserEXP = 1104 + TSqlParserFLOOR = 1105 + TSqlParserLOG10 = 1106 + TSqlParserPI = 1107 + TSqlParserPOWER = 1108 + TSqlParserRADIANS = 1109 + TSqlParserRAND = 1110 + TSqlParserROUND = 1111 + TSqlParserSIGN = 1112 + TSqlParserSIN = 1113 + TSqlParserSQRT = 1114 + TSqlParserSQUARE = 1115 + TSqlParserTAN = 1116 + TSqlParserCURRENT_TIMEZONE = 1117 + TSqlParserCURRENT_TIMEZONE_ID = 1118 + TSqlParserDATE_BUCKET = 1119 + TSqlParserDATEDIFF_BIG = 1120 + TSqlParserDATEFROMPARTS = 1121 + TSqlParserDATETIME2FROMPARTS = 1122 + TSqlParserDATETIMEFROMPARTS = 1123 + TSqlParserDATETIMEOFFSETFROMPARTS = 1124 + TSqlParserDATETRUNC = 1125 + TSqlParserDAY = 1126 + TSqlParserEOMONTH = 1127 + TSqlParserISDATE = 1128 + TSqlParserMONTH = 1129 + TSqlParserSMALLDATETIMEFROMPARTS = 1130 + TSqlParserSWITCHOFFSET = 1131 + TSqlParserSYSDATETIME = 1132 + TSqlParserSYSDATETIMEOFFSET = 1133 + TSqlParserSYSUTCDATETIME = 1134 + TSqlParserTIMEFROMPARTS = 1135 + TSqlParserTODATETIMEOFFSET = 1136 + TSqlParserYEAR = 1137 + TSqlParserQUARTER = 1138 + TSqlParserDAYOFYEAR = 1139 + TSqlParserWEEK = 1140 + TSqlParserHOUR = 1141 + TSqlParserMINUTE = 1142 + TSqlParserSECOND = 1143 + TSqlParserMILLISECOND = 1144 + TSqlParserMICROSECOND = 1145 + TSqlParserNANOSECOND = 1146 + TSqlParserTZOFFSET = 1147 + TSqlParserISO_WEEK = 1148 + TSqlParserWEEKDAY = 1149 + TSqlParserYEAR_ABBR = 1150 + TSqlParserQUARTER_ABBR = 1151 + TSqlParserMONTH_ABBR = 1152 + TSqlParserDAYOFYEAR_ABBR = 1153 + TSqlParserDAY_ABBR = 1154 + TSqlParserWEEK_ABBR = 1155 + TSqlParserHOUR_ABBR = 1156 + TSqlParserMINUTE_ABBR = 1157 + TSqlParserSECOND_ABBR = 1158 + TSqlParserMILLISECOND_ABBR = 1159 + TSqlParserMICROSECOND_ABBR = 1160 + TSqlParserNANOSECOND_ABBR = 1161 + TSqlParserTZOFFSET_ABBR = 1162 + TSqlParserISO_WEEK_ABBR = 1163 + TSqlParserWEEKDAY_ABBR = 1164 + TSqlParserSP_EXECUTESQL = 1165 + TSqlParserVARCHAR = 1166 + TSqlParserNVARCHAR = 1167 + TSqlParserDISK_DRIVE = 1168 + TSqlParserDOLLAR_ACTION = 1169 + TSqlParserCURSOR_ROWS = 1170 + TSqlParserFETCH_STATUS = 1171 + TSqlParserIPV4_ADDR = 1172 + TSqlParserSPACE = 1173 + TSqlParserCOMMENT = 1174 + TSqlParserLINE_COMMENT = 1175 + TSqlParserDOUBLE_QUOTE_ID = 1176 + TSqlParserDOUBLE_QUOTE_BLANK = 1177 + TSqlParserSINGLE_QUOTE = 1178 + TSqlParserSQUARE_BRACKET_ID = 1179 + TSqlParserLOCAL_ID = 1180 + TSqlParserTEMP_ID = 1181 + TSqlParserDECIMAL = 1182 + TSqlParserID = 1183 + TSqlParserSTRING = 1184 + TSqlParserBINARY = 1185 + TSqlParserFLOAT = 1186 + TSqlParserREAL = 1187 + TSqlParserEQUAL = 1188 + TSqlParserGREATER = 1189 + TSqlParserLESS = 1190 + TSqlParserEXCLAMATION = 1191 + TSqlParserPLUS_ASSIGN = 1192 + TSqlParserMINUS_ASSIGN = 1193 + TSqlParserMULT_ASSIGN = 1194 + TSqlParserDIV_ASSIGN = 1195 + TSqlParserMOD_ASSIGN = 1196 + TSqlParserAND_ASSIGN = 1197 + TSqlParserXOR_ASSIGN = 1198 + TSqlParserOR_ASSIGN = 1199 + TSqlParserDOUBLE_BAR = 1200 + TSqlParserDOT = 1201 + TSqlParserUNDERLINE = 1202 + TSqlParserAT = 1203 + TSqlParserSHARP = 1204 + TSqlParserDOLLAR = 1205 + TSqlParserLR_BRACKET = 1206 + TSqlParserRR_BRACKET = 1207 + TSqlParserCOMMA = 1208 + TSqlParserSEMI = 1209 + TSqlParserCOLON = 1210 + TSqlParserDOUBLE_COLON = 1211 + TSqlParserSTAR = 1212 + TSqlParserDIVIDE = 1213 + TSqlParserMODULE = 1214 + TSqlParserPLUS = 1215 + TSqlParserMINUS = 1216 + TSqlParserBIT_NOT = 1217 + TSqlParserBIT_OR = 1218 + TSqlParserBIT_AND = 1219 + TSqlParserBIT_XOR = 1220 + TSqlParserPLACEHOLDER = 1221 +) + +// TSqlParser rules. +const ( + TSqlParserRULE_tsql_file = 0 + TSqlParserRULE_batch_without_go = 1 + TSqlParserRULE_batch_level_statement = 2 + TSqlParserRULE_sql_clauses = 3 + TSqlParserRULE_dml_clause = 4 + TSqlParserRULE_ddl_clause = 5 + TSqlParserRULE_backup_statement = 6 + TSqlParserRULE_cfl_statement = 7 + TSqlParserRULE_block_statement = 8 + TSqlParserRULE_break_statement = 9 + TSqlParserRULE_continue_statement = 10 + TSqlParserRULE_goto_statement = 11 + TSqlParserRULE_return_statement = 12 + TSqlParserRULE_if_statement = 13 + TSqlParserRULE_throw_statement = 14 + TSqlParserRULE_throw_error_number = 15 + TSqlParserRULE_throw_message = 16 + TSqlParserRULE_throw_state = 17 + TSqlParserRULE_try_catch_statement = 18 + TSqlParserRULE_waitfor_statement = 19 + TSqlParserRULE_while_statement = 20 + TSqlParserRULE_print_statement = 21 + TSqlParserRULE_raiseerror_statement = 22 + TSqlParserRULE_empty_statement = 23 + TSqlParserRULE_another_statement = 24 + TSqlParserRULE_alter_application_role = 25 + TSqlParserRULE_alter_xml_schema_collection = 26 + TSqlParserRULE_create_application_role = 27 + TSqlParserRULE_drop_aggregate = 28 + TSqlParserRULE_drop_application_role = 29 + TSqlParserRULE_alter_assembly = 30 + TSqlParserRULE_alter_assembly_start = 31 + TSqlParserRULE_alter_assembly_clause = 32 + TSqlParserRULE_alter_assembly_from_clause = 33 + TSqlParserRULE_alter_assembly_from_clause_start = 34 + TSqlParserRULE_alter_assembly_drop_clause = 35 + TSqlParserRULE_alter_assembly_drop_multiple_files = 36 + TSqlParserRULE_alter_assembly_drop = 37 + TSqlParserRULE_alter_assembly_add_clause = 38 + TSqlParserRULE_alter_asssembly_add_clause_start = 39 + TSqlParserRULE_alter_assembly_client_file_clause = 40 + TSqlParserRULE_alter_assembly_file_name = 41 + TSqlParserRULE_alter_assembly_file_bits = 42 + TSqlParserRULE_alter_assembly_as = 43 + TSqlParserRULE_alter_assembly_with_clause = 44 + TSqlParserRULE_alter_assembly_with = 45 + TSqlParserRULE_client_assembly_specifier = 46 + TSqlParserRULE_assembly_option = 47 + TSqlParserRULE_network_file_share = 48 + TSqlParserRULE_network_computer = 49 + TSqlParserRULE_network_file_start = 50 + TSqlParserRULE_file_path = 51 + TSqlParserRULE_file_directory_path_separator = 52 + TSqlParserRULE_local_file = 53 + TSqlParserRULE_local_drive = 54 + TSqlParserRULE_multiple_local_files = 55 + TSqlParserRULE_multiple_local_file_start = 56 + TSqlParserRULE_create_assembly = 57 + TSqlParserRULE_drop_assembly = 58 + TSqlParserRULE_alter_asymmetric_key = 59 + TSqlParserRULE_alter_asymmetric_key_start = 60 + TSqlParserRULE_asymmetric_key_option = 61 + TSqlParserRULE_asymmetric_key_option_start = 62 + TSqlParserRULE_asymmetric_key_password_change_option = 63 + TSqlParserRULE_create_asymmetric_key = 64 + TSqlParserRULE_drop_asymmetric_key = 65 + TSqlParserRULE_alter_authorization = 66 + TSqlParserRULE_authorization_grantee = 67 + TSqlParserRULE_entity_to = 68 + TSqlParserRULE_colon_colon = 69 + TSqlParserRULE_alter_authorization_start = 70 + TSqlParserRULE_alter_authorization_for_sql_database = 71 + TSqlParserRULE_alter_authorization_for_azure_dw = 72 + TSqlParserRULE_alter_authorization_for_parallel_dw = 73 + TSqlParserRULE_class_type = 74 + TSqlParserRULE_class_type_for_sql_database = 75 + TSqlParserRULE_class_type_for_azure_dw = 76 + TSqlParserRULE_class_type_for_parallel_dw = 77 + TSqlParserRULE_class_type_for_grant = 78 + TSqlParserRULE_drop_availability_group = 79 + TSqlParserRULE_alter_availability_group = 80 + TSqlParserRULE_alter_availability_group_start = 81 + TSqlParserRULE_alter_availability_group_options = 82 + TSqlParserRULE_ip_v4_failover = 83 + TSqlParserRULE_ip_v6_failover = 84 + TSqlParserRULE_create_or_alter_broker_priority = 85 + TSqlParserRULE_drop_broker_priority = 86 + TSqlParserRULE_alter_certificate = 87 + TSqlParserRULE_alter_column_encryption_key = 88 + TSqlParserRULE_create_column_encryption_key = 89 + TSqlParserRULE_drop_certificate = 90 + TSqlParserRULE_drop_column_encryption_key = 91 + TSqlParserRULE_drop_column_master_key = 92 + TSqlParserRULE_drop_contract = 93 + TSqlParserRULE_drop_credential = 94 + TSqlParserRULE_drop_cryptograhic_provider = 95 + TSqlParserRULE_drop_database = 96 + TSqlParserRULE_drop_database_audit_specification = 97 + TSqlParserRULE_drop_database_encryption_key = 98 + TSqlParserRULE_drop_database_scoped_credential = 99 + TSqlParserRULE_drop_default = 100 + TSqlParserRULE_drop_endpoint = 101 + TSqlParserRULE_drop_external_data_source = 102 + TSqlParserRULE_drop_external_file_format = 103 + TSqlParserRULE_drop_external_library = 104 + TSqlParserRULE_drop_external_resource_pool = 105 + TSqlParserRULE_drop_external_table = 106 + TSqlParserRULE_drop_event_notifications = 107 + TSqlParserRULE_drop_event_session = 108 + TSqlParserRULE_drop_fulltext_catalog = 109 + TSqlParserRULE_drop_fulltext_index = 110 + TSqlParserRULE_drop_fulltext_stoplist = 111 + TSqlParserRULE_drop_login = 112 + TSqlParserRULE_drop_master_key = 113 + TSqlParserRULE_drop_message_type = 114 + TSqlParserRULE_drop_partition_function = 115 + TSqlParserRULE_drop_partition_scheme = 116 + TSqlParserRULE_drop_queue = 117 + TSqlParserRULE_drop_remote_service_binding = 118 + TSqlParserRULE_drop_resource_pool = 119 + TSqlParserRULE_drop_db_role = 120 + TSqlParserRULE_drop_route = 121 + TSqlParserRULE_drop_rule = 122 + TSqlParserRULE_drop_schema = 123 + TSqlParserRULE_drop_search_property_list = 124 + TSqlParserRULE_drop_security_policy = 125 + TSqlParserRULE_drop_sequence = 126 + TSqlParserRULE_drop_server_audit = 127 + TSqlParserRULE_drop_server_audit_specification = 128 + TSqlParserRULE_drop_server_role = 129 + TSqlParserRULE_drop_service = 130 + TSqlParserRULE_drop_signature = 131 + TSqlParserRULE_drop_statistics_name_azure_dw_and_pdw = 132 + TSqlParserRULE_drop_symmetric_key = 133 + TSqlParserRULE_drop_synonym = 134 + TSqlParserRULE_drop_user = 135 + TSqlParserRULE_drop_workload_group = 136 + TSqlParserRULE_drop_xml_schema_collection = 137 + TSqlParserRULE_disable_trigger = 138 + TSqlParserRULE_enable_trigger = 139 + TSqlParserRULE_lock_table = 140 + TSqlParserRULE_truncate_table = 141 + TSqlParserRULE_create_column_master_key = 142 + TSqlParserRULE_alter_credential = 143 + TSqlParserRULE_create_credential = 144 + TSqlParserRULE_alter_cryptographic_provider = 145 + TSqlParserRULE_create_cryptographic_provider = 146 + TSqlParserRULE_create_endpoint = 147 + TSqlParserRULE_endpoint_encryption_alogorithm_clause = 148 + TSqlParserRULE_endpoint_authentication_clause = 149 + TSqlParserRULE_endpoint_listener_clause = 150 + TSqlParserRULE_create_event_notification = 151 + TSqlParserRULE_create_or_alter_event_session = 152 + TSqlParserRULE_event_session_predicate_expression = 153 + TSqlParserRULE_event_session_predicate_factor = 154 + TSqlParserRULE_event_session_predicate_leaf = 155 + TSqlParserRULE_alter_external_data_source = 156 + TSqlParserRULE_alter_external_library = 157 + TSqlParserRULE_create_external_library = 158 + TSqlParserRULE_alter_external_resource_pool = 159 + TSqlParserRULE_create_external_resource_pool = 160 + TSqlParserRULE_alter_fulltext_catalog = 161 + TSqlParserRULE_create_fulltext_catalog = 162 + TSqlParserRULE_alter_fulltext_stoplist = 163 + TSqlParserRULE_create_fulltext_stoplist = 164 + TSqlParserRULE_alter_login_sql_server = 165 + TSqlParserRULE_create_login_sql_server = 166 + TSqlParserRULE_alter_login_azure_sql = 167 + TSqlParserRULE_create_login_azure_sql = 168 + TSqlParserRULE_alter_login_azure_sql_dw_and_pdw = 169 + TSqlParserRULE_create_login_pdw = 170 + TSqlParserRULE_alter_master_key_sql_server = 171 + TSqlParserRULE_create_master_key_sql_server = 172 + TSqlParserRULE_alter_master_key_azure_sql = 173 + TSqlParserRULE_create_master_key_azure_sql = 174 + TSqlParserRULE_alter_message_type = 175 + TSqlParserRULE_alter_partition_function = 176 + TSqlParserRULE_alter_partition_scheme = 177 + TSqlParserRULE_alter_remote_service_binding = 178 + TSqlParserRULE_create_remote_service_binding = 179 + TSqlParserRULE_create_resource_pool = 180 + TSqlParserRULE_alter_resource_governor = 181 + TSqlParserRULE_alter_database_audit_specification = 182 + TSqlParserRULE_audit_action_spec_group = 183 + TSqlParserRULE_audit_action_specification = 184 + TSqlParserRULE_action_specification = 185 + TSqlParserRULE_audit_class_name = 186 + TSqlParserRULE_audit_securable = 187 + TSqlParserRULE_alter_db_role = 188 + TSqlParserRULE_create_database_audit_specification = 189 + TSqlParserRULE_create_db_role = 190 + TSqlParserRULE_create_route = 191 + TSqlParserRULE_create_rule = 192 + TSqlParserRULE_alter_schema_sql = 193 + TSqlParserRULE_create_schema = 194 + TSqlParserRULE_create_schema_azure_sql_dw_and_pdw = 195 + TSqlParserRULE_alter_schema_azure_sql_dw_and_pdw = 196 + TSqlParserRULE_create_search_property_list = 197 + TSqlParserRULE_create_security_policy = 198 + TSqlParserRULE_alter_sequence = 199 + TSqlParserRULE_create_sequence = 200 + TSqlParserRULE_alter_server_audit = 201 + TSqlParserRULE_create_server_audit = 202 + TSqlParserRULE_alter_server_audit_specification = 203 + TSqlParserRULE_create_server_audit_specification = 204 + TSqlParserRULE_alter_server_configuration = 205 + TSqlParserRULE_alter_server_role = 206 + TSqlParserRULE_create_server_role = 207 + TSqlParserRULE_alter_server_role_pdw = 208 + TSqlParserRULE_alter_service = 209 + TSqlParserRULE_opt_arg_clause = 210 + TSqlParserRULE_create_service = 211 + TSqlParserRULE_alter_service_master_key = 212 + TSqlParserRULE_alter_symmetric_key = 213 + TSqlParserRULE_create_synonym = 214 + TSqlParserRULE_alter_user = 215 + TSqlParserRULE_create_user = 216 + TSqlParserRULE_create_user_azure_sql_dw = 217 + TSqlParserRULE_alter_user_azure_sql = 218 + TSqlParserRULE_alter_workload_group = 219 + TSqlParserRULE_create_workload_group = 220 + TSqlParserRULE_create_xml_schema_collection = 221 + TSqlParserRULE_create_partition_function = 222 + TSqlParserRULE_create_partition_scheme = 223 + TSqlParserRULE_create_queue = 224 + TSqlParserRULE_queue_settings = 225 + TSqlParserRULE_alter_queue = 226 + TSqlParserRULE_queue_action = 227 + TSqlParserRULE_queue_rebuild_options = 228 + TSqlParserRULE_create_contract = 229 + TSqlParserRULE_conversation_statement = 230 + TSqlParserRULE_message_statement = 231 + TSqlParserRULE_merge_statement = 232 + TSqlParserRULE_when_matches = 233 + TSqlParserRULE_merge_matched = 234 + TSqlParserRULE_merge_not_matched = 235 + TSqlParserRULE_delete_statement = 236 + TSqlParserRULE_delete_statement_from = 237 + TSqlParserRULE_insert_statement = 238 + TSqlParserRULE_insert_statement_value = 239 + TSqlParserRULE_receive_statement = 240 + TSqlParserRULE_select_statement_standalone = 241 + TSqlParserRULE_select_statement = 242 + TSqlParserRULE_time = 243 + TSqlParserRULE_update_statement = 244 + TSqlParserRULE_output_clause = 245 + TSqlParserRULE_output_dml_list_elem = 246 + TSqlParserRULE_create_database = 247 + TSqlParserRULE_create_index = 248 + TSqlParserRULE_create_spatial_index = 249 + TSqlParserRULE_spatial_tessellation_scheme = 250 + TSqlParserRULE_spatial_index_options = 251 + TSqlParserRULE_spatial_index_option = 252 + TSqlParserRULE_signed_decimal = 253 + TSqlParserRULE_spatial_grid_level = 254 + TSqlParserRULE_spatial_grid_density = 255 + TSqlParserRULE_create_index_options = 256 + TSqlParserRULE_relational_index_option = 257 + TSqlParserRULE_alter_index = 258 + TSqlParserRULE_resumable_index_options = 259 + TSqlParserRULE_resumable_index_option = 260 + TSqlParserRULE_reorganize_partition = 261 + TSqlParserRULE_reorganize_options = 262 + TSqlParserRULE_reorganize_option = 263 + TSqlParserRULE_set_index_options = 264 + TSqlParserRULE_set_index_option = 265 + TSqlParserRULE_rebuild_partition = 266 + TSqlParserRULE_rebuild_index_options = 267 + TSqlParserRULE_rebuild_index_option = 268 + TSqlParserRULE_single_partition_rebuild_index_options = 269 + TSqlParserRULE_single_partition_rebuild_index_option = 270 + TSqlParserRULE_on_partitions = 271 + TSqlParserRULE_create_columnstore_index = 272 + TSqlParserRULE_create_columnstore_index_options = 273 + TSqlParserRULE_columnstore_index_option = 274 + TSqlParserRULE_create_nonclustered_columnstore_index = 275 + TSqlParserRULE_create_xml_index = 276 + TSqlParserRULE_xml_index_options = 277 + TSqlParserRULE_xml_index_option = 278 + TSqlParserRULE_create_or_alter_procedure = 279 + TSqlParserRULE_as_external_name = 280 + TSqlParserRULE_create_or_alter_trigger = 281 + TSqlParserRULE_create_or_alter_dml_trigger = 282 + TSqlParserRULE_dml_trigger_option = 283 + TSqlParserRULE_dml_trigger_operation = 284 + TSqlParserRULE_create_or_alter_ddl_trigger = 285 + TSqlParserRULE_ddl_trigger_operation = 286 + TSqlParserRULE_create_or_alter_function = 287 + TSqlParserRULE_func_body_returns_select = 288 + TSqlParserRULE_func_body_returns_table = 289 + TSqlParserRULE_func_body_returns_scalar = 290 + TSqlParserRULE_procedure_param_default_value = 291 + TSqlParserRULE_procedure_param = 292 + TSqlParserRULE_procedure_option = 293 + TSqlParserRULE_function_option = 294 + TSqlParserRULE_create_statistics = 295 + TSqlParserRULE_update_statistics = 296 + TSqlParserRULE_update_statistics_options = 297 + TSqlParserRULE_update_statistics_option = 298 + TSqlParserRULE_create_table = 299 + TSqlParserRULE_table_indices = 300 + TSqlParserRULE_table_options = 301 + TSqlParserRULE_table_option = 302 + TSqlParserRULE_create_table_index_options = 303 + TSqlParserRULE_create_table_index_option = 304 + TSqlParserRULE_create_view = 305 + TSqlParserRULE_view_attribute = 306 + TSqlParserRULE_alter_table = 307 + TSqlParserRULE_switch_partition = 308 + TSqlParserRULE_low_priority_lock_wait = 309 + TSqlParserRULE_alter_database = 310 + TSqlParserRULE_add_or_modify_files = 311 + TSqlParserRULE_filespec = 312 + TSqlParserRULE_add_or_modify_filegroups = 313 + TSqlParserRULE_filegroup_updatability_option = 314 + TSqlParserRULE_database_optionspec = 315 + TSqlParserRULE_auto_option = 316 + TSqlParserRULE_change_tracking_option = 317 + TSqlParserRULE_change_tracking_option_list = 318 + TSqlParserRULE_containment_option = 319 + TSqlParserRULE_cursor_option = 320 + TSqlParserRULE_alter_endpoint = 321 + TSqlParserRULE_database_mirroring_option = 322 + TSqlParserRULE_mirroring_set_option = 323 + TSqlParserRULE_mirroring_partner = 324 + TSqlParserRULE_mirroring_witness = 325 + TSqlParserRULE_witness_partner_equal = 326 + TSqlParserRULE_partner_option = 327 + TSqlParserRULE_witness_option = 328 + TSqlParserRULE_witness_server = 329 + TSqlParserRULE_partner_server = 330 + TSqlParserRULE_mirroring_host_port_seperator = 331 + TSqlParserRULE_partner_server_tcp_prefix = 332 + TSqlParserRULE_port_number = 333 + TSqlParserRULE_host = 334 + TSqlParserRULE_date_correlation_optimization_option = 335 + TSqlParserRULE_db_encryption_option = 336 + TSqlParserRULE_db_state_option = 337 + TSqlParserRULE_db_update_option = 338 + TSqlParserRULE_db_user_access_option = 339 + TSqlParserRULE_delayed_durability_option = 340 + TSqlParserRULE_external_access_option = 341 + TSqlParserRULE_hadr_options = 342 + TSqlParserRULE_mixed_page_allocation_option = 343 + TSqlParserRULE_parameterization_option = 344 + TSqlParserRULE_recovery_option = 345 + TSqlParserRULE_service_broker_option = 346 + TSqlParserRULE_snapshot_option = 347 + TSqlParserRULE_sql_option = 348 + TSqlParserRULE_target_recovery_time_option = 349 + TSqlParserRULE_termination = 350 + TSqlParserRULE_drop_index = 351 + TSqlParserRULE_drop_relational_or_xml_or_spatial_index = 352 + TSqlParserRULE_drop_backward_compatible_index = 353 + TSqlParserRULE_drop_procedure = 354 + TSqlParserRULE_drop_trigger = 355 + TSqlParserRULE_drop_dml_trigger = 356 + TSqlParserRULE_drop_ddl_trigger = 357 + TSqlParserRULE_drop_function = 358 + TSqlParserRULE_drop_statistics = 359 + TSqlParserRULE_drop_table = 360 + TSqlParserRULE_drop_view = 361 + TSqlParserRULE_create_type = 362 + TSqlParserRULE_drop_type = 363 + TSqlParserRULE_rowset_function_limited = 364 + TSqlParserRULE_openquery = 365 + TSqlParserRULE_opendatasource = 366 + TSqlParserRULE_declare_statement = 367 + TSqlParserRULE_xml_declaration = 368 + TSqlParserRULE_cursor_statement = 369 + TSqlParserRULE_backup_database = 370 + TSqlParserRULE_backup_log = 371 + TSqlParserRULE_backup_certificate = 372 + TSqlParserRULE_backup_master_key = 373 + TSqlParserRULE_backup_service_master_key = 374 + TSqlParserRULE_kill_statement = 375 + TSqlParserRULE_kill_process = 376 + TSqlParserRULE_kill_query_notification = 377 + TSqlParserRULE_kill_stats_job = 378 + TSqlParserRULE_execute_statement = 379 + TSqlParserRULE_execute_body_batch = 380 + TSqlParserRULE_execute_body = 381 + TSqlParserRULE_execute_statement_arg = 382 + TSqlParserRULE_execute_statement_arg_named = 383 + TSqlParserRULE_execute_statement_arg_unnamed = 384 + TSqlParserRULE_execute_parameter = 385 + TSqlParserRULE_execute_var_string = 386 + TSqlParserRULE_security_statement = 387 + TSqlParserRULE_principal_id = 388 + TSqlParserRULE_create_certificate = 389 + TSqlParserRULE_existing_keys = 390 + TSqlParserRULE_private_key_options = 391 + TSqlParserRULE_generate_new_keys = 392 + TSqlParserRULE_date_options = 393 + TSqlParserRULE_open_key = 394 + TSqlParserRULE_close_key = 395 + TSqlParserRULE_create_key = 396 + TSqlParserRULE_key_options = 397 + TSqlParserRULE_algorithm = 398 + TSqlParserRULE_encryption_mechanism = 399 + TSqlParserRULE_decryption_mechanism = 400 + TSqlParserRULE_grant_permission = 401 + TSqlParserRULE_set_statement = 402 + TSqlParserRULE_transaction_statement = 403 + TSqlParserRULE_go_statement = 404 + TSqlParserRULE_use_statement = 405 + TSqlParserRULE_setuser_statement = 406 + TSqlParserRULE_reconfigure_statement = 407 + TSqlParserRULE_shutdown_statement = 408 + TSqlParserRULE_checkpoint_statement = 409 + TSqlParserRULE_dbcc_checkalloc_option = 410 + TSqlParserRULE_dbcc_checkalloc = 411 + TSqlParserRULE_dbcc_checkcatalog = 412 + TSqlParserRULE_dbcc_checkconstraints_option = 413 + TSqlParserRULE_dbcc_checkconstraints = 414 + TSqlParserRULE_dbcc_checkdb_table_option = 415 + TSqlParserRULE_dbcc_checkdb = 416 + TSqlParserRULE_dbcc_checkfilegroup_option = 417 + TSqlParserRULE_dbcc_checkfilegroup = 418 + TSqlParserRULE_dbcc_checktable = 419 + TSqlParserRULE_dbcc_cleantable = 420 + TSqlParserRULE_dbcc_clonedatabase_option = 421 + TSqlParserRULE_dbcc_clonedatabase = 422 + TSqlParserRULE_dbcc_pdw_showspaceused = 423 + TSqlParserRULE_dbcc_proccache = 424 + TSqlParserRULE_dbcc_showcontig_option = 425 + TSqlParserRULE_dbcc_showcontig = 426 + TSqlParserRULE_dbcc_shrinklog = 427 + TSqlParserRULE_dbcc_dbreindex = 428 + TSqlParserRULE_dbcc_dll_free = 429 + TSqlParserRULE_dbcc_dropcleanbuffers = 430 + TSqlParserRULE_dbcc_clause = 431 + TSqlParserRULE_execute_clause = 432 + TSqlParserRULE_declare_local = 433 + TSqlParserRULE_table_type_definition = 434 + TSqlParserRULE_table_type_indices = 435 + TSqlParserRULE_xml_type_definition = 436 + TSqlParserRULE_xml_schema_collection = 437 + TSqlParserRULE_column_def_table_constraints = 438 + TSqlParserRULE_column_def_table_constraint = 439 + TSqlParserRULE_column_definition = 440 + TSqlParserRULE_column_definition_element = 441 + TSqlParserRULE_column_modifier = 442 + TSqlParserRULE_materialized_column_definition = 443 + TSqlParserRULE_column_constraint = 444 + TSqlParserRULE_column_index = 445 + TSqlParserRULE_on_partition_or_filegroup = 446 + TSqlParserRULE_table_constraint = 447 + TSqlParserRULE_connection_node = 448 + TSqlParserRULE_primary_key_options = 449 + TSqlParserRULE_foreign_key_options = 450 + TSqlParserRULE_check_constraint = 451 + TSqlParserRULE_on_delete = 452 + TSqlParserRULE_on_update = 453 + TSqlParserRULE_alter_table_index_options = 454 + TSqlParserRULE_alter_table_index_option = 455 + TSqlParserRULE_declare_cursor = 456 + TSqlParserRULE_declare_set_cursor_common = 457 + TSqlParserRULE_declare_set_cursor_common_partial = 458 + TSqlParserRULE_fetch_cursor = 459 + TSqlParserRULE_set_special = 460 + TSqlParserRULE_special_list = 461 + TSqlParserRULE_constant_LOCAL_ID = 462 + TSqlParserRULE_expression = 463 + TSqlParserRULE_parameter = 464 + TSqlParserRULE_time_zone = 465 + TSqlParserRULE_primitive_expression = 466 + TSqlParserRULE_case_expression = 467 + TSqlParserRULE_unary_operator_expression = 468 + TSqlParserRULE_bracket_expression = 469 + TSqlParserRULE_subquery = 470 + TSqlParserRULE_with_expression = 471 + TSqlParserRULE_common_table_expression = 472 + TSqlParserRULE_update_elem = 473 + TSqlParserRULE_update_elem_merge = 474 + TSqlParserRULE_search_condition = 475 + TSqlParserRULE_predicate = 476 + TSqlParserRULE_query_expression = 477 + TSqlParserRULE_sql_union = 478 + TSqlParserRULE_query_specification = 479 + TSqlParserRULE_group_by_clause = 480 + TSqlParserRULE_having_clause = 481 + TSqlParserRULE_from_table_sources = 482 + TSqlParserRULE_top_clause = 483 + TSqlParserRULE_top_percent = 484 + TSqlParserRULE_top_count = 485 + TSqlParserRULE_order_by_clause = 486 + TSqlParserRULE_select_order_by_clause = 487 + TSqlParserRULE_for_clause = 488 + TSqlParserRULE_xml_common_directives = 489 + TSqlParserRULE_order_by_expression = 490 + TSqlParserRULE_grouping_sets_item = 491 + TSqlParserRULE_group_by_item = 492 + TSqlParserRULE_option_clause = 493 + TSqlParserRULE_option = 494 + TSqlParserRULE_optimize_for_arg = 495 + TSqlParserRULE_select_list = 496 + TSqlParserRULE_udt_method_arguments = 497 + TSqlParserRULE_asterisk = 498 + TSqlParserRULE_udt_elem = 499 + TSqlParserRULE_expression_elem = 500 + TSqlParserRULE_select_list_elem = 501 + TSqlParserRULE_table_sources = 502 + TSqlParserRULE_table_source = 503 + TSqlParserRULE_table_source_item = 504 + TSqlParserRULE_open_xml = 505 + TSqlParserRULE_open_json = 506 + TSqlParserRULE_json_declaration = 507 + TSqlParserRULE_json_column_declaration = 508 + TSqlParserRULE_schema_declaration = 509 + TSqlParserRULE_column_declaration = 510 + TSqlParserRULE_change_table = 511 + TSqlParserRULE_change_table_changes = 512 + TSqlParserRULE_change_table_version = 513 + TSqlParserRULE_join_part = 514 + TSqlParserRULE_join_on = 515 + TSqlParserRULE_cross_join = 516 + TSqlParserRULE_apply_ = 517 + TSqlParserRULE_pivot = 518 + TSqlParserRULE_unpivot = 519 + TSqlParserRULE_pivot_clause = 520 + TSqlParserRULE_unpivot_clause = 521 + TSqlParserRULE_full_column_name_list = 522 + TSqlParserRULE_rowset_function = 523 + TSqlParserRULE_bulk_option = 524 + TSqlParserRULE_derived_table = 525 + TSqlParserRULE_function_call = 526 + TSqlParserRULE_partition_function = 527 + TSqlParserRULE_freetext_function = 528 + TSqlParserRULE_freetext_predicate = 529 + TSqlParserRULE_json_key_value = 530 + TSqlParserRULE_json_null_clause = 531 + TSqlParserRULE_built_in_functions = 532 + TSqlParserRULE_xml_data_type_methods = 533 + TSqlParserRULE_dateparts_9 = 534 + TSqlParserRULE_dateparts_12 = 535 + TSqlParserRULE_dateparts_15 = 536 + TSqlParserRULE_dateparts_datetrunc = 537 + TSqlParserRULE_value_method = 538 + TSqlParserRULE_value_call = 539 + TSqlParserRULE_query_method = 540 + TSqlParserRULE_query_call = 541 + TSqlParserRULE_exist_method = 542 + TSqlParserRULE_exist_call = 543 + TSqlParserRULE_modify_method = 544 + TSqlParserRULE_modify_call = 545 + TSqlParserRULE_hierarchyid_call = 546 + TSqlParserRULE_hierarchyid_static_method = 547 + TSqlParserRULE_nodes_method = 548 + TSqlParserRULE_switch_section = 549 + TSqlParserRULE_switch_search_condition_section = 550 + TSqlParserRULE_as_column_alias = 551 + TSqlParserRULE_as_table_alias = 552 + TSqlParserRULE_table_alias = 553 + TSqlParserRULE_with_table_hints = 554 + TSqlParserRULE_deprecated_table_hint = 555 + TSqlParserRULE_sybase_legacy_hints = 556 + TSqlParserRULE_sybase_legacy_hint = 557 + TSqlParserRULE_table_hint = 558 + TSqlParserRULE_index_value = 559 + TSqlParserRULE_column_alias_list = 560 + TSqlParserRULE_column_alias = 561 + TSqlParserRULE_table_value_constructor = 562 + TSqlParserRULE_expression_list_ = 563 + TSqlParserRULE_ranking_windowed_function = 564 + TSqlParserRULE_aggregate_windowed_function = 565 + TSqlParserRULE_analytic_windowed_function = 566 + TSqlParserRULE_all_distinct_expression = 567 + TSqlParserRULE_over_clause = 568 + TSqlParserRULE_row_or_range_clause = 569 + TSqlParserRULE_window_frame_extent = 570 + TSqlParserRULE_window_frame_bound = 571 + TSqlParserRULE_window_frame_preceding = 572 + TSqlParserRULE_window_frame_following = 573 + TSqlParserRULE_create_database_option = 574 + TSqlParserRULE_database_filestream_option = 575 + TSqlParserRULE_database_file_spec = 576 + TSqlParserRULE_file_group = 577 + TSqlParserRULE_file_spec = 578 + TSqlParserRULE_entity_name = 579 + TSqlParserRULE_entity_name_for_azure_dw = 580 + TSqlParserRULE_entity_name_for_parallel_dw = 581 + TSqlParserRULE_full_table_name = 582 + TSqlParserRULE_dotID = 583 + TSqlParserRULE_doubleDotID = 584 + TSqlParserRULE_table_name = 585 + TSqlParserRULE_simple_name = 586 + TSqlParserRULE_func_proc_name_schema = 587 + TSqlParserRULE_func_proc_name_database_schema = 588 + TSqlParserRULE_func_proc_name_server_database_schema = 589 + TSqlParserRULE_ddl_object = 590 + TSqlParserRULE_full_column_name = 591 + TSqlParserRULE_column_name_list_with_order = 592 + TSqlParserRULE_column_name_with_order = 593 + TSqlParserRULE_insert_column_name_list = 594 + TSqlParserRULE_insert_column_id = 595 + TSqlParserRULE_column_name_list = 596 + TSqlParserRULE_cursor_name = 597 + TSqlParserRULE_on_off = 598 + TSqlParserRULE_clustered = 599 + TSqlParserRULE_null_notnull = 600 + TSqlParserRULE_scalar_function_name = 601 + TSqlParserRULE_begin_conversation_timer = 602 + TSqlParserRULE_begin_conversation_dialog = 603 + TSqlParserRULE_contract_name = 604 + TSqlParserRULE_service_name = 605 + TSqlParserRULE_end_conversation = 606 + TSqlParserRULE_waitfor_conversation = 607 + TSqlParserRULE_get_conversation = 608 + TSqlParserRULE_queue_id = 609 + TSqlParserRULE_send_conversation = 610 + TSqlParserRULE_data_type = 611 + TSqlParserRULE_constant = 612 + TSqlParserRULE_primitive_constant = 613 + TSqlParserRULE_keyword = 614 + TSqlParserRULE_id_ = 615 + TSqlParserRULE_simple_id = 616 + TSqlParserRULE_id_or_string = 617 + TSqlParserRULE_comparison_operator = 618 + TSqlParserRULE_assignment_operator = 619 + TSqlParserRULE_file_size = 620 +) + +// ITsql_fileContext is an interface to support dynamic dispatch. +type ITsql_fileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EOF() antlr.TerminalNode + AllGo_statement() []IGo_statementContext + Go_statement(i int) IGo_statementContext + AllBatch_without_go() []IBatch_without_goContext + Batch_without_go(i int) IBatch_without_goContext + + // IsTsql_fileContext differentiates from other interfaces. + IsTsql_fileContext() +} + +type Tsql_fileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTsql_fileContext() *Tsql_fileContext { + var p = new(Tsql_fileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_tsql_file + return p +} + +func InitEmptyTsql_fileContext(p *Tsql_fileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_tsql_file +} + +func (*Tsql_fileContext) IsTsql_fileContext() {} + +func NewTsql_fileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tsql_fileContext { + var p = new(Tsql_fileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_tsql_file + + return p +} + +func (s *Tsql_fileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tsql_fileContext) EOF() antlr.TerminalNode { + return s.GetToken(TSqlParserEOF, 0) +} + +func (s *Tsql_fileContext) AllGo_statement() []IGo_statementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGo_statementContext); ok { + len++ + } + } + + tst := make([]IGo_statementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGo_statementContext); ok { + tst[i] = t.(IGo_statementContext) + i++ + } + } + + return tst +} + +func (s *Tsql_fileContext) Go_statement(i int) IGo_statementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGo_statementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGo_statementContext) +} + +func (s *Tsql_fileContext) AllBatch_without_go() []IBatch_without_goContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBatch_without_goContext); ok { + len++ + } + } + + tst := make([]IBatch_without_goContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBatch_without_goContext); ok { + tst[i] = t.(IBatch_without_goContext) + i++ + } + } + + return tst +} + +func (s *Tsql_fileContext) Batch_without_go(i int) IBatch_without_goContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBatch_without_goContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBatch_without_goContext) +} + +func (s *Tsql_fileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tsql_fileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tsql_fileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTsql_file(s) + } +} + +func (s *Tsql_fileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTsql_file(s) + } +} + +func (s *Tsql_fileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTsql_file(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Tsql_file() (localctx ITsql_fileContext) { + localctx = NewTsql_fileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 0, TSqlParserRULE_tsql_file) + var _la int + + var _alt int + + p.SetState(1264) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 4, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(1245) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserGO { + { + p.SetState(1242) + p.Go_statement() + } + + p.SetState(1247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1248) + p.Match(TSqlParserEOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1249) + p.Batch_without_go() + } + p.SetState(1256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1250) + p.Go_statement() + } + p.SetState(1252) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1, p.GetParserRuleContext()) == 1 { + { + p.SetState(1251) + p.Batch_without_go() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + p.SetState(1258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(1260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserGO { + { + p.SetState(1259) + p.Go_statement() + } + + } + { + p.SetState(1262) + p.Match(TSqlParserEOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBatch_without_goContext is an interface to support dynamic dispatch. +type IBatch_without_goContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSql_clauses() []ISql_clausesContext + Sql_clauses(i int) ISql_clausesContext + Batch_level_statement() IBatch_level_statementContext + Execute_body_batch() IExecute_body_batchContext + + // IsBatch_without_goContext differentiates from other interfaces. + IsBatch_without_goContext() +} + +type Batch_without_goContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBatch_without_goContext() *Batch_without_goContext { + var p = new(Batch_without_goContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_batch_without_go + return p +} + +func InitEmptyBatch_without_goContext(p *Batch_without_goContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_batch_without_go +} + +func (*Batch_without_goContext) IsBatch_without_goContext() {} + +func NewBatch_without_goContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Batch_without_goContext { + var p = new(Batch_without_goContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_batch_without_go + + return p +} + +func (s *Batch_without_goContext) GetParser() antlr.Parser { return s.parser } + +func (s *Batch_without_goContext) AllSql_clauses() []ISql_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_clausesContext); ok { + len++ + } + } + + tst := make([]ISql_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_clausesContext); ok { + tst[i] = t.(ISql_clausesContext) + i++ + } + } + + return tst +} + +func (s *Batch_without_goContext) Sql_clauses(i int) ISql_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_clausesContext) +} + +func (s *Batch_without_goContext) Batch_level_statement() IBatch_level_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBatch_level_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBatch_level_statementContext) +} + +func (s *Batch_without_goContext) Execute_body_batch() IExecute_body_batchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_body_batchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_body_batchContext) +} + +func (s *Batch_without_goContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Batch_without_goContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Batch_without_goContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBatch_without_go(s) + } +} + +func (s *Batch_without_goContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBatch_without_go(s) + } +} + +func (s *Batch_without_goContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBatch_without_go(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Batch_without_go() (localctx IBatch_without_goContext) { + localctx = NewBatch_without_goContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2, TSqlParserRULE_batch_without_go) + var _alt int + + p.SetState(1279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 7, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(1267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(1266) + p.Sql_clauses() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(1269) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1271) + p.Batch_level_statement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1272) + p.Execute_body_batch() + } + p.SetState(1276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 6, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1273) + p.Sql_clauses() + } + + } + p.SetState(1278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 6, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBatch_level_statementContext is an interface to support dynamic dispatch. +type IBatch_level_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Create_or_alter_function() ICreate_or_alter_functionContext + Create_or_alter_procedure() ICreate_or_alter_procedureContext + Create_or_alter_trigger() ICreate_or_alter_triggerContext + Create_view() ICreate_viewContext + + // IsBatch_level_statementContext differentiates from other interfaces. + IsBatch_level_statementContext() +} + +type Batch_level_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBatch_level_statementContext() *Batch_level_statementContext { + var p = new(Batch_level_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_batch_level_statement + return p +} + +func InitEmptyBatch_level_statementContext(p *Batch_level_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_batch_level_statement +} + +func (*Batch_level_statementContext) IsBatch_level_statementContext() {} + +func NewBatch_level_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Batch_level_statementContext { + var p = new(Batch_level_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_batch_level_statement + + return p +} + +func (s *Batch_level_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Batch_level_statementContext) Create_or_alter_function() ICreate_or_alter_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_or_alter_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_or_alter_functionContext) +} + +func (s *Batch_level_statementContext) Create_or_alter_procedure() ICreate_or_alter_procedureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_or_alter_procedureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_or_alter_procedureContext) +} + +func (s *Batch_level_statementContext) Create_or_alter_trigger() ICreate_or_alter_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_or_alter_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_or_alter_triggerContext) +} + +func (s *Batch_level_statementContext) Create_view() ICreate_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_viewContext) +} + +func (s *Batch_level_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Batch_level_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Batch_level_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBatch_level_statement(s) + } +} + +func (s *Batch_level_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBatch_level_statement(s) + } +} + +func (s *Batch_level_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBatch_level_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Batch_level_statement() (localctx IBatch_level_statementContext) { + localctx = NewBatch_level_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 4, TSqlParserRULE_batch_level_statement) + p.SetState(1285) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 8, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1281) + p.Create_or_alter_function() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1282) + p.Create_or_alter_procedure() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1283) + p.Create_or_alter_trigger() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1284) + p.Create_view() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_clausesContext is an interface to support dynamic dispatch. +type ISql_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Dml_clause() IDml_clauseContext + SEMI() antlr.TerminalNode + Cfl_statement() ICfl_statementContext + Another_statement() IAnother_statementContext + Ddl_clause() IDdl_clauseContext + Dbcc_clause() IDbcc_clauseContext + Backup_statement() IBackup_statementContext + + // IsSql_clausesContext differentiates from other interfaces. + IsSql_clausesContext() +} + +type Sql_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_clausesContext() *Sql_clausesContext { + var p = new(Sql_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_sql_clauses + return p +} + +func InitEmptySql_clausesContext(p *Sql_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_sql_clauses +} + +func (*Sql_clausesContext) IsSql_clausesContext() {} + +func NewSql_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_clausesContext { + var p = new(Sql_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_sql_clauses + + return p +} + +func (s *Sql_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_clausesContext) Dml_clause() IDml_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_clauseContext) +} + +func (s *Sql_clausesContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Sql_clausesContext) Cfl_statement() ICfl_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICfl_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICfl_statementContext) +} + +func (s *Sql_clausesContext) Another_statement() IAnother_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnother_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnother_statementContext) +} + +func (s *Sql_clausesContext) Ddl_clause() IDdl_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDdl_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDdl_clauseContext) +} + +func (s *Sql_clausesContext) Dbcc_clause() IDbcc_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_clauseContext) +} + +func (s *Sql_clausesContext) Backup_statement() IBackup_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBackup_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBackup_statementContext) +} + +func (s *Sql_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSql_clauses(s) + } +} + +func (s *Sql_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSql_clauses(s) + } +} + +func (s *Sql_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSql_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Sql_clauses() (localctx ISql_clausesContext) { + localctx = NewSql_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 6, TSqlParserRULE_sql_clauses) + p.SetState(1312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 15, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1287) + p.Dml_clause() + } + p.SetState(1289) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 9, p.GetParserRuleContext()) == 1 { + { + p.SetState(1288) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1291) + p.Cfl_statement() + } + p.SetState(1293) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 10, p.GetParserRuleContext()) == 1 { + { + p.SetState(1292) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1295) + p.Another_statement() + } + p.SetState(1297) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 11, p.GetParserRuleContext()) == 1 { + { + p.SetState(1296) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1299) + p.Ddl_clause() + } + p.SetState(1301) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 12, p.GetParserRuleContext()) == 1 { + { + p.SetState(1300) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1303) + p.Dbcc_clause() + } + p.SetState(1305) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 13, p.GetParserRuleContext()) == 1 { + { + p.SetState(1304) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1307) + p.Backup_statement() + } + p.SetState(1309) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 14, p.GetParserRuleContext()) == 1 { + { + p.SetState(1308) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1311) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDml_clauseContext is an interface to support dynamic dispatch. +type IDml_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Merge_statement() IMerge_statementContext + Delete_statement() IDelete_statementContext + Insert_statement() IInsert_statementContext + Select_statement_standalone() ISelect_statement_standaloneContext + Update_statement() IUpdate_statementContext + + // IsDml_clauseContext differentiates from other interfaces. + IsDml_clauseContext() +} + +type Dml_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDml_clauseContext() *Dml_clauseContext { + var p = new(Dml_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dml_clause + return p +} + +func InitEmptyDml_clauseContext(p *Dml_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dml_clause +} + +func (*Dml_clauseContext) IsDml_clauseContext() {} + +func NewDml_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_clauseContext { + var p = new(Dml_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dml_clause + + return p +} + +func (s *Dml_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dml_clauseContext) Merge_statement() IMerge_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_statementContext) +} + +func (s *Dml_clauseContext) Delete_statement() IDelete_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelete_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelete_statementContext) +} + +func (s *Dml_clauseContext) Insert_statement() IInsert_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_statementContext) +} + +func (s *Dml_clauseContext) Select_statement_standalone() ISelect_statement_standaloneContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statement_standaloneContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statement_standaloneContext) +} + +func (s *Dml_clauseContext) Update_statement() IUpdate_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_statementContext) +} + +func (s *Dml_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dml_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dml_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDml_clause(s) + } +} + +func (s *Dml_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDml_clause(s) + } +} + +func (s *Dml_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDml_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dml_clause() (localctx IDml_clauseContext) { + localctx = NewDml_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 8, TSqlParserRULE_dml_clause) + p.SetState(1319) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 16, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1314) + p.Merge_statement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1315) + p.Delete_statement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1316) + p.Insert_statement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1317) + p.Select_statement_standalone() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1318) + p.Update_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDdl_clauseContext is an interface to support dynamic dispatch. +type IDdl_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_application_role() IAlter_application_roleContext + Alter_assembly() IAlter_assemblyContext + Alter_asymmetric_key() IAlter_asymmetric_keyContext + Alter_authorization() IAlter_authorizationContext + Alter_authorization_for_azure_dw() IAlter_authorization_for_azure_dwContext + Alter_authorization_for_parallel_dw() IAlter_authorization_for_parallel_dwContext + Alter_authorization_for_sql_database() IAlter_authorization_for_sql_databaseContext + Alter_availability_group() IAlter_availability_groupContext + Alter_certificate() IAlter_certificateContext + Alter_column_encryption_key() IAlter_column_encryption_keyContext + Alter_credential() IAlter_credentialContext + Alter_cryptographic_provider() IAlter_cryptographic_providerContext + Alter_database() IAlter_databaseContext + Alter_database_audit_specification() IAlter_database_audit_specificationContext + Alter_db_role() IAlter_db_roleContext + Alter_endpoint() IAlter_endpointContext + Alter_external_data_source() IAlter_external_data_sourceContext + Alter_external_library() IAlter_external_libraryContext + Alter_external_resource_pool() IAlter_external_resource_poolContext + Alter_fulltext_catalog() IAlter_fulltext_catalogContext + Alter_fulltext_stoplist() IAlter_fulltext_stoplistContext + Alter_index() IAlter_indexContext + Alter_login_azure_sql() IAlter_login_azure_sqlContext + Alter_login_azure_sql_dw_and_pdw() IAlter_login_azure_sql_dw_and_pdwContext + Alter_login_sql_server() IAlter_login_sql_serverContext + Alter_master_key_azure_sql() IAlter_master_key_azure_sqlContext + Alter_master_key_sql_server() IAlter_master_key_sql_serverContext + Alter_message_type() IAlter_message_typeContext + Alter_partition_function() IAlter_partition_functionContext + Alter_partition_scheme() IAlter_partition_schemeContext + Alter_remote_service_binding() IAlter_remote_service_bindingContext + Alter_resource_governor() IAlter_resource_governorContext + Alter_schema_azure_sql_dw_and_pdw() IAlter_schema_azure_sql_dw_and_pdwContext + Alter_schema_sql() IAlter_schema_sqlContext + Alter_sequence() IAlter_sequenceContext + Alter_server_audit() IAlter_server_auditContext + Alter_server_audit_specification() IAlter_server_audit_specificationContext + Alter_server_configuration() IAlter_server_configurationContext + Alter_server_role() IAlter_server_roleContext + Alter_server_role_pdw() IAlter_server_role_pdwContext + Alter_service() IAlter_serviceContext + Alter_service_master_key() IAlter_service_master_keyContext + Alter_symmetric_key() IAlter_symmetric_keyContext + Alter_table() IAlter_tableContext + Alter_user() IAlter_userContext + Alter_user_azure_sql() IAlter_user_azure_sqlContext + Alter_workload_group() IAlter_workload_groupContext + Alter_xml_schema_collection() IAlter_xml_schema_collectionContext + Create_application_role() ICreate_application_roleContext + Create_assembly() ICreate_assemblyContext + Create_asymmetric_key() ICreate_asymmetric_keyContext + Create_column_encryption_key() ICreate_column_encryption_keyContext + Create_column_master_key() ICreate_column_master_keyContext + Create_columnstore_index() ICreate_columnstore_indexContext + Create_credential() ICreate_credentialContext + Create_cryptographic_provider() ICreate_cryptographic_providerContext + Create_database() ICreate_databaseContext + Create_database_audit_specification() ICreate_database_audit_specificationContext + Create_db_role() ICreate_db_roleContext + Create_endpoint() ICreate_endpointContext + Create_event_notification() ICreate_event_notificationContext + Create_external_library() ICreate_external_libraryContext + Create_external_resource_pool() ICreate_external_resource_poolContext + Create_fulltext_catalog() ICreate_fulltext_catalogContext + Create_fulltext_stoplist() ICreate_fulltext_stoplistContext + Create_index() ICreate_indexContext + Create_login_azure_sql() ICreate_login_azure_sqlContext + Create_login_pdw() ICreate_login_pdwContext + Create_login_sql_server() ICreate_login_sql_serverContext + Create_master_key_azure_sql() ICreate_master_key_azure_sqlContext + Create_master_key_sql_server() ICreate_master_key_sql_serverContext + Create_nonclustered_columnstore_index() ICreate_nonclustered_columnstore_indexContext + Create_or_alter_broker_priority() ICreate_or_alter_broker_priorityContext + Create_or_alter_event_session() ICreate_or_alter_event_sessionContext + Create_partition_function() ICreate_partition_functionContext + Create_partition_scheme() ICreate_partition_schemeContext + Create_remote_service_binding() ICreate_remote_service_bindingContext + Create_resource_pool() ICreate_resource_poolContext + Create_route() ICreate_routeContext + Create_rule() ICreate_ruleContext + Create_schema() ICreate_schemaContext + Create_schema_azure_sql_dw_and_pdw() ICreate_schema_azure_sql_dw_and_pdwContext + Create_spatial_index() ICreate_spatial_indexContext + Create_search_property_list() ICreate_search_property_listContext + Create_security_policy() ICreate_security_policyContext + Create_sequence() ICreate_sequenceContext + Create_server_audit() ICreate_server_auditContext + Create_server_audit_specification() ICreate_server_audit_specificationContext + Create_server_role() ICreate_server_roleContext + Create_service() ICreate_serviceContext + Create_statistics() ICreate_statisticsContext + Create_synonym() ICreate_synonymContext + Create_table() ICreate_tableContext + Create_type() ICreate_typeContext + Create_user() ICreate_userContext + Create_user_azure_sql_dw() ICreate_user_azure_sql_dwContext + Create_workload_group() ICreate_workload_groupContext + Create_xml_index() ICreate_xml_indexContext + Create_xml_schema_collection() ICreate_xml_schema_collectionContext + Disable_trigger() IDisable_triggerContext + Drop_aggregate() IDrop_aggregateContext + Drop_application_role() IDrop_application_roleContext + Drop_assembly() IDrop_assemblyContext + Drop_asymmetric_key() IDrop_asymmetric_keyContext + Drop_availability_group() IDrop_availability_groupContext + Drop_broker_priority() IDrop_broker_priorityContext + Drop_certificate() IDrop_certificateContext + Drop_column_encryption_key() IDrop_column_encryption_keyContext + Drop_column_master_key() IDrop_column_master_keyContext + Drop_contract() IDrop_contractContext + Drop_credential() IDrop_credentialContext + Drop_cryptograhic_provider() IDrop_cryptograhic_providerContext + Drop_database() IDrop_databaseContext + Drop_database_audit_specification() IDrop_database_audit_specificationContext + Drop_database_encryption_key() IDrop_database_encryption_keyContext + Drop_database_scoped_credential() IDrop_database_scoped_credentialContext + Drop_db_role() IDrop_db_roleContext + Drop_default() IDrop_defaultContext + Drop_endpoint() IDrop_endpointContext + Drop_event_notifications() IDrop_event_notificationsContext + Drop_event_session() IDrop_event_sessionContext + Drop_external_data_source() IDrop_external_data_sourceContext + Drop_external_file_format() IDrop_external_file_formatContext + Drop_external_library() IDrop_external_libraryContext + Drop_external_resource_pool() IDrop_external_resource_poolContext + Drop_external_table() IDrop_external_tableContext + Drop_fulltext_catalog() IDrop_fulltext_catalogContext + Drop_fulltext_index() IDrop_fulltext_indexContext + Drop_fulltext_stoplist() IDrop_fulltext_stoplistContext + Drop_function() IDrop_functionContext + Drop_index() IDrop_indexContext + Drop_login() IDrop_loginContext + Drop_master_key() IDrop_master_keyContext + Drop_message_type() IDrop_message_typeContext + Drop_partition_function() IDrop_partition_functionContext + Drop_partition_scheme() IDrop_partition_schemeContext + Drop_procedure() IDrop_procedureContext + Drop_queue() IDrop_queueContext + Drop_remote_service_binding() IDrop_remote_service_bindingContext + Drop_resource_pool() IDrop_resource_poolContext + Drop_route() IDrop_routeContext + Drop_rule() IDrop_ruleContext + Drop_schema() IDrop_schemaContext + Drop_search_property_list() IDrop_search_property_listContext + Drop_security_policy() IDrop_security_policyContext + Drop_sequence() IDrop_sequenceContext + Drop_server_audit() IDrop_server_auditContext + Drop_server_audit_specification() IDrop_server_audit_specificationContext + Drop_server_role() IDrop_server_roleContext + Drop_service() IDrop_serviceContext + Drop_signature() IDrop_signatureContext + Drop_statistics() IDrop_statisticsContext + Drop_statistics_name_azure_dw_and_pdw() IDrop_statistics_name_azure_dw_and_pdwContext + Drop_symmetric_key() IDrop_symmetric_keyContext + Drop_synonym() IDrop_synonymContext + Drop_table() IDrop_tableContext + Drop_trigger() IDrop_triggerContext + Drop_type() IDrop_typeContext + Drop_user() IDrop_userContext + Drop_view() IDrop_viewContext + Drop_workload_group() IDrop_workload_groupContext + Drop_xml_schema_collection() IDrop_xml_schema_collectionContext + Enable_trigger() IEnable_triggerContext + Lock_table() ILock_tableContext + Truncate_table() ITruncate_tableContext + Update_statistics() IUpdate_statisticsContext + + // IsDdl_clauseContext differentiates from other interfaces. + IsDdl_clauseContext() +} + +type Ddl_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDdl_clauseContext() *Ddl_clauseContext { + var p = new(Ddl_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_ddl_clause + return p +} + +func InitEmptyDdl_clauseContext(p *Ddl_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_ddl_clause +} + +func (*Ddl_clauseContext) IsDdl_clauseContext() {} + +func NewDdl_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ddl_clauseContext { + var p = new(Ddl_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_ddl_clause + + return p +} + +func (s *Ddl_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ddl_clauseContext) Alter_application_role() IAlter_application_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_application_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_application_roleContext) +} + +func (s *Ddl_clauseContext) Alter_assembly() IAlter_assemblyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assemblyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assemblyContext) +} + +func (s *Ddl_clauseContext) Alter_asymmetric_key() IAlter_asymmetric_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_asymmetric_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_asymmetric_keyContext) +} + +func (s *Ddl_clauseContext) Alter_authorization() IAlter_authorizationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_authorizationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_authorizationContext) +} + +func (s *Ddl_clauseContext) Alter_authorization_for_azure_dw() IAlter_authorization_for_azure_dwContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_authorization_for_azure_dwContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_authorization_for_azure_dwContext) +} + +func (s *Ddl_clauseContext) Alter_authorization_for_parallel_dw() IAlter_authorization_for_parallel_dwContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_authorization_for_parallel_dwContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_authorization_for_parallel_dwContext) +} + +func (s *Ddl_clauseContext) Alter_authorization_for_sql_database() IAlter_authorization_for_sql_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_authorization_for_sql_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_authorization_for_sql_databaseContext) +} + +func (s *Ddl_clauseContext) Alter_availability_group() IAlter_availability_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_availability_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_availability_groupContext) +} + +func (s *Ddl_clauseContext) Alter_certificate() IAlter_certificateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_certificateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_certificateContext) +} + +func (s *Ddl_clauseContext) Alter_column_encryption_key() IAlter_column_encryption_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_column_encryption_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_column_encryption_keyContext) +} + +func (s *Ddl_clauseContext) Alter_credential() IAlter_credentialContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_credentialContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_credentialContext) +} + +func (s *Ddl_clauseContext) Alter_cryptographic_provider() IAlter_cryptographic_providerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_cryptographic_providerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_cryptographic_providerContext) +} + +func (s *Ddl_clauseContext) Alter_database() IAlter_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_databaseContext) +} + +func (s *Ddl_clauseContext) Alter_database_audit_specification() IAlter_database_audit_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_database_audit_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_database_audit_specificationContext) +} + +func (s *Ddl_clauseContext) Alter_db_role() IAlter_db_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_db_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_db_roleContext) +} + +func (s *Ddl_clauseContext) Alter_endpoint() IAlter_endpointContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_endpointContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_endpointContext) +} + +func (s *Ddl_clauseContext) Alter_external_data_source() IAlter_external_data_sourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_external_data_sourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_external_data_sourceContext) +} + +func (s *Ddl_clauseContext) Alter_external_library() IAlter_external_libraryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_external_libraryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_external_libraryContext) +} + +func (s *Ddl_clauseContext) Alter_external_resource_pool() IAlter_external_resource_poolContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_external_resource_poolContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_external_resource_poolContext) +} + +func (s *Ddl_clauseContext) Alter_fulltext_catalog() IAlter_fulltext_catalogContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_fulltext_catalogContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_fulltext_catalogContext) +} + +func (s *Ddl_clauseContext) Alter_fulltext_stoplist() IAlter_fulltext_stoplistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_fulltext_stoplistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_fulltext_stoplistContext) +} + +func (s *Ddl_clauseContext) Alter_index() IAlter_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_indexContext) +} + +func (s *Ddl_clauseContext) Alter_login_azure_sql() IAlter_login_azure_sqlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_login_azure_sqlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_login_azure_sqlContext) +} + +func (s *Ddl_clauseContext) Alter_login_azure_sql_dw_and_pdw() IAlter_login_azure_sql_dw_and_pdwContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_login_azure_sql_dw_and_pdwContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_login_azure_sql_dw_and_pdwContext) +} + +func (s *Ddl_clauseContext) Alter_login_sql_server() IAlter_login_sql_serverContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_login_sql_serverContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_login_sql_serverContext) +} + +func (s *Ddl_clauseContext) Alter_master_key_azure_sql() IAlter_master_key_azure_sqlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_master_key_azure_sqlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_master_key_azure_sqlContext) +} + +func (s *Ddl_clauseContext) Alter_master_key_sql_server() IAlter_master_key_sql_serverContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_master_key_sql_serverContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_master_key_sql_serverContext) +} + +func (s *Ddl_clauseContext) Alter_message_type() IAlter_message_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_message_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_message_typeContext) +} + +func (s *Ddl_clauseContext) Alter_partition_function() IAlter_partition_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_partition_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_partition_functionContext) +} + +func (s *Ddl_clauseContext) Alter_partition_scheme() IAlter_partition_schemeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_partition_schemeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_partition_schemeContext) +} + +func (s *Ddl_clauseContext) Alter_remote_service_binding() IAlter_remote_service_bindingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_remote_service_bindingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_remote_service_bindingContext) +} + +func (s *Ddl_clauseContext) Alter_resource_governor() IAlter_resource_governorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_resource_governorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_resource_governorContext) +} + +func (s *Ddl_clauseContext) Alter_schema_azure_sql_dw_and_pdw() IAlter_schema_azure_sql_dw_and_pdwContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_schema_azure_sql_dw_and_pdwContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_schema_azure_sql_dw_and_pdwContext) +} + +func (s *Ddl_clauseContext) Alter_schema_sql() IAlter_schema_sqlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_schema_sqlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_schema_sqlContext) +} + +func (s *Ddl_clauseContext) Alter_sequence() IAlter_sequenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_sequenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_sequenceContext) +} + +func (s *Ddl_clauseContext) Alter_server_audit() IAlter_server_auditContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_server_auditContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_server_auditContext) +} + +func (s *Ddl_clauseContext) Alter_server_audit_specification() IAlter_server_audit_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_server_audit_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_server_audit_specificationContext) +} + +func (s *Ddl_clauseContext) Alter_server_configuration() IAlter_server_configurationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_server_configurationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_server_configurationContext) +} + +func (s *Ddl_clauseContext) Alter_server_role() IAlter_server_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_server_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_server_roleContext) +} + +func (s *Ddl_clauseContext) Alter_server_role_pdw() IAlter_server_role_pdwContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_server_role_pdwContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_server_role_pdwContext) +} + +func (s *Ddl_clauseContext) Alter_service() IAlter_serviceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_serviceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_serviceContext) +} + +func (s *Ddl_clauseContext) Alter_service_master_key() IAlter_service_master_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_service_master_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_service_master_keyContext) +} + +func (s *Ddl_clauseContext) Alter_symmetric_key() IAlter_symmetric_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_symmetric_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_symmetric_keyContext) +} + +func (s *Ddl_clauseContext) Alter_table() IAlter_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tableContext) +} + +func (s *Ddl_clauseContext) Alter_user() IAlter_userContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_userContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_userContext) +} + +func (s *Ddl_clauseContext) Alter_user_azure_sql() IAlter_user_azure_sqlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_user_azure_sqlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_user_azure_sqlContext) +} + +func (s *Ddl_clauseContext) Alter_workload_group() IAlter_workload_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_workload_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_workload_groupContext) +} + +func (s *Ddl_clauseContext) Alter_xml_schema_collection() IAlter_xml_schema_collectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_xml_schema_collectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_xml_schema_collectionContext) +} + +func (s *Ddl_clauseContext) Create_application_role() ICreate_application_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_application_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_application_roleContext) +} + +func (s *Ddl_clauseContext) Create_assembly() ICreate_assemblyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_assemblyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_assemblyContext) +} + +func (s *Ddl_clauseContext) Create_asymmetric_key() ICreate_asymmetric_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_asymmetric_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_asymmetric_keyContext) +} + +func (s *Ddl_clauseContext) Create_column_encryption_key() ICreate_column_encryption_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_column_encryption_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_column_encryption_keyContext) +} + +func (s *Ddl_clauseContext) Create_column_master_key() ICreate_column_master_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_column_master_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_column_master_keyContext) +} + +func (s *Ddl_clauseContext) Create_columnstore_index() ICreate_columnstore_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_columnstore_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_columnstore_indexContext) +} + +func (s *Ddl_clauseContext) Create_credential() ICreate_credentialContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_credentialContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_credentialContext) +} + +func (s *Ddl_clauseContext) Create_cryptographic_provider() ICreate_cryptographic_providerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_cryptographic_providerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_cryptographic_providerContext) +} + +func (s *Ddl_clauseContext) Create_database() ICreate_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_databaseContext) +} + +func (s *Ddl_clauseContext) Create_database_audit_specification() ICreate_database_audit_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_database_audit_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_database_audit_specificationContext) +} + +func (s *Ddl_clauseContext) Create_db_role() ICreate_db_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_db_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_db_roleContext) +} + +func (s *Ddl_clauseContext) Create_endpoint() ICreate_endpointContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_endpointContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_endpointContext) +} + +func (s *Ddl_clauseContext) Create_event_notification() ICreate_event_notificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_event_notificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_event_notificationContext) +} + +func (s *Ddl_clauseContext) Create_external_library() ICreate_external_libraryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_external_libraryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_external_libraryContext) +} + +func (s *Ddl_clauseContext) Create_external_resource_pool() ICreate_external_resource_poolContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_external_resource_poolContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_external_resource_poolContext) +} + +func (s *Ddl_clauseContext) Create_fulltext_catalog() ICreate_fulltext_catalogContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_fulltext_catalogContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_fulltext_catalogContext) +} + +func (s *Ddl_clauseContext) Create_fulltext_stoplist() ICreate_fulltext_stoplistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_fulltext_stoplistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_fulltext_stoplistContext) +} + +func (s *Ddl_clauseContext) Create_index() ICreate_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_indexContext) +} + +func (s *Ddl_clauseContext) Create_login_azure_sql() ICreate_login_azure_sqlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_login_azure_sqlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_login_azure_sqlContext) +} + +func (s *Ddl_clauseContext) Create_login_pdw() ICreate_login_pdwContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_login_pdwContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_login_pdwContext) +} + +func (s *Ddl_clauseContext) Create_login_sql_server() ICreate_login_sql_serverContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_login_sql_serverContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_login_sql_serverContext) +} + +func (s *Ddl_clauseContext) Create_master_key_azure_sql() ICreate_master_key_azure_sqlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_master_key_azure_sqlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_master_key_azure_sqlContext) +} + +func (s *Ddl_clauseContext) Create_master_key_sql_server() ICreate_master_key_sql_serverContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_master_key_sql_serverContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_master_key_sql_serverContext) +} + +func (s *Ddl_clauseContext) Create_nonclustered_columnstore_index() ICreate_nonclustered_columnstore_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_nonclustered_columnstore_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_nonclustered_columnstore_indexContext) +} + +func (s *Ddl_clauseContext) Create_or_alter_broker_priority() ICreate_or_alter_broker_priorityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_or_alter_broker_priorityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_or_alter_broker_priorityContext) +} + +func (s *Ddl_clauseContext) Create_or_alter_event_session() ICreate_or_alter_event_sessionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_or_alter_event_sessionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_or_alter_event_sessionContext) +} + +func (s *Ddl_clauseContext) Create_partition_function() ICreate_partition_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_partition_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_partition_functionContext) +} + +func (s *Ddl_clauseContext) Create_partition_scheme() ICreate_partition_schemeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_partition_schemeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_partition_schemeContext) +} + +func (s *Ddl_clauseContext) Create_remote_service_binding() ICreate_remote_service_bindingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_remote_service_bindingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_remote_service_bindingContext) +} + +func (s *Ddl_clauseContext) Create_resource_pool() ICreate_resource_poolContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_resource_poolContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_resource_poolContext) +} + +func (s *Ddl_clauseContext) Create_route() ICreate_routeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_routeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_routeContext) +} + +func (s *Ddl_clauseContext) Create_rule() ICreate_ruleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_ruleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_ruleContext) +} + +func (s *Ddl_clauseContext) Create_schema() ICreate_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_schemaContext) +} + +func (s *Ddl_clauseContext) Create_schema_azure_sql_dw_and_pdw() ICreate_schema_azure_sql_dw_and_pdwContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_schema_azure_sql_dw_and_pdwContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_schema_azure_sql_dw_and_pdwContext) +} + +func (s *Ddl_clauseContext) Create_spatial_index() ICreate_spatial_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_spatial_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_spatial_indexContext) +} + +func (s *Ddl_clauseContext) Create_search_property_list() ICreate_search_property_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_search_property_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_search_property_listContext) +} + +func (s *Ddl_clauseContext) Create_security_policy() ICreate_security_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_security_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_security_policyContext) +} + +func (s *Ddl_clauseContext) Create_sequence() ICreate_sequenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_sequenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_sequenceContext) +} + +func (s *Ddl_clauseContext) Create_server_audit() ICreate_server_auditContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_server_auditContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_server_auditContext) +} + +func (s *Ddl_clauseContext) Create_server_audit_specification() ICreate_server_audit_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_server_audit_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_server_audit_specificationContext) +} + +func (s *Ddl_clauseContext) Create_server_role() ICreate_server_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_server_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_server_roleContext) +} + +func (s *Ddl_clauseContext) Create_service() ICreate_serviceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_serviceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_serviceContext) +} + +func (s *Ddl_clauseContext) Create_statistics() ICreate_statisticsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_statisticsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_statisticsContext) +} + +func (s *Ddl_clauseContext) Create_synonym() ICreate_synonymContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_synonymContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_synonymContext) +} + +func (s *Ddl_clauseContext) Create_table() ICreate_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_tableContext) +} + +func (s *Ddl_clauseContext) Create_type() ICreate_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_typeContext) +} + +func (s *Ddl_clauseContext) Create_user() ICreate_userContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_userContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_userContext) +} + +func (s *Ddl_clauseContext) Create_user_azure_sql_dw() ICreate_user_azure_sql_dwContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_user_azure_sql_dwContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_user_azure_sql_dwContext) +} + +func (s *Ddl_clauseContext) Create_workload_group() ICreate_workload_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_workload_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_workload_groupContext) +} + +func (s *Ddl_clauseContext) Create_xml_index() ICreate_xml_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_xml_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_xml_indexContext) +} + +func (s *Ddl_clauseContext) Create_xml_schema_collection() ICreate_xml_schema_collectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_xml_schema_collectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_xml_schema_collectionContext) +} + +func (s *Ddl_clauseContext) Disable_trigger() IDisable_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisable_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisable_triggerContext) +} + +func (s *Ddl_clauseContext) Drop_aggregate() IDrop_aggregateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_aggregateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_aggregateContext) +} + +func (s *Ddl_clauseContext) Drop_application_role() IDrop_application_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_application_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_application_roleContext) +} + +func (s *Ddl_clauseContext) Drop_assembly() IDrop_assemblyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_assemblyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_assemblyContext) +} + +func (s *Ddl_clauseContext) Drop_asymmetric_key() IDrop_asymmetric_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_asymmetric_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_asymmetric_keyContext) +} + +func (s *Ddl_clauseContext) Drop_availability_group() IDrop_availability_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_availability_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_availability_groupContext) +} + +func (s *Ddl_clauseContext) Drop_broker_priority() IDrop_broker_priorityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_broker_priorityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_broker_priorityContext) +} + +func (s *Ddl_clauseContext) Drop_certificate() IDrop_certificateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_certificateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_certificateContext) +} + +func (s *Ddl_clauseContext) Drop_column_encryption_key() IDrop_column_encryption_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_column_encryption_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_column_encryption_keyContext) +} + +func (s *Ddl_clauseContext) Drop_column_master_key() IDrop_column_master_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_column_master_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_column_master_keyContext) +} + +func (s *Ddl_clauseContext) Drop_contract() IDrop_contractContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_contractContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_contractContext) +} + +func (s *Ddl_clauseContext) Drop_credential() IDrop_credentialContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_credentialContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_credentialContext) +} + +func (s *Ddl_clauseContext) Drop_cryptograhic_provider() IDrop_cryptograhic_providerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_cryptograhic_providerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_cryptograhic_providerContext) +} + +func (s *Ddl_clauseContext) Drop_database() IDrop_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_databaseContext) +} + +func (s *Ddl_clauseContext) Drop_database_audit_specification() IDrop_database_audit_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_database_audit_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_database_audit_specificationContext) +} + +func (s *Ddl_clauseContext) Drop_database_encryption_key() IDrop_database_encryption_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_database_encryption_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_database_encryption_keyContext) +} + +func (s *Ddl_clauseContext) Drop_database_scoped_credential() IDrop_database_scoped_credentialContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_database_scoped_credentialContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_database_scoped_credentialContext) +} + +func (s *Ddl_clauseContext) Drop_db_role() IDrop_db_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_db_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_db_roleContext) +} + +func (s *Ddl_clauseContext) Drop_default() IDrop_defaultContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_defaultContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_defaultContext) +} + +func (s *Ddl_clauseContext) Drop_endpoint() IDrop_endpointContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_endpointContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_endpointContext) +} + +func (s *Ddl_clauseContext) Drop_event_notifications() IDrop_event_notificationsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_event_notificationsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_event_notificationsContext) +} + +func (s *Ddl_clauseContext) Drop_event_session() IDrop_event_sessionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_event_sessionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_event_sessionContext) +} + +func (s *Ddl_clauseContext) Drop_external_data_source() IDrop_external_data_sourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_external_data_sourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_external_data_sourceContext) +} + +func (s *Ddl_clauseContext) Drop_external_file_format() IDrop_external_file_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_external_file_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_external_file_formatContext) +} + +func (s *Ddl_clauseContext) Drop_external_library() IDrop_external_libraryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_external_libraryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_external_libraryContext) +} + +func (s *Ddl_clauseContext) Drop_external_resource_pool() IDrop_external_resource_poolContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_external_resource_poolContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_external_resource_poolContext) +} + +func (s *Ddl_clauseContext) Drop_external_table() IDrop_external_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_external_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_external_tableContext) +} + +func (s *Ddl_clauseContext) Drop_fulltext_catalog() IDrop_fulltext_catalogContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_fulltext_catalogContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_fulltext_catalogContext) +} + +func (s *Ddl_clauseContext) Drop_fulltext_index() IDrop_fulltext_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_fulltext_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_fulltext_indexContext) +} + +func (s *Ddl_clauseContext) Drop_fulltext_stoplist() IDrop_fulltext_stoplistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_fulltext_stoplistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_fulltext_stoplistContext) +} + +func (s *Ddl_clauseContext) Drop_function() IDrop_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_functionContext) +} + +func (s *Ddl_clauseContext) Drop_index() IDrop_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_indexContext) +} + +func (s *Ddl_clauseContext) Drop_login() IDrop_loginContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_loginContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_loginContext) +} + +func (s *Ddl_clauseContext) Drop_master_key() IDrop_master_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_master_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_master_keyContext) +} + +func (s *Ddl_clauseContext) Drop_message_type() IDrop_message_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_message_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_message_typeContext) +} + +func (s *Ddl_clauseContext) Drop_partition_function() IDrop_partition_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_partition_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_partition_functionContext) +} + +func (s *Ddl_clauseContext) Drop_partition_scheme() IDrop_partition_schemeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_partition_schemeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_partition_schemeContext) +} + +func (s *Ddl_clauseContext) Drop_procedure() IDrop_procedureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_procedureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_procedureContext) +} + +func (s *Ddl_clauseContext) Drop_queue() IDrop_queueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_queueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_queueContext) +} + +func (s *Ddl_clauseContext) Drop_remote_service_binding() IDrop_remote_service_bindingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_remote_service_bindingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_remote_service_bindingContext) +} + +func (s *Ddl_clauseContext) Drop_resource_pool() IDrop_resource_poolContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_resource_poolContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_resource_poolContext) +} + +func (s *Ddl_clauseContext) Drop_route() IDrop_routeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_routeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_routeContext) +} + +func (s *Ddl_clauseContext) Drop_rule() IDrop_ruleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_ruleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_ruleContext) +} + +func (s *Ddl_clauseContext) Drop_schema() IDrop_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_schemaContext) +} + +func (s *Ddl_clauseContext) Drop_search_property_list() IDrop_search_property_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_search_property_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_search_property_listContext) +} + +func (s *Ddl_clauseContext) Drop_security_policy() IDrop_security_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_security_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_security_policyContext) +} + +func (s *Ddl_clauseContext) Drop_sequence() IDrop_sequenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_sequenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_sequenceContext) +} + +func (s *Ddl_clauseContext) Drop_server_audit() IDrop_server_auditContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_server_auditContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_server_auditContext) +} + +func (s *Ddl_clauseContext) Drop_server_audit_specification() IDrop_server_audit_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_server_audit_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_server_audit_specificationContext) +} + +func (s *Ddl_clauseContext) Drop_server_role() IDrop_server_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_server_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_server_roleContext) +} + +func (s *Ddl_clauseContext) Drop_service() IDrop_serviceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_serviceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_serviceContext) +} + +func (s *Ddl_clauseContext) Drop_signature() IDrop_signatureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_signatureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_signatureContext) +} + +func (s *Ddl_clauseContext) Drop_statistics() IDrop_statisticsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_statisticsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_statisticsContext) +} + +func (s *Ddl_clauseContext) Drop_statistics_name_azure_dw_and_pdw() IDrop_statistics_name_azure_dw_and_pdwContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_statistics_name_azure_dw_and_pdwContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_statistics_name_azure_dw_and_pdwContext) +} + +func (s *Ddl_clauseContext) Drop_symmetric_key() IDrop_symmetric_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_symmetric_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_symmetric_keyContext) +} + +func (s *Ddl_clauseContext) Drop_synonym() IDrop_synonymContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_synonymContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_synonymContext) +} + +func (s *Ddl_clauseContext) Drop_table() IDrop_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_tableContext) +} + +func (s *Ddl_clauseContext) Drop_trigger() IDrop_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_triggerContext) +} + +func (s *Ddl_clauseContext) Drop_type() IDrop_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_typeContext) +} + +func (s *Ddl_clauseContext) Drop_user() IDrop_userContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_userContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_userContext) +} + +func (s *Ddl_clauseContext) Drop_view() IDrop_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_viewContext) +} + +func (s *Ddl_clauseContext) Drop_workload_group() IDrop_workload_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_workload_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_workload_groupContext) +} + +func (s *Ddl_clauseContext) Drop_xml_schema_collection() IDrop_xml_schema_collectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_xml_schema_collectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_xml_schema_collectionContext) +} + +func (s *Ddl_clauseContext) Enable_trigger() IEnable_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnable_triggerContext) +} + +func (s *Ddl_clauseContext) Lock_table() ILock_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILock_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILock_tableContext) +} + +func (s *Ddl_clauseContext) Truncate_table() ITruncate_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITruncate_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITruncate_tableContext) +} + +func (s *Ddl_clauseContext) Update_statistics() IUpdate_statisticsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_statisticsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_statisticsContext) +} + +func (s *Ddl_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ddl_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ddl_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDdl_clause(s) + } +} + +func (s *Ddl_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDdl_clause(s) + } +} + +func (s *Ddl_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDdl_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Ddl_clause() (localctx IDdl_clauseContext) { + localctx = NewDdl_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 10, TSqlParserRULE_ddl_clause) + p.SetState(1487) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 17, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1321) + p.Alter_application_role() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1322) + p.Alter_assembly() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1323) + p.Alter_asymmetric_key() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1324) + p.Alter_authorization() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1325) + p.Alter_authorization_for_azure_dw() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1326) + p.Alter_authorization_for_parallel_dw() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1327) + p.Alter_authorization_for_sql_database() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1328) + p.Alter_availability_group() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1329) + p.Alter_certificate() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(1330) + p.Alter_column_encryption_key() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(1331) + p.Alter_credential() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(1332) + p.Alter_cryptographic_provider() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(1333) + p.Alter_database() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(1334) + p.Alter_database_audit_specification() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(1335) + p.Alter_db_role() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(1336) + p.Alter_endpoint() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(1337) + p.Alter_external_data_source() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(1338) + p.Alter_external_library() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(1339) + p.Alter_external_resource_pool() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(1340) + p.Alter_fulltext_catalog() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(1341) + p.Alter_fulltext_stoplist() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(1342) + p.Alter_index() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(1343) + p.Alter_login_azure_sql() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(1344) + p.Alter_login_azure_sql_dw_and_pdw() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(1345) + p.Alter_login_sql_server() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(1346) + p.Alter_master_key_azure_sql() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(1347) + p.Alter_master_key_sql_server() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(1348) + p.Alter_message_type() + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(1349) + p.Alter_partition_function() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(1350) + p.Alter_partition_scheme() + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(1351) + p.Alter_remote_service_binding() + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(1352) + p.Alter_resource_governor() + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(1353) + p.Alter_schema_azure_sql_dw_and_pdw() + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(1354) + p.Alter_schema_sql() + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(1355) + p.Alter_sequence() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(1356) + p.Alter_server_audit() + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(1357) + p.Alter_server_audit_specification() + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(1358) + p.Alter_server_configuration() + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(1359) + p.Alter_server_role() + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(1360) + p.Alter_server_role_pdw() + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(1361) + p.Alter_service() + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(1362) + p.Alter_service_master_key() + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(1363) + p.Alter_symmetric_key() + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(1364) + p.Alter_table() + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(1365) + p.Alter_user() + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(1366) + p.Alter_user_azure_sql() + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(1367) + p.Alter_workload_group() + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(1368) + p.Alter_xml_schema_collection() + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(1369) + p.Create_application_role() + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(1370) + p.Create_assembly() + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(1371) + p.Create_asymmetric_key() + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(1372) + p.Create_column_encryption_key() + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(1373) + p.Create_column_master_key() + } + + case 54: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(1374) + p.Create_columnstore_index() + } + + case 55: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(1375) + p.Create_credential() + } + + case 56: + p.EnterOuterAlt(localctx, 56) + { + p.SetState(1376) + p.Create_cryptographic_provider() + } + + case 57: + p.EnterOuterAlt(localctx, 57) + { + p.SetState(1377) + p.Create_database() + } + + case 58: + p.EnterOuterAlt(localctx, 58) + { + p.SetState(1378) + p.Create_database_audit_specification() + } + + case 59: + p.EnterOuterAlt(localctx, 59) + { + p.SetState(1379) + p.Create_db_role() + } + + case 60: + p.EnterOuterAlt(localctx, 60) + { + p.SetState(1380) + p.Create_endpoint() + } + + case 61: + p.EnterOuterAlt(localctx, 61) + { + p.SetState(1381) + p.Create_event_notification() + } + + case 62: + p.EnterOuterAlt(localctx, 62) + { + p.SetState(1382) + p.Create_external_library() + } + + case 63: + p.EnterOuterAlt(localctx, 63) + { + p.SetState(1383) + p.Create_external_resource_pool() + } + + case 64: + p.EnterOuterAlt(localctx, 64) + { + p.SetState(1384) + p.Create_fulltext_catalog() + } + + case 65: + p.EnterOuterAlt(localctx, 65) + { + p.SetState(1385) + p.Create_fulltext_stoplist() + } + + case 66: + p.EnterOuterAlt(localctx, 66) + { + p.SetState(1386) + p.Create_index() + } + + case 67: + p.EnterOuterAlt(localctx, 67) + { + p.SetState(1387) + p.Create_login_azure_sql() + } + + case 68: + p.EnterOuterAlt(localctx, 68) + { + p.SetState(1388) + p.Create_login_pdw() + } + + case 69: + p.EnterOuterAlt(localctx, 69) + { + p.SetState(1389) + p.Create_login_sql_server() + } + + case 70: + p.EnterOuterAlt(localctx, 70) + { + p.SetState(1390) + p.Create_master_key_azure_sql() + } + + case 71: + p.EnterOuterAlt(localctx, 71) + { + p.SetState(1391) + p.Create_master_key_sql_server() + } + + case 72: + p.EnterOuterAlt(localctx, 72) + { + p.SetState(1392) + p.Create_nonclustered_columnstore_index() + } + + case 73: + p.EnterOuterAlt(localctx, 73) + { + p.SetState(1393) + p.Create_or_alter_broker_priority() + } + + case 74: + p.EnterOuterAlt(localctx, 74) + { + p.SetState(1394) + p.Create_or_alter_event_session() + } + + case 75: + p.EnterOuterAlt(localctx, 75) + { + p.SetState(1395) + p.Create_partition_function() + } + + case 76: + p.EnterOuterAlt(localctx, 76) + { + p.SetState(1396) + p.Create_partition_scheme() + } + + case 77: + p.EnterOuterAlt(localctx, 77) + { + p.SetState(1397) + p.Create_remote_service_binding() + } + + case 78: + p.EnterOuterAlt(localctx, 78) + { + p.SetState(1398) + p.Create_resource_pool() + } + + case 79: + p.EnterOuterAlt(localctx, 79) + { + p.SetState(1399) + p.Create_route() + } + + case 80: + p.EnterOuterAlt(localctx, 80) + { + p.SetState(1400) + p.Create_rule() + } + + case 81: + p.EnterOuterAlt(localctx, 81) + { + p.SetState(1401) + p.Create_schema() + } + + case 82: + p.EnterOuterAlt(localctx, 82) + { + p.SetState(1402) + p.Create_schema_azure_sql_dw_and_pdw() + } + + case 83: + p.EnterOuterAlt(localctx, 83) + { + p.SetState(1403) + p.Create_spatial_index() + } + + case 84: + p.EnterOuterAlt(localctx, 84) + { + p.SetState(1404) + p.Create_search_property_list() + } + + case 85: + p.EnterOuterAlt(localctx, 85) + { + p.SetState(1405) + p.Create_security_policy() + } + + case 86: + p.EnterOuterAlt(localctx, 86) + { + p.SetState(1406) + p.Create_sequence() + } + + case 87: + p.EnterOuterAlt(localctx, 87) + { + p.SetState(1407) + p.Create_server_audit() + } + + case 88: + p.EnterOuterAlt(localctx, 88) + { + p.SetState(1408) + p.Create_server_audit_specification() + } + + case 89: + p.EnterOuterAlt(localctx, 89) + { + p.SetState(1409) + p.Create_server_role() + } + + case 90: + p.EnterOuterAlt(localctx, 90) + { + p.SetState(1410) + p.Create_service() + } + + case 91: + p.EnterOuterAlt(localctx, 91) + { + p.SetState(1411) + p.Create_statistics() + } + + case 92: + p.EnterOuterAlt(localctx, 92) + { + p.SetState(1412) + p.Create_synonym() + } + + case 93: + p.EnterOuterAlt(localctx, 93) + { + p.SetState(1413) + p.Create_table() + } + + case 94: + p.EnterOuterAlt(localctx, 94) + { + p.SetState(1414) + p.Create_type() + } + + case 95: + p.EnterOuterAlt(localctx, 95) + { + p.SetState(1415) + p.Create_user() + } + + case 96: + p.EnterOuterAlt(localctx, 96) + { + p.SetState(1416) + p.Create_user_azure_sql_dw() + } + + case 97: + p.EnterOuterAlt(localctx, 97) + { + p.SetState(1417) + p.Create_workload_group() + } + + case 98: + p.EnterOuterAlt(localctx, 98) + { + p.SetState(1418) + p.Create_xml_index() + } + + case 99: + p.EnterOuterAlt(localctx, 99) + { + p.SetState(1419) + p.Create_xml_schema_collection() + } + + case 100: + p.EnterOuterAlt(localctx, 100) + { + p.SetState(1420) + p.Disable_trigger() + } + + case 101: + p.EnterOuterAlt(localctx, 101) + { + p.SetState(1421) + p.Drop_aggregate() + } + + case 102: + p.EnterOuterAlt(localctx, 102) + { + p.SetState(1422) + p.Drop_application_role() + } + + case 103: + p.EnterOuterAlt(localctx, 103) + { + p.SetState(1423) + p.Drop_assembly() + } + + case 104: + p.EnterOuterAlt(localctx, 104) + { + p.SetState(1424) + p.Drop_asymmetric_key() + } + + case 105: + p.EnterOuterAlt(localctx, 105) + { + p.SetState(1425) + p.Drop_availability_group() + } + + case 106: + p.EnterOuterAlt(localctx, 106) + { + p.SetState(1426) + p.Drop_broker_priority() + } + + case 107: + p.EnterOuterAlt(localctx, 107) + { + p.SetState(1427) + p.Drop_certificate() + } + + case 108: + p.EnterOuterAlt(localctx, 108) + { + p.SetState(1428) + p.Drop_column_encryption_key() + } + + case 109: + p.EnterOuterAlt(localctx, 109) + { + p.SetState(1429) + p.Drop_column_master_key() + } + + case 110: + p.EnterOuterAlt(localctx, 110) + { + p.SetState(1430) + p.Drop_contract() + } + + case 111: + p.EnterOuterAlt(localctx, 111) + { + p.SetState(1431) + p.Drop_credential() + } + + case 112: + p.EnterOuterAlt(localctx, 112) + { + p.SetState(1432) + p.Drop_cryptograhic_provider() + } + + case 113: + p.EnterOuterAlt(localctx, 113) + { + p.SetState(1433) + p.Drop_database() + } + + case 114: + p.EnterOuterAlt(localctx, 114) + { + p.SetState(1434) + p.Drop_database_audit_specification() + } + + case 115: + p.EnterOuterAlt(localctx, 115) + { + p.SetState(1435) + p.Drop_database_encryption_key() + } + + case 116: + p.EnterOuterAlt(localctx, 116) + { + p.SetState(1436) + p.Drop_database_scoped_credential() + } + + case 117: + p.EnterOuterAlt(localctx, 117) + { + p.SetState(1437) + p.Drop_db_role() + } + + case 118: + p.EnterOuterAlt(localctx, 118) + { + p.SetState(1438) + p.Drop_default() + } + + case 119: + p.EnterOuterAlt(localctx, 119) + { + p.SetState(1439) + p.Drop_endpoint() + } + + case 120: + p.EnterOuterAlt(localctx, 120) + { + p.SetState(1440) + p.Drop_event_notifications() + } + + case 121: + p.EnterOuterAlt(localctx, 121) + { + p.SetState(1441) + p.Drop_event_session() + } + + case 122: + p.EnterOuterAlt(localctx, 122) + { + p.SetState(1442) + p.Drop_external_data_source() + } + + case 123: + p.EnterOuterAlt(localctx, 123) + { + p.SetState(1443) + p.Drop_external_file_format() + } + + case 124: + p.EnterOuterAlt(localctx, 124) + { + p.SetState(1444) + p.Drop_external_library() + } + + case 125: + p.EnterOuterAlt(localctx, 125) + { + p.SetState(1445) + p.Drop_external_resource_pool() + } + + case 126: + p.EnterOuterAlt(localctx, 126) + { + p.SetState(1446) + p.Drop_external_table() + } + + case 127: + p.EnterOuterAlt(localctx, 127) + { + p.SetState(1447) + p.Drop_fulltext_catalog() + } + + case 128: + p.EnterOuterAlt(localctx, 128) + { + p.SetState(1448) + p.Drop_fulltext_index() + } + + case 129: + p.EnterOuterAlt(localctx, 129) + { + p.SetState(1449) + p.Drop_fulltext_stoplist() + } + + case 130: + p.EnterOuterAlt(localctx, 130) + { + p.SetState(1450) + p.Drop_function() + } + + case 131: + p.EnterOuterAlt(localctx, 131) + { + p.SetState(1451) + p.Drop_index() + } + + case 132: + p.EnterOuterAlt(localctx, 132) + { + p.SetState(1452) + p.Drop_login() + } + + case 133: + p.EnterOuterAlt(localctx, 133) + { + p.SetState(1453) + p.Drop_master_key() + } + + case 134: + p.EnterOuterAlt(localctx, 134) + { + p.SetState(1454) + p.Drop_message_type() + } + + case 135: + p.EnterOuterAlt(localctx, 135) + { + p.SetState(1455) + p.Drop_partition_function() + } + + case 136: + p.EnterOuterAlt(localctx, 136) + { + p.SetState(1456) + p.Drop_partition_scheme() + } + + case 137: + p.EnterOuterAlt(localctx, 137) + { + p.SetState(1457) + p.Drop_procedure() + } + + case 138: + p.EnterOuterAlt(localctx, 138) + { + p.SetState(1458) + p.Drop_queue() + } + + case 139: + p.EnterOuterAlt(localctx, 139) + { + p.SetState(1459) + p.Drop_remote_service_binding() + } + + case 140: + p.EnterOuterAlt(localctx, 140) + { + p.SetState(1460) + p.Drop_resource_pool() + } + + case 141: + p.EnterOuterAlt(localctx, 141) + { + p.SetState(1461) + p.Drop_route() + } + + case 142: + p.EnterOuterAlt(localctx, 142) + { + p.SetState(1462) + p.Drop_rule() + } + + case 143: + p.EnterOuterAlt(localctx, 143) + { + p.SetState(1463) + p.Drop_schema() + } + + case 144: + p.EnterOuterAlt(localctx, 144) + { + p.SetState(1464) + p.Drop_search_property_list() + } + + case 145: + p.EnterOuterAlt(localctx, 145) + { + p.SetState(1465) + p.Drop_security_policy() + } + + case 146: + p.EnterOuterAlt(localctx, 146) + { + p.SetState(1466) + p.Drop_sequence() + } + + case 147: + p.EnterOuterAlt(localctx, 147) + { + p.SetState(1467) + p.Drop_server_audit() + } + + case 148: + p.EnterOuterAlt(localctx, 148) + { + p.SetState(1468) + p.Drop_server_audit_specification() + } + + case 149: + p.EnterOuterAlt(localctx, 149) + { + p.SetState(1469) + p.Drop_server_role() + } + + case 150: + p.EnterOuterAlt(localctx, 150) + { + p.SetState(1470) + p.Drop_service() + } + + case 151: + p.EnterOuterAlt(localctx, 151) + { + p.SetState(1471) + p.Drop_signature() + } + + case 152: + p.EnterOuterAlt(localctx, 152) + { + p.SetState(1472) + p.Drop_statistics() + } + + case 153: + p.EnterOuterAlt(localctx, 153) + { + p.SetState(1473) + p.Drop_statistics_name_azure_dw_and_pdw() + } + + case 154: + p.EnterOuterAlt(localctx, 154) + { + p.SetState(1474) + p.Drop_symmetric_key() + } + + case 155: + p.EnterOuterAlt(localctx, 155) + { + p.SetState(1475) + p.Drop_synonym() + } + + case 156: + p.EnterOuterAlt(localctx, 156) + { + p.SetState(1476) + p.Drop_table() + } + + case 157: + p.EnterOuterAlt(localctx, 157) + { + p.SetState(1477) + p.Drop_trigger() + } + + case 158: + p.EnterOuterAlt(localctx, 158) + { + p.SetState(1478) + p.Drop_type() + } + + case 159: + p.EnterOuterAlt(localctx, 159) + { + p.SetState(1479) + p.Drop_user() + } + + case 160: + p.EnterOuterAlt(localctx, 160) + { + p.SetState(1480) + p.Drop_view() + } + + case 161: + p.EnterOuterAlt(localctx, 161) + { + p.SetState(1481) + p.Drop_workload_group() + } + + case 162: + p.EnterOuterAlt(localctx, 162) + { + p.SetState(1482) + p.Drop_xml_schema_collection() + } + + case 163: + p.EnterOuterAlt(localctx, 163) + { + p.SetState(1483) + p.Enable_trigger() + } + + case 164: + p.EnterOuterAlt(localctx, 164) + { + p.SetState(1484) + p.Lock_table() + } + + case 165: + p.EnterOuterAlt(localctx, 165) + { + p.SetState(1485) + p.Truncate_table() + } + + case 166: + p.EnterOuterAlt(localctx, 166) + { + p.SetState(1486) + p.Update_statistics() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBackup_statementContext is an interface to support dynamic dispatch. +type IBackup_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Backup_database() IBackup_databaseContext + Backup_log() IBackup_logContext + Backup_certificate() IBackup_certificateContext + Backup_master_key() IBackup_master_keyContext + Backup_service_master_key() IBackup_service_master_keyContext + + // IsBackup_statementContext differentiates from other interfaces. + IsBackup_statementContext() +} + +type Backup_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBackup_statementContext() *Backup_statementContext { + var p = new(Backup_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_backup_statement + return p +} + +func InitEmptyBackup_statementContext(p *Backup_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_backup_statement +} + +func (*Backup_statementContext) IsBackup_statementContext() {} + +func NewBackup_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_statementContext { + var p = new(Backup_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_backup_statement + + return p +} + +func (s *Backup_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Backup_statementContext) Backup_database() IBackup_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBackup_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBackup_databaseContext) +} + +func (s *Backup_statementContext) Backup_log() IBackup_logContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBackup_logContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBackup_logContext) +} + +func (s *Backup_statementContext) Backup_certificate() IBackup_certificateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBackup_certificateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBackup_certificateContext) +} + +func (s *Backup_statementContext) Backup_master_key() IBackup_master_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBackup_master_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBackup_master_keyContext) +} + +func (s *Backup_statementContext) Backup_service_master_key() IBackup_service_master_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBackup_service_master_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBackup_service_master_keyContext) +} + +func (s *Backup_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Backup_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Backup_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBackup_statement(s) + } +} + +func (s *Backup_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBackup_statement(s) + } +} + +func (s *Backup_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBackup_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Backup_statement() (localctx IBackup_statementContext) { + localctx = NewBackup_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 12, TSqlParserRULE_backup_statement) + p.SetState(1494) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 18, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1489) + p.Backup_database() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1490) + p.Backup_log() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1491) + p.Backup_certificate() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1492) + p.Backup_master_key() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1493) + p.Backup_service_master_key() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICfl_statementContext is an interface to support dynamic dispatch. +type ICfl_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Block_statement() IBlock_statementContext + Break_statement() IBreak_statementContext + Continue_statement() IContinue_statementContext + Goto_statement() IGoto_statementContext + If_statement() IIf_statementContext + Print_statement() IPrint_statementContext + Raiseerror_statement() IRaiseerror_statementContext + Return_statement() IReturn_statementContext + Throw_statement() IThrow_statementContext + Try_catch_statement() ITry_catch_statementContext + Waitfor_statement() IWaitfor_statementContext + While_statement() IWhile_statementContext + + // IsCfl_statementContext differentiates from other interfaces. + IsCfl_statementContext() +} + +type Cfl_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCfl_statementContext() *Cfl_statementContext { + var p = new(Cfl_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_cfl_statement + return p +} + +func InitEmptyCfl_statementContext(p *Cfl_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_cfl_statement +} + +func (*Cfl_statementContext) IsCfl_statementContext() {} + +func NewCfl_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cfl_statementContext { + var p = new(Cfl_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_cfl_statement + + return p +} + +func (s *Cfl_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cfl_statementContext) Block_statement() IBlock_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlock_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlock_statementContext) +} + +func (s *Cfl_statementContext) Break_statement() IBreak_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBreak_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBreak_statementContext) +} + +func (s *Cfl_statementContext) Continue_statement() IContinue_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContinue_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContinue_statementContext) +} + +func (s *Cfl_statementContext) Goto_statement() IGoto_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGoto_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGoto_statementContext) +} + +func (s *Cfl_statementContext) If_statement() IIf_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_statementContext) +} + +func (s *Cfl_statementContext) Print_statement() IPrint_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrint_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrint_statementContext) +} + +func (s *Cfl_statementContext) Raiseerror_statement() IRaiseerror_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRaiseerror_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRaiseerror_statementContext) +} + +func (s *Cfl_statementContext) Return_statement() IReturn_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReturn_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReturn_statementContext) +} + +func (s *Cfl_statementContext) Throw_statement() IThrow_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IThrow_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IThrow_statementContext) +} + +func (s *Cfl_statementContext) Try_catch_statement() ITry_catch_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITry_catch_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITry_catch_statementContext) +} + +func (s *Cfl_statementContext) Waitfor_statement() IWaitfor_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWaitfor_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWaitfor_statementContext) +} + +func (s *Cfl_statementContext) While_statement() IWhile_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhile_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhile_statementContext) +} + +func (s *Cfl_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cfl_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cfl_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCfl_statement(s) + } +} + +func (s *Cfl_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCfl_statement(s) + } +} + +func (s *Cfl_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCfl_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Cfl_statement() (localctx ICfl_statementContext) { + localctx = NewCfl_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 14, TSqlParserRULE_cfl_statement) + p.SetState(1508) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 19, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1496) + p.Block_statement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1497) + p.Break_statement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1498) + p.Continue_statement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1499) + p.Goto_statement() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1500) + p.If_statement() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1501) + p.Print_statement() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1502) + p.Raiseerror_statement() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1503) + p.Return_statement() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1504) + p.Throw_statement() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(1505) + p.Try_catch_statement() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(1506) + p.Waitfor_statement() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(1507) + p.While_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBlock_statementContext is an interface to support dynamic dispatch. +type IBlock_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BEGIN() antlr.TerminalNode + END() antlr.TerminalNode + AllSEMI() []antlr.TerminalNode + SEMI(i int) antlr.TerminalNode + AllSql_clauses() []ISql_clausesContext + Sql_clauses(i int) ISql_clausesContext + + // IsBlock_statementContext differentiates from other interfaces. + IsBlock_statementContext() +} + +type Block_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBlock_statementContext() *Block_statementContext { + var p = new(Block_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_block_statement + return p +} + +func InitEmptyBlock_statementContext(p *Block_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_block_statement +} + +func (*Block_statementContext) IsBlock_statementContext() {} + +func NewBlock_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Block_statementContext { + var p = new(Block_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_block_statement + + return p +} + +func (s *Block_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Block_statementContext) BEGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserBEGIN, 0) +} + +func (s *Block_statementContext) END() antlr.TerminalNode { + return s.GetToken(TSqlParserEND, 0) +} + +func (s *Block_statementContext) AllSEMI() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSEMI) +} + +func (s *Block_statementContext) SEMI(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, i) +} + +func (s *Block_statementContext) AllSql_clauses() []ISql_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_clausesContext); ok { + len++ + } + } + + tst := make([]ISql_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_clausesContext); ok { + tst[i] = t.(ISql_clausesContext) + i++ + } + } + + return tst +} + +func (s *Block_statementContext) Sql_clauses(i int) ISql_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_clausesContext) +} + +func (s *Block_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Block_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Block_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBlock_statement(s) + } +} + +func (s *Block_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBlock_statement(s) + } +} + +func (s *Block_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBlock_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Block_statement() (localctx IBlock_statementContext) { + localctx = NewBlock_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 16, TSqlParserRULE_block_statement) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1510) + p.Match(TSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1512) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 20, p.GetParserRuleContext()) == 1 { + { + p.SetState(1511) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1517) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 21, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1514) + p.Sql_clauses() + } + + } + p.SetState(1519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 21, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(1520) + p.Match(TSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1522) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 22, p.GetParserRuleContext()) == 1 { + { + p.SetState(1521) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBreak_statementContext is an interface to support dynamic dispatch. +type IBreak_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BREAK() antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsBreak_statementContext differentiates from other interfaces. + IsBreak_statementContext() +} + +type Break_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBreak_statementContext() *Break_statementContext { + var p = new(Break_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_break_statement + return p +} + +func InitEmptyBreak_statementContext(p *Break_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_break_statement +} + +func (*Break_statementContext) IsBreak_statementContext() {} + +func NewBreak_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Break_statementContext { + var p = new(Break_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_break_statement + + return p +} + +func (s *Break_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Break_statementContext) BREAK() antlr.TerminalNode { + return s.GetToken(TSqlParserBREAK, 0) +} + +func (s *Break_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Break_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Break_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Break_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBreak_statement(s) + } +} + +func (s *Break_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBreak_statement(s) + } +} + +func (s *Break_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBreak_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Break_statement() (localctx IBreak_statementContext) { + localctx = NewBreak_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 18, TSqlParserRULE_break_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1524) + p.Match(TSqlParserBREAK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1526) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 23, p.GetParserRuleContext()) == 1 { + { + p.SetState(1525) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IContinue_statementContext is an interface to support dynamic dispatch. +type IContinue_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONTINUE() antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsContinue_statementContext differentiates from other interfaces. + IsContinue_statementContext() +} + +type Continue_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContinue_statementContext() *Continue_statementContext { + var p = new(Continue_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_continue_statement + return p +} + +func InitEmptyContinue_statementContext(p *Continue_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_continue_statement +} + +func (*Continue_statementContext) IsContinue_statementContext() {} + +func NewContinue_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Continue_statementContext { + var p = new(Continue_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_continue_statement + + return p +} + +func (s *Continue_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Continue_statementContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTINUE, 0) +} + +func (s *Continue_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Continue_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Continue_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Continue_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterContinue_statement(s) + } +} + +func (s *Continue_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitContinue_statement(s) + } +} + +func (s *Continue_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitContinue_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Continue_statement() (localctx IContinue_statementContext) { + localctx = NewContinue_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 20, TSqlParserRULE_continue_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1528) + p.Match(TSqlParserCONTINUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1530) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 24, p.GetParserRuleContext()) == 1 { + { + p.SetState(1529) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGoto_statementContext is an interface to support dynamic dispatch. +type IGoto_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GOTO() antlr.TerminalNode + Id_() IId_Context + SEMI() antlr.TerminalNode + COLON() antlr.TerminalNode + + // IsGoto_statementContext differentiates from other interfaces. + IsGoto_statementContext() +} + +type Goto_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGoto_statementContext() *Goto_statementContext { + var p = new(Goto_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_goto_statement + return p +} + +func InitEmptyGoto_statementContext(p *Goto_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_goto_statement +} + +func (*Goto_statementContext) IsGoto_statementContext() {} + +func NewGoto_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Goto_statementContext { + var p = new(Goto_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_goto_statement + + return p +} + +func (s *Goto_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Goto_statementContext) GOTO() antlr.TerminalNode { + return s.GetToken(TSqlParserGOTO, 0) +} + +func (s *Goto_statementContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Goto_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Goto_statementContext) COLON() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLON, 0) +} + +func (s *Goto_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Goto_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Goto_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterGoto_statement(s) + } +} + +func (s *Goto_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitGoto_statement(s) + } +} + +func (s *Goto_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitGoto_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Goto_statement() (localctx IGoto_statementContext) { + localctx = NewGoto_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 22, TSqlParserRULE_goto_statement) + p.SetState(1542) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserGOTO: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1532) + p.Match(TSqlParserGOTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1533) + p.Id_() + } + p.SetState(1535) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 25, p.GetParserRuleContext()) == 1 { + { + p.SetState(1534) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1537) + p.Id_() + } + { + p.SetState(1538) + p.Match(TSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1540) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 26, p.GetParserRuleContext()) == 1 { + { + p.SetState(1539) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReturn_statementContext is an interface to support dynamic dispatch. +type IReturn_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURN() antlr.TerminalNode + Expression() IExpressionContext + SEMI() antlr.TerminalNode + + // IsReturn_statementContext differentiates from other interfaces. + IsReturn_statementContext() +} + +type Return_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReturn_statementContext() *Return_statementContext { + var p = new(Return_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_return_statement + return p +} + +func InitEmptyReturn_statementContext(p *Return_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_return_statement +} + +func (*Return_statementContext) IsReturn_statementContext() {} + +func NewReturn_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Return_statementContext { + var p = new(Return_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_return_statement + + return p +} + +func (s *Return_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Return_statementContext) RETURN() antlr.TerminalNode { + return s.GetToken(TSqlParserRETURN, 0) +} + +func (s *Return_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Return_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Return_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Return_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Return_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterReturn_statement(s) + } +} + +func (s *Return_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitReturn_statement(s) + } +} + +func (s *Return_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitReturn_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Return_statement() (localctx IReturn_statementContext) { + localctx = NewReturn_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 24, TSqlParserRULE_return_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1544) + p.Match(TSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1546) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 28, p.GetParserRuleContext()) == 1 { + { + p.SetState(1545) + p.expression(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1549) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 29, p.GetParserRuleContext()) == 1 { + { + p.SetState(1548) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIf_statementContext is an interface to support dynamic dispatch. +type IIf_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IF() antlr.TerminalNode + Search_condition() ISearch_conditionContext + AllSql_clauses() []ISql_clausesContext + Sql_clauses(i int) ISql_clausesContext + ELSE() antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsIf_statementContext differentiates from other interfaces. + IsIf_statementContext() +} + +type If_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIf_statementContext() *If_statementContext { + var p = new(If_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_if_statement + return p +} + +func InitEmptyIf_statementContext(p *If_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_if_statement +} + +func (*If_statementContext) IsIf_statementContext() {} + +func NewIf_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *If_statementContext { + var p = new(If_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_if_statement + + return p +} + +func (s *If_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *If_statementContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *If_statementContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *If_statementContext) AllSql_clauses() []ISql_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_clausesContext); ok { + len++ + } + } + + tst := make([]ISql_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_clausesContext); ok { + tst[i] = t.(ISql_clausesContext) + i++ + } + } + + return tst +} + +func (s *If_statementContext) Sql_clauses(i int) ISql_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_clausesContext) +} + +func (s *If_statementContext) ELSE() antlr.TerminalNode { + return s.GetToken(TSqlParserELSE, 0) +} + +func (s *If_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *If_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *If_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *If_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterIf_statement(s) + } +} + +func (s *If_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitIf_statement(s) + } +} + +func (s *If_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitIf_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) If_statement() (localctx IIf_statementContext) { + localctx = NewIf_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 26, TSqlParserRULE_if_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1551) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1552) + p.search_condition(0) + } + { + p.SetState(1553) + p.Sql_clauses() + } + p.SetState(1556) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 30, p.GetParserRuleContext()) == 1 { + { + p.SetState(1554) + p.Match(TSqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1555) + p.Sql_clauses() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1559) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 31, p.GetParserRuleContext()) == 1 { + { + p.SetState(1558) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IThrow_statementContext is an interface to support dynamic dispatch. +type IThrow_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + THROW() antlr.TerminalNode + Throw_error_number() IThrow_error_numberContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Throw_message() IThrow_messageContext + Throw_state() IThrow_stateContext + SEMI() antlr.TerminalNode + + // IsThrow_statementContext differentiates from other interfaces. + IsThrow_statementContext() +} + +type Throw_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyThrow_statementContext() *Throw_statementContext { + var p = new(Throw_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_throw_statement + return p +} + +func InitEmptyThrow_statementContext(p *Throw_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_throw_statement +} + +func (*Throw_statementContext) IsThrow_statementContext() {} + +func NewThrow_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Throw_statementContext { + var p = new(Throw_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_throw_statement + + return p +} + +func (s *Throw_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Throw_statementContext) THROW() antlr.TerminalNode { + return s.GetToken(TSqlParserTHROW, 0) +} + +func (s *Throw_statementContext) Throw_error_number() IThrow_error_numberContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IThrow_error_numberContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IThrow_error_numberContext) +} + +func (s *Throw_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Throw_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Throw_statementContext) Throw_message() IThrow_messageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IThrow_messageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IThrow_messageContext) +} + +func (s *Throw_statementContext) Throw_state() IThrow_stateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IThrow_stateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IThrow_stateContext) +} + +func (s *Throw_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Throw_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Throw_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Throw_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterThrow_statement(s) + } +} + +func (s *Throw_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitThrow_statement(s) + } +} + +func (s *Throw_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitThrow_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Throw_statement() (localctx IThrow_statementContext) { + localctx = NewThrow_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 28, TSqlParserRULE_throw_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1561) + p.Match(TSqlParserTHROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1568) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLOCAL_ID || _la == TSqlParserDECIMAL { + { + p.SetState(1562) + p.Throw_error_number() + } + { + p.SetState(1563) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1564) + p.Throw_message() + } + { + p.SetState(1565) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1566) + p.Throw_state() + } + + } + p.SetState(1571) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 33, p.GetParserRuleContext()) == 1 { + { + p.SetState(1570) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IThrow_error_numberContext is an interface to support dynamic dispatch. +type IThrow_error_numberContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECIMAL() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + + // IsThrow_error_numberContext differentiates from other interfaces. + IsThrow_error_numberContext() +} + +type Throw_error_numberContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyThrow_error_numberContext() *Throw_error_numberContext { + var p = new(Throw_error_numberContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_throw_error_number + return p +} + +func InitEmptyThrow_error_numberContext(p *Throw_error_numberContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_throw_error_number +} + +func (*Throw_error_numberContext) IsThrow_error_numberContext() {} + +func NewThrow_error_numberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Throw_error_numberContext { + var p = new(Throw_error_numberContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_throw_error_number + + return p +} + +func (s *Throw_error_numberContext) GetParser() antlr.Parser { return s.parser } + +func (s *Throw_error_numberContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Throw_error_numberContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Throw_error_numberContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Throw_error_numberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Throw_error_numberContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterThrow_error_number(s) + } +} + +func (s *Throw_error_numberContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitThrow_error_number(s) + } +} + +func (s *Throw_error_numberContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitThrow_error_number(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Throw_error_number() (localctx IThrow_error_numberContext) { + localctx = NewThrow_error_numberContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 30, TSqlParserRULE_throw_error_number) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1573) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOCAL_ID || _la == TSqlParserDECIMAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IThrow_messageContext is an interface to support dynamic dispatch. +type IThrow_messageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRING() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + + // IsThrow_messageContext differentiates from other interfaces. + IsThrow_messageContext() +} + +type Throw_messageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyThrow_messageContext() *Throw_messageContext { + var p = new(Throw_messageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_throw_message + return p +} + +func InitEmptyThrow_messageContext(p *Throw_messageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_throw_message +} + +func (*Throw_messageContext) IsThrow_messageContext() {} + +func NewThrow_messageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Throw_messageContext { + var p = new(Throw_messageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_throw_message + + return p +} + +func (s *Throw_messageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Throw_messageContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Throw_messageContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Throw_messageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Throw_messageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Throw_messageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterThrow_message(s) + } +} + +func (s *Throw_messageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitThrow_message(s) + } +} + +func (s *Throw_messageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitThrow_message(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Throw_message() (localctx IThrow_messageContext) { + localctx = NewThrow_messageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 32, TSqlParserRULE_throw_message) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1575) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOCAL_ID || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IThrow_stateContext is an interface to support dynamic dispatch. +type IThrow_stateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECIMAL() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + + // IsThrow_stateContext differentiates from other interfaces. + IsThrow_stateContext() +} + +type Throw_stateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyThrow_stateContext() *Throw_stateContext { + var p = new(Throw_stateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_throw_state + return p +} + +func InitEmptyThrow_stateContext(p *Throw_stateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_throw_state +} + +func (*Throw_stateContext) IsThrow_stateContext() {} + +func NewThrow_stateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Throw_stateContext { + var p = new(Throw_stateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_throw_state + + return p +} + +func (s *Throw_stateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Throw_stateContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Throw_stateContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Throw_stateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Throw_stateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Throw_stateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterThrow_state(s) + } +} + +func (s *Throw_stateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitThrow_state(s) + } +} + +func (s *Throw_stateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitThrow_state(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Throw_state() (localctx IThrow_stateContext) { + localctx = NewThrow_stateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 34, TSqlParserRULE_throw_state) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1577) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOCAL_ID || _la == TSqlParserDECIMAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITry_catch_statementContext is an interface to support dynamic dispatch. +type ITry_catch_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTry_clauses returns the try_clauses rule contexts. + GetTry_clauses() ISql_clausesContext + + // GetCatch_clauses returns the catch_clauses rule contexts. + GetCatch_clauses() ISql_clausesContext + + // SetTry_clauses sets the try_clauses rule contexts. + SetTry_clauses(ISql_clausesContext) + + // SetCatch_clauses sets the catch_clauses rule contexts. + SetCatch_clauses(ISql_clausesContext) + + // Getter signatures + AllBEGIN() []antlr.TerminalNode + BEGIN(i int) antlr.TerminalNode + AllTRY() []antlr.TerminalNode + TRY(i int) antlr.TerminalNode + AllEND() []antlr.TerminalNode + END(i int) antlr.TerminalNode + AllCATCH() []antlr.TerminalNode + CATCH(i int) antlr.TerminalNode + AllSEMI() []antlr.TerminalNode + SEMI(i int) antlr.TerminalNode + AllSql_clauses() []ISql_clausesContext + Sql_clauses(i int) ISql_clausesContext + + // IsTry_catch_statementContext differentiates from other interfaces. + IsTry_catch_statementContext() +} + +type Try_catch_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + try_clauses ISql_clausesContext + catch_clauses ISql_clausesContext +} + +func NewEmptyTry_catch_statementContext() *Try_catch_statementContext { + var p = new(Try_catch_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_try_catch_statement + return p +} + +func InitEmptyTry_catch_statementContext(p *Try_catch_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_try_catch_statement +} + +func (*Try_catch_statementContext) IsTry_catch_statementContext() {} + +func NewTry_catch_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Try_catch_statementContext { + var p = new(Try_catch_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_try_catch_statement + + return p +} + +func (s *Try_catch_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Try_catch_statementContext) GetTry_clauses() ISql_clausesContext { return s.try_clauses } + +func (s *Try_catch_statementContext) GetCatch_clauses() ISql_clausesContext { return s.catch_clauses } + +func (s *Try_catch_statementContext) SetTry_clauses(v ISql_clausesContext) { s.try_clauses = v } + +func (s *Try_catch_statementContext) SetCatch_clauses(v ISql_clausesContext) { s.catch_clauses = v } + +func (s *Try_catch_statementContext) AllBEGIN() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBEGIN) +} + +func (s *Try_catch_statementContext) BEGIN(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBEGIN, i) +} + +func (s *Try_catch_statementContext) AllTRY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTRY) +} + +func (s *Try_catch_statementContext) TRY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTRY, i) +} + +func (s *Try_catch_statementContext) AllEND() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEND) +} + +func (s *Try_catch_statementContext) END(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEND, i) +} + +func (s *Try_catch_statementContext) AllCATCH() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCATCH) +} + +func (s *Try_catch_statementContext) CATCH(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCATCH, i) +} + +func (s *Try_catch_statementContext) AllSEMI() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSEMI) +} + +func (s *Try_catch_statementContext) SEMI(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, i) +} + +func (s *Try_catch_statementContext) AllSql_clauses() []ISql_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_clausesContext); ok { + len++ + } + } + + tst := make([]ISql_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_clausesContext); ok { + tst[i] = t.(ISql_clausesContext) + i++ + } + } + + return tst +} + +func (s *Try_catch_statementContext) Sql_clauses(i int) ISql_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_clausesContext) +} + +func (s *Try_catch_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Try_catch_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Try_catch_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTry_catch_statement(s) + } +} + +func (s *Try_catch_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTry_catch_statement(s) + } +} + +func (s *Try_catch_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTry_catch_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Try_catch_statement() (localctx ITry_catch_statementContext) { + localctx = NewTry_catch_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 36, TSqlParserRULE_try_catch_statement) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1579) + p.Match(TSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1580) + p.Match(TSqlParserTRY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1582) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 34, p.GetParserRuleContext()) == 1 { + { + p.SetState(1581) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(1584) + + var _x = p.Sql_clauses() + + localctx.(*Try_catch_statementContext).try_clauses = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(1587) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 35, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(1589) + p.Match(TSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1590) + p.Match(TSqlParserTRY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSEMI { + { + p.SetState(1591) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1594) + p.Match(TSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1595) + p.Match(TSqlParserCATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1597) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 37, p.GetParserRuleContext()) == 1 { + { + p.SetState(1596) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1602) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 38, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1599) + + var _x = p.Sql_clauses() + + localctx.(*Try_catch_statementContext).catch_clauses = _x + } + + } + p.SetState(1604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 38, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(1605) + p.Match(TSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1606) + p.Match(TSqlParserCATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1608) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 39, p.GetParserRuleContext()) == 1 { + { + p.SetState(1607) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWaitfor_statementContext is an interface to support dynamic dispatch. +type IWaitfor_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WAITFOR() antlr.TerminalNode + Receive_statement() IReceive_statementContext + COMMA() antlr.TerminalNode + Time() ITimeContext + Expression() IExpressionContext + SEMI() antlr.TerminalNode + DELAY() antlr.TerminalNode + TIME() antlr.TerminalNode + TIMEOUT() antlr.TerminalNode + + // IsWaitfor_statementContext differentiates from other interfaces. + IsWaitfor_statementContext() +} + +type Waitfor_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWaitfor_statementContext() *Waitfor_statementContext { + var p = new(Waitfor_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_waitfor_statement + return p +} + +func InitEmptyWaitfor_statementContext(p *Waitfor_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_waitfor_statement +} + +func (*Waitfor_statementContext) IsWaitfor_statementContext() {} + +func NewWaitfor_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Waitfor_statementContext { + var p = new(Waitfor_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_waitfor_statement + + return p +} + +func (s *Waitfor_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Waitfor_statementContext) WAITFOR() antlr.TerminalNode { + return s.GetToken(TSqlParserWAITFOR, 0) +} + +func (s *Waitfor_statementContext) Receive_statement() IReceive_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReceive_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReceive_statementContext) +} + +func (s *Waitfor_statementContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Waitfor_statementContext) Time() ITimeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITimeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITimeContext) +} + +func (s *Waitfor_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Waitfor_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Waitfor_statementContext) DELAY() antlr.TerminalNode { + return s.GetToken(TSqlParserDELAY, 0) +} + +func (s *Waitfor_statementContext) TIME() antlr.TerminalNode { + return s.GetToken(TSqlParserTIME, 0) +} + +func (s *Waitfor_statementContext) TIMEOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserTIMEOUT, 0) +} + +func (s *Waitfor_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Waitfor_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Waitfor_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterWaitfor_statement(s) + } +} + +func (s *Waitfor_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitWaitfor_statement(s) + } +} + +func (s *Waitfor_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitWaitfor_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Waitfor_statement() (localctx IWaitfor_statementContext) { + localctx = NewWaitfor_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 38, TSqlParserRULE_waitfor_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1610) + p.Match(TSqlParserWAITFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1612) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 40, p.GetParserRuleContext()) == 1 { + { + p.SetState(1611) + p.Receive_statement() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(1614) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1619) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 42, p.GetParserRuleContext()) == 1 { + { + p.SetState(1617) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDELAY || _la == TSqlParserTIME || _la == TSqlParserTIMEOUT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1618) + p.Time() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1622) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 43, p.GetParserRuleContext()) == 1 { + { + p.SetState(1621) + p.expression(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1625) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 44, p.GetParserRuleContext()) == 1 { + { + p.SetState(1624) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhile_statementContext is an interface to support dynamic dispatch. +type IWhile_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHILE() antlr.TerminalNode + Search_condition() ISearch_conditionContext + Sql_clauses() ISql_clausesContext + BREAK() antlr.TerminalNode + CONTINUE() antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsWhile_statementContext differentiates from other interfaces. + IsWhile_statementContext() +} + +type While_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhile_statementContext() *While_statementContext { + var p = new(While_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_while_statement + return p +} + +func InitEmptyWhile_statementContext(p *While_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_while_statement +} + +func (*While_statementContext) IsWhile_statementContext() {} + +func NewWhile_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *While_statementContext { + var p = new(While_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_while_statement + + return p +} + +func (s *While_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *While_statementContext) WHILE() antlr.TerminalNode { + return s.GetToken(TSqlParserWHILE, 0) +} + +func (s *While_statementContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *While_statementContext) Sql_clauses() ISql_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_clausesContext) +} + +func (s *While_statementContext) BREAK() antlr.TerminalNode { + return s.GetToken(TSqlParserBREAK, 0) +} + +func (s *While_statementContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTINUE, 0) +} + +func (s *While_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *While_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *While_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *While_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterWhile_statement(s) + } +} + +func (s *While_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitWhile_statement(s) + } +} + +func (s *While_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitWhile_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) While_statement() (localctx IWhile_statementContext) { + localctx = NewWhile_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 40, TSqlParserRULE_while_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1627) + p.Match(TSqlParserWHILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1628) + p.search_condition(0) + } + p.SetState(1638) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 47, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1629) + p.Sql_clauses() + } + + case 2: + { + p.SetState(1630) + p.Match(TSqlParserBREAK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1632) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 45, p.GetParserRuleContext()) == 1 { + { + p.SetState(1631) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + { + p.SetState(1634) + p.Match(TSqlParserCONTINUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1636) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 46, p.GetParserRuleContext()) == 1 { + { + p.SetState(1635) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrint_statementContext is an interface to support dynamic dispatch. +type IPrint_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRINT() antlr.TerminalNode + Expression() IExpressionContext + DOUBLE_QUOTE_ID() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllLOCAL_ID() []antlr.TerminalNode + LOCAL_ID(i int) antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsPrint_statementContext differentiates from other interfaces. + IsPrint_statementContext() +} + +type Print_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrint_statementContext() *Print_statementContext { + var p = new(Print_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_print_statement + return p +} + +func InitEmptyPrint_statementContext(p *Print_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_print_statement +} + +func (*Print_statementContext) IsPrint_statementContext() {} + +func NewPrint_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Print_statementContext { + var p = new(Print_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_print_statement + + return p +} + +func (s *Print_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Print_statementContext) PRINT() antlr.TerminalNode { + return s.GetToken(TSqlParserPRINT, 0) +} + +func (s *Print_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Print_statementContext) DOUBLE_QUOTE_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_QUOTE_ID, 0) +} + +func (s *Print_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Print_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Print_statementContext) AllLOCAL_ID() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOCAL_ID) +} + +func (s *Print_statementContext) LOCAL_ID(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, i) +} + +func (s *Print_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Print_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Print_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Print_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPrint_statement(s) + } +} + +func (s *Print_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPrint_statement(s) + } +} + +func (s *Print_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPrint_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Print_statement() (localctx IPrint_statementContext) { + localctx = NewPrint_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 42, TSqlParserRULE_print_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1640) + p.Match(TSqlParserPRINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1643) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 48, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1641) + p.expression(0) + } + + case 2: + { + p.SetState(1642) + p.Match(TSqlParserDOUBLE_QUOTE_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(1649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(1645) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1646) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(1651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(1653) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 50, p.GetParserRuleContext()) == 1 { + { + p.SetState(1652) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRaiseerror_statementContext is an interface to support dynamic dispatch. +type IRaiseerror_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMsg returns the msg token. + GetMsg() antlr.Token + + // GetFormatstring returns the formatstring token. + GetFormatstring() antlr.Token + + // GetArgument returns the argument token. + GetArgument() antlr.Token + + // SetMsg sets the msg token. + SetMsg(antlr.Token) + + // SetFormatstring sets the formatstring token. + SetFormatstring(antlr.Token) + + // SetArgument sets the argument token. + SetArgument(antlr.Token) + + // GetSeverity returns the severity rule contexts. + GetSeverity() IConstant_LOCAL_IDContext + + // GetState returns the state rule contexts. + GetState() IConstant_LOCAL_IDContext + + // SetSeverity sets the severity rule contexts. + SetSeverity(IConstant_LOCAL_IDContext) + + // SetState sets the state rule contexts. + SetState(IConstant_LOCAL_IDContext) + + // Getter signatures + RAISERROR() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllConstant_LOCAL_ID() []IConstant_LOCAL_IDContext + Constant_LOCAL_ID(i int) IConstant_LOCAL_IDContext + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllLOCAL_ID() []antlr.TerminalNode + LOCAL_ID(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + SEMI() antlr.TerminalNode + LOG() antlr.TerminalNode + SETERROR() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + DOUBLE_QUOTE_ID() antlr.TerminalNode + + // IsRaiseerror_statementContext differentiates from other interfaces. + IsRaiseerror_statementContext() +} + +type Raiseerror_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + msg antlr.Token + severity IConstant_LOCAL_IDContext + state IConstant_LOCAL_IDContext + formatstring antlr.Token + argument antlr.Token +} + +func NewEmptyRaiseerror_statementContext() *Raiseerror_statementContext { + var p = new(Raiseerror_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_raiseerror_statement + return p +} + +func InitEmptyRaiseerror_statementContext(p *Raiseerror_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_raiseerror_statement +} + +func (*Raiseerror_statementContext) IsRaiseerror_statementContext() {} + +func NewRaiseerror_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Raiseerror_statementContext { + var p = new(Raiseerror_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_raiseerror_statement + + return p +} + +func (s *Raiseerror_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Raiseerror_statementContext) GetMsg() antlr.Token { return s.msg } + +func (s *Raiseerror_statementContext) GetFormatstring() antlr.Token { return s.formatstring } + +func (s *Raiseerror_statementContext) GetArgument() antlr.Token { return s.argument } + +func (s *Raiseerror_statementContext) SetMsg(v antlr.Token) { s.msg = v } + +func (s *Raiseerror_statementContext) SetFormatstring(v antlr.Token) { s.formatstring = v } + +func (s *Raiseerror_statementContext) SetArgument(v antlr.Token) { s.argument = v } + +func (s *Raiseerror_statementContext) GetSeverity() IConstant_LOCAL_IDContext { return s.severity } + +func (s *Raiseerror_statementContext) GetState() IConstant_LOCAL_IDContext { return s.state } + +func (s *Raiseerror_statementContext) SetSeverity(v IConstant_LOCAL_IDContext) { s.severity = v } + +func (s *Raiseerror_statementContext) SetState(v IConstant_LOCAL_IDContext) { s.state = v } + +func (s *Raiseerror_statementContext) RAISERROR() antlr.TerminalNode { + return s.GetToken(TSqlParserRAISERROR, 0) +} + +func (s *Raiseerror_statementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Raiseerror_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Raiseerror_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Raiseerror_statementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Raiseerror_statementContext) AllConstant_LOCAL_ID() []IConstant_LOCAL_IDContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstant_LOCAL_IDContext); ok { + len++ + } + } + + tst := make([]IConstant_LOCAL_IDContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstant_LOCAL_IDContext); ok { + tst[i] = t.(IConstant_LOCAL_IDContext) + i++ + } + } + + return tst +} + +func (s *Raiseerror_statementContext) Constant_LOCAL_ID(i int) IConstant_LOCAL_IDContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstant_LOCAL_IDContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstant_LOCAL_IDContext) +} + +func (s *Raiseerror_statementContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Raiseerror_statementContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Raiseerror_statementContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Raiseerror_statementContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Raiseerror_statementContext) AllLOCAL_ID() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOCAL_ID) +} + +func (s *Raiseerror_statementContext) LOCAL_ID(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, i) +} + +func (s *Raiseerror_statementContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Raiseerror_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Raiseerror_statementContext) LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserLOG, 0) +} + +func (s *Raiseerror_statementContext) SETERROR() antlr.TerminalNode { + return s.GetToken(TSqlParserSETERROR, 0) +} + +func (s *Raiseerror_statementContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOWAIT, 0) +} + +func (s *Raiseerror_statementContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNULL_) +} + +func (s *Raiseerror_statementContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_, i) +} + +func (s *Raiseerror_statementContext) DOUBLE_QUOTE_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_QUOTE_ID, 0) +} + +func (s *Raiseerror_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Raiseerror_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Raiseerror_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRaiseerror_statement(s) + } +} + +func (s *Raiseerror_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRaiseerror_statement(s) + } +} + +func (s *Raiseerror_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRaiseerror_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Raiseerror_statement() (localctx IRaiseerror_statementContext) { + localctx = NewRaiseerror_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 44, TSqlParserRULE_raiseerror_statement) + var _la int + + p.SetState(1690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 56, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1655) + p.Match(TSqlParserRAISERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1656) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1657) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Raiseerror_statementContext).msg = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1180)) & ^0x3f) == 0 && ((int64(1)<<(_la-1180))&21) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Raiseerror_statementContext).msg = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1658) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1659) + + var _x = p.Constant_LOCAL_ID() + + localctx.(*Raiseerror_statementContext).severity = _x + } + { + p.SetState(1660) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1661) + + var _x = p.Constant_LOCAL_ID() + + localctx.(*Raiseerror_statementContext).state = _x + } + p.SetState(1669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(1662) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1665) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLOCAL_ID, TSqlParserDECIMAL, TSqlParserSTRING, TSqlParserBINARY, TSqlParserFLOAT, TSqlParserREAL, TSqlParserDOLLAR, TSqlParserMINUS, TSqlParserPLACEHOLDER: + { + p.SetState(1663) + p.Constant_LOCAL_ID() + } + + case TSqlParserNULL_: + { + p.SetState(1664) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(1671) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1672) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1675) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 53, p.GetParserRuleContext()) == 1 { + { + p.SetState(1673) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1674) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOG || _la == TSqlParserNOWAIT || _la == TSqlParserSETERROR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1678) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 54, p.GetParserRuleContext()) == 1 { + { + p.SetState(1677) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1680) + p.Match(TSqlParserRAISERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1681) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1682) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Raiseerror_statementContext).formatstring = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1176)) & ^0x3f) == 0 && ((int64(1)<<(_la-1176))&273) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Raiseerror_statementContext).formatstring = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1687) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(1683) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1684) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Raiseerror_statementContext).argument = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1180)) & ^0x3f) == 0 && ((int64(1)<<(_la-1180))&21) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Raiseerror_statementContext).argument = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + p.SetState(1689) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEmpty_statementContext is an interface to support dynamic dispatch. +type IEmpty_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEMI() antlr.TerminalNode + + // IsEmpty_statementContext differentiates from other interfaces. + IsEmpty_statementContext() +} + +type Empty_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEmpty_statementContext() *Empty_statementContext { + var p = new(Empty_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_empty_statement + return p +} + +func InitEmptyEmpty_statementContext(p *Empty_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_empty_statement +} + +func (*Empty_statementContext) IsEmpty_statementContext() {} + +func NewEmpty_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Empty_statementContext { + var p = new(Empty_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_empty_statement + + return p +} + +func (s *Empty_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Empty_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Empty_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Empty_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Empty_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEmpty_statement(s) + } +} + +func (s *Empty_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEmpty_statement(s) + } +} + +func (s *Empty_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEmpty_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Empty_statement() (localctx IEmpty_statementContext) { + localctx = NewEmpty_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 46, TSqlParserRULE_empty_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1692) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAnother_statementContext is an interface to support dynamic dispatch. +type IAnother_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_queue() IAlter_queueContext + Checkpoint_statement() ICheckpoint_statementContext + Conversation_statement() IConversation_statementContext + Create_contract() ICreate_contractContext + Create_queue() ICreate_queueContext + Cursor_statement() ICursor_statementContext + Declare_statement() IDeclare_statementContext + Execute_statement() IExecute_statementContext + Kill_statement() IKill_statementContext + Message_statement() IMessage_statementContext + Reconfigure_statement() IReconfigure_statementContext + Security_statement() ISecurity_statementContext + Set_statement() ISet_statementContext + Setuser_statement() ISetuser_statementContext + Shutdown_statement() IShutdown_statementContext + Transaction_statement() ITransaction_statementContext + Use_statement() IUse_statementContext + + // IsAnother_statementContext differentiates from other interfaces. + IsAnother_statementContext() +} + +type Another_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnother_statementContext() *Another_statementContext { + var p = new(Another_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_another_statement + return p +} + +func InitEmptyAnother_statementContext(p *Another_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_another_statement +} + +func (*Another_statementContext) IsAnother_statementContext() {} + +func NewAnother_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Another_statementContext { + var p = new(Another_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_another_statement + + return p +} + +func (s *Another_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Another_statementContext) Alter_queue() IAlter_queueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_queueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_queueContext) +} + +func (s *Another_statementContext) Checkpoint_statement() ICheckpoint_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICheckpoint_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICheckpoint_statementContext) +} + +func (s *Another_statementContext) Conversation_statement() IConversation_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConversation_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConversation_statementContext) +} + +func (s *Another_statementContext) Create_contract() ICreate_contractContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_contractContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_contractContext) +} + +func (s *Another_statementContext) Create_queue() ICreate_queueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_queueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_queueContext) +} + +func (s *Another_statementContext) Cursor_statement() ICursor_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_statementContext) +} + +func (s *Another_statementContext) Declare_statement() IDeclare_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclare_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeclare_statementContext) +} + +func (s *Another_statementContext) Execute_statement() IExecute_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_statementContext) +} + +func (s *Another_statementContext) Kill_statement() IKill_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKill_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKill_statementContext) +} + +func (s *Another_statementContext) Message_statement() IMessage_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMessage_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMessage_statementContext) +} + +func (s *Another_statementContext) Reconfigure_statement() IReconfigure_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReconfigure_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReconfigure_statementContext) +} + +func (s *Another_statementContext) Security_statement() ISecurity_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecurity_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISecurity_statementContext) +} + +func (s *Another_statementContext) Set_statement() ISet_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_statementContext) +} + +func (s *Another_statementContext) Setuser_statement() ISetuser_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetuser_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetuser_statementContext) +} + +func (s *Another_statementContext) Shutdown_statement() IShutdown_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShutdown_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShutdown_statementContext) +} + +func (s *Another_statementContext) Transaction_statement() ITransaction_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransaction_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransaction_statementContext) +} + +func (s *Another_statementContext) Use_statement() IUse_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUse_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUse_statementContext) +} + +func (s *Another_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Another_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Another_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAnother_statement(s) + } +} + +func (s *Another_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAnother_statement(s) + } +} + +func (s *Another_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAnother_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Another_statement() (localctx IAnother_statementContext) { + localctx = NewAnother_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 48, TSqlParserRULE_another_statement) + p.SetState(1711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 57, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1694) + p.Alter_queue() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1695) + p.Checkpoint_statement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1696) + p.Conversation_statement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1697) + p.Create_contract() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1698) + p.Create_queue() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1699) + p.Cursor_statement() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1700) + p.Declare_statement() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1701) + p.Execute_statement() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1702) + p.Kill_statement() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(1703) + p.Message_statement() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(1704) + p.Reconfigure_statement() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(1705) + p.Security_statement() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(1706) + p.Set_statement() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(1707) + p.Setuser_statement() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(1708) + p.Shutdown_statement() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(1709) + p.Transaction_statement() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(1710) + p.Use_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_application_roleContext is an interface to support dynamic dispatch. +type IAlter_application_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetApplication_role_password returns the application_role_password token. + GetApplication_role_password() antlr.Token + + // SetApplication_role_password sets the application_role_password token. + SetApplication_role_password(antlr.Token) + + // GetAppliction_role returns the appliction_role rule contexts. + GetAppliction_role() IId_Context + + // GetNew_application_role_name returns the new_application_role_name rule contexts. + GetNew_application_role_name() IId_Context + + // GetApp_role_default_schema returns the app_role_default_schema rule contexts. + GetApp_role_default_schema() IId_Context + + // SetAppliction_role sets the appliction_role rule contexts. + SetAppliction_role(IId_Context) + + // SetNew_application_role_name sets the new_application_role_name rule contexts. + SetNew_application_role_name(IId_Context) + + // SetApp_role_default_schema sets the app_role_default_schema rule contexts. + SetApp_role_default_schema(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + APPLICATION() antlr.TerminalNode + ROLE() antlr.TerminalNode + WITH() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + NAME() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + PASSWORD() antlr.TerminalNode + DEFAULT_SCHEMA() antlr.TerminalNode + STRING() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_application_roleContext differentiates from other interfaces. + IsAlter_application_roleContext() +} + +type Alter_application_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + appliction_role IId_Context + new_application_role_name IId_Context + application_role_password antlr.Token + app_role_default_schema IId_Context +} + +func NewEmptyAlter_application_roleContext() *Alter_application_roleContext { + var p = new(Alter_application_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_application_role + return p +} + +func InitEmptyAlter_application_roleContext(p *Alter_application_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_application_role +} + +func (*Alter_application_roleContext) IsAlter_application_roleContext() {} + +func NewAlter_application_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_application_roleContext { + var p = new(Alter_application_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_application_role + + return p +} + +func (s *Alter_application_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_application_roleContext) GetApplication_role_password() antlr.Token { + return s.application_role_password +} + +func (s *Alter_application_roleContext) SetApplication_role_password(v antlr.Token) { + s.application_role_password = v +} + +func (s *Alter_application_roleContext) GetAppliction_role() IId_Context { return s.appliction_role } + +func (s *Alter_application_roleContext) GetNew_application_role_name() IId_Context { + return s.new_application_role_name +} + +func (s *Alter_application_roleContext) GetApp_role_default_schema() IId_Context { + return s.app_role_default_schema +} + +func (s *Alter_application_roleContext) SetAppliction_role(v IId_Context) { s.appliction_role = v } + +func (s *Alter_application_roleContext) SetNew_application_role_name(v IId_Context) { + s.new_application_role_name = v +} + +func (s *Alter_application_roleContext) SetApp_role_default_schema(v IId_Context) { + s.app_role_default_schema = v +} + +func (s *Alter_application_roleContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_application_roleContext) APPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLICATION, 0) +} + +func (s *Alter_application_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Alter_application_roleContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_application_roleContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_application_roleContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_application_roleContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *Alter_application_roleContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_application_roleContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_application_roleContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Alter_application_roleContext) DEFAULT_SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_SCHEMA, 0) +} + +func (s *Alter_application_roleContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Alter_application_roleContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_application_roleContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_application_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_application_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_application_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_application_role(s) + } +} + +func (s *Alter_application_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_application_role(s) + } +} + +func (s *Alter_application_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_application_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_application_role() (localctx IAlter_application_roleContext) { + localctx = NewAlter_application_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 50, TSqlParserRULE_alter_application_role) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1713) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1714) + p.Match(TSqlParserAPPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1715) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1716) + + var _x = p.Id_() + + localctx.(*Alter_application_roleContext).appliction_role = _x + } + { + p.SetState(1717) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1724) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 59, p.GetParserRuleContext()) == 1 { + p.SetState(1719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(1718) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1721) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1722) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1723) + + var _x = p.Id_() + + localctx.(*Alter_application_roleContext).new_application_role_name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1732) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 61, p.GetParserRuleContext()) == 1 { + p.SetState(1727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(1726) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1729) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1730) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1731) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_application_roleContext).application_role_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1740) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 63, p.GetParserRuleContext()) == 1 { + p.SetState(1735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(1734) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1737) + p.Match(TSqlParserDEFAULT_SCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1738) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1739) + + var _x = p.Id_() + + localctx.(*Alter_application_roleContext).app_role_default_schema = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_xml_schema_collectionContext is an interface to support dynamic dispatch. +type IAlter_xml_schema_collectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + XML() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + COLLECTION() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ADD() antlr.TerminalNode + STRING() antlr.TerminalNode + DOT() antlr.TerminalNode + + // IsAlter_xml_schema_collectionContext differentiates from other interfaces. + IsAlter_xml_schema_collectionContext() +} + +type Alter_xml_schema_collectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_xml_schema_collectionContext() *Alter_xml_schema_collectionContext { + var p = new(Alter_xml_schema_collectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_xml_schema_collection + return p +} + +func InitEmptyAlter_xml_schema_collectionContext(p *Alter_xml_schema_collectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_xml_schema_collection +} + +func (*Alter_xml_schema_collectionContext) IsAlter_xml_schema_collectionContext() {} + +func NewAlter_xml_schema_collectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_xml_schema_collectionContext { + var p = new(Alter_xml_schema_collectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_xml_schema_collection + + return p +} + +func (s *Alter_xml_schema_collectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_xml_schema_collectionContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_xml_schema_collectionContext) XML() antlr.TerminalNode { + return s.GetToken(TSqlParserXML, 0) +} + +func (s *Alter_xml_schema_collectionContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Alter_xml_schema_collectionContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLECTION, 0) +} + +func (s *Alter_xml_schema_collectionContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_xml_schema_collectionContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_xml_schema_collectionContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_xml_schema_collectionContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Alter_xml_schema_collectionContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Alter_xml_schema_collectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_xml_schema_collectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_xml_schema_collectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_xml_schema_collection(s) + } +} + +func (s *Alter_xml_schema_collectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_xml_schema_collection(s) + } +} + +func (s *Alter_xml_schema_collectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_xml_schema_collection(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_xml_schema_collection() (localctx IAlter_xml_schema_collectionContext) { + localctx = NewAlter_xml_schema_collectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 52, TSqlParserRULE_alter_xml_schema_collection) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1742) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1743) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1744) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1745) + p.Match(TSqlParserCOLLECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1749) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 64, p.GetParserRuleContext()) == 1 { + { + p.SetState(1746) + p.Id_() + } + { + p.SetState(1747) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1751) + p.Id_() + } + { + p.SetState(1752) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1753) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_application_roleContext is an interface to support dynamic dispatch. +type ICreate_application_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetApplication_role_password returns the application_role_password token. + GetApplication_role_password() antlr.Token + + // SetApplication_role_password sets the application_role_password token. + SetApplication_role_password(antlr.Token) + + // GetAppliction_role returns the appliction_role rule contexts. + GetAppliction_role() IId_Context + + // GetApp_role_default_schema returns the app_role_default_schema rule contexts. + GetApp_role_default_schema() IId_Context + + // SetAppliction_role sets the appliction_role rule contexts. + SetAppliction_role(IId_Context) + + // SetApp_role_default_schema sets the app_role_default_schema rule contexts. + SetApp_role_default_schema(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + APPLICATION() antlr.TerminalNode + ROLE() antlr.TerminalNode + WITH() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + PASSWORD() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + DEFAULT_SCHEMA() antlr.TerminalNode + STRING() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_application_roleContext differentiates from other interfaces. + IsCreate_application_roleContext() +} + +type Create_application_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + appliction_role IId_Context + application_role_password antlr.Token + app_role_default_schema IId_Context +} + +func NewEmptyCreate_application_roleContext() *Create_application_roleContext { + var p = new(Create_application_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_application_role + return p +} + +func InitEmptyCreate_application_roleContext(p *Create_application_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_application_role +} + +func (*Create_application_roleContext) IsCreate_application_roleContext() {} + +func NewCreate_application_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_application_roleContext { + var p = new(Create_application_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_application_role + + return p +} + +func (s *Create_application_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_application_roleContext) GetApplication_role_password() antlr.Token { + return s.application_role_password +} + +func (s *Create_application_roleContext) SetApplication_role_password(v antlr.Token) { + s.application_role_password = v +} + +func (s *Create_application_roleContext) GetAppliction_role() IId_Context { return s.appliction_role } + +func (s *Create_application_roleContext) GetApp_role_default_schema() IId_Context { + return s.app_role_default_schema +} + +func (s *Create_application_roleContext) SetAppliction_role(v IId_Context) { s.appliction_role = v } + +func (s *Create_application_roleContext) SetApp_role_default_schema(v IId_Context) { + s.app_role_default_schema = v +} + +func (s *Create_application_roleContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_application_roleContext) APPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLICATION, 0) +} + +func (s *Create_application_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Create_application_roleContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_application_roleContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_application_roleContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_application_roleContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Create_application_roleContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_application_roleContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_application_roleContext) DEFAULT_SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_SCHEMA, 0) +} + +func (s *Create_application_roleContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_application_roleContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_application_roleContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_application_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_application_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_application_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_application_role(s) + } +} + +func (s *Create_application_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_application_role(s) + } +} + +func (s *Create_application_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_application_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_application_role() (localctx ICreate_application_roleContext) { + localctx = NewCreate_application_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 54, TSqlParserRULE_create_application_role) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1755) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1756) + p.Match(TSqlParserAPPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1757) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1758) + + var _x = p.Id_() + + localctx.(*Create_application_roleContext).appliction_role = _x + } + { + p.SetState(1759) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1766) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 66, p.GetParserRuleContext()) == 1 { + p.SetState(1761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(1760) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1763) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1764) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1765) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_application_roleContext).application_role_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1774) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 68, p.GetParserRuleContext()) == 1 { + p.SetState(1769) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(1768) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1771) + p.Match(TSqlParserDEFAULT_SCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1772) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1773) + + var _x = p.Id_() + + localctx.(*Create_application_roleContext).app_role_default_schema = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_aggregateContext is an interface to support dynamic dispatch. +type IDrop_aggregateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetAggregate_name returns the aggregate_name rule contexts. + GetAggregate_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetAggregate_name sets the aggregate_name rule contexts. + SetAggregate_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + DOT() antlr.TerminalNode + + // IsDrop_aggregateContext differentiates from other interfaces. + IsDrop_aggregateContext() +} + +type Drop_aggregateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + aggregate_name IId_Context +} + +func NewEmptyDrop_aggregateContext() *Drop_aggregateContext { + var p = new(Drop_aggregateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_aggregate + return p +} + +func InitEmptyDrop_aggregateContext(p *Drop_aggregateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_aggregate +} + +func (*Drop_aggregateContext) IsDrop_aggregateContext() {} + +func NewDrop_aggregateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_aggregateContext { + var p = new(Drop_aggregateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_aggregate + + return p +} + +func (s *Drop_aggregateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_aggregateContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Drop_aggregateContext) GetAggregate_name() IId_Context { return s.aggregate_name } + +func (s *Drop_aggregateContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Drop_aggregateContext) SetAggregate_name(v IId_Context) { s.aggregate_name = v } + +func (s *Drop_aggregateContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_aggregateContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(TSqlParserAGGREGATE, 0) +} + +func (s *Drop_aggregateContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_aggregateContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_aggregateContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_aggregateContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_aggregateContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Drop_aggregateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_aggregateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_aggregateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_aggregate(s) + } +} + +func (s *Drop_aggregateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_aggregate(s) + } +} + +func (s *Drop_aggregateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_aggregate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_aggregate() (localctx IDrop_aggregateContext) { + localctx = NewDrop_aggregateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 56, TSqlParserRULE_drop_aggregate) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1776) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1777) + p.Match(TSqlParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(1778) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1779) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1785) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 70, p.GetParserRuleContext()) == 1 { + { + p.SetState(1782) + + var _x = p.Id_() + + localctx.(*Drop_aggregateContext).schema_name = _x + } + { + p.SetState(1783) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1787) + + var _x = p.Id_() + + localctx.(*Drop_aggregateContext).aggregate_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_application_roleContext is an interface to support dynamic dispatch. +type IDrop_application_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRolename returns the rolename rule contexts. + GetRolename() IId_Context + + // SetRolename sets the rolename rule contexts. + SetRolename(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + APPLICATION() antlr.TerminalNode + ROLE() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_application_roleContext differentiates from other interfaces. + IsDrop_application_roleContext() +} + +type Drop_application_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + rolename IId_Context +} + +func NewEmptyDrop_application_roleContext() *Drop_application_roleContext { + var p = new(Drop_application_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_application_role + return p +} + +func InitEmptyDrop_application_roleContext(p *Drop_application_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_application_role +} + +func (*Drop_application_roleContext) IsDrop_application_roleContext() {} + +func NewDrop_application_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_application_roleContext { + var p = new(Drop_application_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_application_role + + return p +} + +func (s *Drop_application_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_application_roleContext) GetRolename() IId_Context { return s.rolename } + +func (s *Drop_application_roleContext) SetRolename(v IId_Context) { s.rolename = v } + +func (s *Drop_application_roleContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_application_roleContext) APPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLICATION, 0) +} + +func (s *Drop_application_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Drop_application_roleContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_application_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_application_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_application_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_application_role(s) + } +} + +func (s *Drop_application_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_application_role(s) + } +} + +func (s *Drop_application_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_application_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_application_role() (localctx IDrop_application_roleContext) { + localctx = NewDrop_application_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 58, TSqlParserRULE_drop_application_role) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1789) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1790) + p.Match(TSqlParserAPPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1791) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1792) + + var _x = p.Id_() + + localctx.(*Drop_application_roleContext).rolename = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assemblyContext is an interface to support dynamic dispatch. +type IAlter_assemblyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAssembly_name returns the assembly_name rule contexts. + GetAssembly_name() IId_Context + + // SetAssembly_name sets the assembly_name rule contexts. + SetAssembly_name(IId_Context) + + // Getter signatures + Alter_assembly_start() IAlter_assembly_startContext + Alter_assembly_clause() IAlter_assembly_clauseContext + Id_() IId_Context + + // IsAlter_assemblyContext differentiates from other interfaces. + IsAlter_assemblyContext() +} + +type Alter_assemblyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + assembly_name IId_Context +} + +func NewEmptyAlter_assemblyContext() *Alter_assemblyContext { + var p = new(Alter_assemblyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly + return p +} + +func InitEmptyAlter_assemblyContext(p *Alter_assemblyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly +} + +func (*Alter_assemblyContext) IsAlter_assemblyContext() {} + +func NewAlter_assemblyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assemblyContext { + var p = new(Alter_assemblyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly + + return p +} + +func (s *Alter_assemblyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assemblyContext) GetAssembly_name() IId_Context { return s.assembly_name } + +func (s *Alter_assemblyContext) SetAssembly_name(v IId_Context) { s.assembly_name = v } + +func (s *Alter_assemblyContext) Alter_assembly_start() IAlter_assembly_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_startContext) +} + +func (s *Alter_assemblyContext) Alter_assembly_clause() IAlter_assembly_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_clauseContext) +} + +func (s *Alter_assemblyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_assemblyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assemblyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assemblyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly(s) + } +} + +func (s *Alter_assemblyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly(s) + } +} + +func (s *Alter_assemblyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly() (localctx IAlter_assemblyContext) { + localctx = NewAlter_assemblyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 60, TSqlParserRULE_alter_assembly) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1794) + p.Alter_assembly_start() + } + { + p.SetState(1795) + + var _x = p.Id_() + + localctx.(*Alter_assemblyContext).assembly_name = _x + } + { + p.SetState(1796) + p.Alter_assembly_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_startContext is an interface to support dynamic dispatch. +type IAlter_assembly_startContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + ASSEMBLY() antlr.TerminalNode + + // IsAlter_assembly_startContext differentiates from other interfaces. + IsAlter_assembly_startContext() +} + +type Alter_assembly_startContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_startContext() *Alter_assembly_startContext { + var p = new(Alter_assembly_startContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_start + return p +} + +func InitEmptyAlter_assembly_startContext(p *Alter_assembly_startContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_start +} + +func (*Alter_assembly_startContext) IsAlter_assembly_startContext() {} + +func NewAlter_assembly_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_startContext { + var p = new(Alter_assembly_startContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_start + + return p +} + +func (s *Alter_assembly_startContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_startContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_assembly_startContext) ASSEMBLY() antlr.TerminalNode { + return s.GetToken(TSqlParserASSEMBLY, 0) +} + +func (s *Alter_assembly_startContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_startContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_start(s) + } +} + +func (s *Alter_assembly_startContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_start(s) + } +} + +func (s *Alter_assembly_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_start(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_start() (localctx IAlter_assembly_startContext) { + localctx = NewAlter_assembly_startContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 62, TSqlParserRULE_alter_assembly_start) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1798) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1799) + p.Match(TSqlParserASSEMBLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_clauseContext is an interface to support dynamic dispatch. +type IAlter_assembly_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_assembly_from_clause() IAlter_assembly_from_clauseContext + Alter_assembly_with_clause() IAlter_assembly_with_clauseContext + Alter_assembly_drop_clause() IAlter_assembly_drop_clauseContext + Alter_assembly_add_clause() IAlter_assembly_add_clauseContext + + // IsAlter_assembly_clauseContext differentiates from other interfaces. + IsAlter_assembly_clauseContext() +} + +type Alter_assembly_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_clauseContext() *Alter_assembly_clauseContext { + var p = new(Alter_assembly_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_clause + return p +} + +func InitEmptyAlter_assembly_clauseContext(p *Alter_assembly_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_clause +} + +func (*Alter_assembly_clauseContext) IsAlter_assembly_clauseContext() {} + +func NewAlter_assembly_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_clauseContext { + var p = new(Alter_assembly_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_clause + + return p +} + +func (s *Alter_assembly_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_clauseContext) Alter_assembly_from_clause() IAlter_assembly_from_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_from_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_from_clauseContext) +} + +func (s *Alter_assembly_clauseContext) Alter_assembly_with_clause() IAlter_assembly_with_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_with_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_with_clauseContext) +} + +func (s *Alter_assembly_clauseContext) Alter_assembly_drop_clause() IAlter_assembly_drop_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_drop_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_drop_clauseContext) +} + +func (s *Alter_assembly_clauseContext) Alter_assembly_add_clause() IAlter_assembly_add_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_add_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_add_clauseContext) +} + +func (s *Alter_assembly_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_clause(s) + } +} + +func (s *Alter_assembly_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_clause(s) + } +} + +func (s *Alter_assembly_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_clause() (localctx IAlter_assembly_clauseContext) { + localctx = NewAlter_assembly_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 64, TSqlParserRULE_alter_assembly_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFROM { + { + p.SetState(1801) + p.Alter_assembly_from_clause() + } + + } + p.SetState(1805) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 72, p.GetParserRuleContext()) == 1 { + { + p.SetState(1804) + p.Alter_assembly_with_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1808) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 73, p.GetParserRuleContext()) == 1 { + { + p.SetState(1807) + p.Alter_assembly_drop_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(1811) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 74, p.GetParserRuleContext()) == 1 { + { + p.SetState(1810) + p.Alter_assembly_add_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_from_clauseContext is an interface to support dynamic dispatch. +type IAlter_assembly_from_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_assembly_from_clause_start() IAlter_assembly_from_clause_startContext + Client_assembly_specifier() IClient_assembly_specifierContext + Alter_assembly_file_bits() IAlter_assembly_file_bitsContext + + // IsAlter_assembly_from_clauseContext differentiates from other interfaces. + IsAlter_assembly_from_clauseContext() +} + +type Alter_assembly_from_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_from_clauseContext() *Alter_assembly_from_clauseContext { + var p = new(Alter_assembly_from_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_from_clause + return p +} + +func InitEmptyAlter_assembly_from_clauseContext(p *Alter_assembly_from_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_from_clause +} + +func (*Alter_assembly_from_clauseContext) IsAlter_assembly_from_clauseContext() {} + +func NewAlter_assembly_from_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_from_clauseContext { + var p = new(Alter_assembly_from_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_from_clause + + return p +} + +func (s *Alter_assembly_from_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_from_clauseContext) Alter_assembly_from_clause_start() IAlter_assembly_from_clause_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_from_clause_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_from_clause_startContext) +} + +func (s *Alter_assembly_from_clauseContext) Client_assembly_specifier() IClient_assembly_specifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClient_assembly_specifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClient_assembly_specifierContext) +} + +func (s *Alter_assembly_from_clauseContext) Alter_assembly_file_bits() IAlter_assembly_file_bitsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_file_bitsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_file_bitsContext) +} + +func (s *Alter_assembly_from_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_from_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_from_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_from_clause(s) + } +} + +func (s *Alter_assembly_from_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_from_clause(s) + } +} + +func (s *Alter_assembly_from_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_from_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_from_clause() (localctx IAlter_assembly_from_clauseContext) { + localctx = NewAlter_assembly_from_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 66, TSqlParserRULE_alter_assembly_from_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1813) + p.Alter_assembly_from_clause_start() + } + p.SetState(1816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDOUBLE_BACK_SLASH, TSqlParserDISK_DRIVE, TSqlParserSTRING: + { + p.SetState(1814) + p.Client_assembly_specifier() + } + + case TSqlParserAS: + { + p.SetState(1815) + p.Alter_assembly_file_bits() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_from_clause_startContext is an interface to support dynamic dispatch. +type IAlter_assembly_from_clause_startContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + + // IsAlter_assembly_from_clause_startContext differentiates from other interfaces. + IsAlter_assembly_from_clause_startContext() +} + +type Alter_assembly_from_clause_startContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_from_clause_startContext() *Alter_assembly_from_clause_startContext { + var p = new(Alter_assembly_from_clause_startContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_from_clause_start + return p +} + +func InitEmptyAlter_assembly_from_clause_startContext(p *Alter_assembly_from_clause_startContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_from_clause_start +} + +func (*Alter_assembly_from_clause_startContext) IsAlter_assembly_from_clause_startContext() {} + +func NewAlter_assembly_from_clause_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_from_clause_startContext { + var p = new(Alter_assembly_from_clause_startContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_from_clause_start + + return p +} + +func (s *Alter_assembly_from_clause_startContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_from_clause_startContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Alter_assembly_from_clause_startContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_from_clause_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_from_clause_startContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_from_clause_start(s) + } +} + +func (s *Alter_assembly_from_clause_startContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_from_clause_start(s) + } +} + +func (s *Alter_assembly_from_clause_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_from_clause_start(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_from_clause_start() (localctx IAlter_assembly_from_clause_startContext) { + localctx = NewAlter_assembly_from_clause_startContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 68, TSqlParserRULE_alter_assembly_from_clause_start) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1818) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_drop_clauseContext is an interface to support dynamic dispatch. +type IAlter_assembly_drop_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_assembly_drop() IAlter_assembly_dropContext + Alter_assembly_drop_multiple_files() IAlter_assembly_drop_multiple_filesContext + + // IsAlter_assembly_drop_clauseContext differentiates from other interfaces. + IsAlter_assembly_drop_clauseContext() +} + +type Alter_assembly_drop_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_drop_clauseContext() *Alter_assembly_drop_clauseContext { + var p = new(Alter_assembly_drop_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_drop_clause + return p +} + +func InitEmptyAlter_assembly_drop_clauseContext(p *Alter_assembly_drop_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_drop_clause +} + +func (*Alter_assembly_drop_clauseContext) IsAlter_assembly_drop_clauseContext() {} + +func NewAlter_assembly_drop_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_drop_clauseContext { + var p = new(Alter_assembly_drop_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_drop_clause + + return p +} + +func (s *Alter_assembly_drop_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_drop_clauseContext) Alter_assembly_drop() IAlter_assembly_dropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_dropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_dropContext) +} + +func (s *Alter_assembly_drop_clauseContext) Alter_assembly_drop_multiple_files() IAlter_assembly_drop_multiple_filesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_drop_multiple_filesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_drop_multiple_filesContext) +} + +func (s *Alter_assembly_drop_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_drop_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_drop_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_drop_clause(s) + } +} + +func (s *Alter_assembly_drop_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_drop_clause(s) + } +} + +func (s *Alter_assembly_drop_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_drop_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_drop_clause() (localctx IAlter_assembly_drop_clauseContext) { + localctx = NewAlter_assembly_drop_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 70, TSqlParserRULE_alter_assembly_drop_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1820) + p.Alter_assembly_drop() + } + { + p.SetState(1821) + p.Alter_assembly_drop_multiple_files() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_drop_multiple_filesContext is an interface to support dynamic dispatch. +type IAlter_assembly_drop_multiple_filesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + Multiple_local_files() IMultiple_local_filesContext + + // IsAlter_assembly_drop_multiple_filesContext differentiates from other interfaces. + IsAlter_assembly_drop_multiple_filesContext() +} + +type Alter_assembly_drop_multiple_filesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_drop_multiple_filesContext() *Alter_assembly_drop_multiple_filesContext { + var p = new(Alter_assembly_drop_multiple_filesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_drop_multiple_files + return p +} + +func InitEmptyAlter_assembly_drop_multiple_filesContext(p *Alter_assembly_drop_multiple_filesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_drop_multiple_files +} + +func (*Alter_assembly_drop_multiple_filesContext) IsAlter_assembly_drop_multiple_filesContext() {} + +func NewAlter_assembly_drop_multiple_filesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_drop_multiple_filesContext { + var p = new(Alter_assembly_drop_multiple_filesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_drop_multiple_files + + return p +} + +func (s *Alter_assembly_drop_multiple_filesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_drop_multiple_filesContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Alter_assembly_drop_multiple_filesContext) Multiple_local_files() IMultiple_local_filesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiple_local_filesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultiple_local_filesContext) +} + +func (s *Alter_assembly_drop_multiple_filesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_drop_multiple_filesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_drop_multiple_filesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_drop_multiple_files(s) + } +} + +func (s *Alter_assembly_drop_multiple_filesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_drop_multiple_files(s) + } +} + +func (s *Alter_assembly_drop_multiple_filesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_drop_multiple_files(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_drop_multiple_files() (localctx IAlter_assembly_drop_multiple_filesContext) { + localctx = NewAlter_assembly_drop_multiple_filesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 72, TSqlParserRULE_alter_assembly_drop_multiple_files) + p.SetState(1825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1823) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDISK_DRIVE, TSqlParserSINGLE_QUOTE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1824) + p.Multiple_local_files() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_dropContext is an interface to support dynamic dispatch. +type IAlter_assembly_dropContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + + // IsAlter_assembly_dropContext differentiates from other interfaces. + IsAlter_assembly_dropContext() +} + +type Alter_assembly_dropContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_dropContext() *Alter_assembly_dropContext { + var p = new(Alter_assembly_dropContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_drop + return p +} + +func InitEmptyAlter_assembly_dropContext(p *Alter_assembly_dropContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_drop +} + +func (*Alter_assembly_dropContext) IsAlter_assembly_dropContext() {} + +func NewAlter_assembly_dropContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_dropContext { + var p = new(Alter_assembly_dropContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_drop + + return p +} + +func (s *Alter_assembly_dropContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_dropContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Alter_assembly_dropContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_dropContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_dropContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_drop(s) + } +} + +func (s *Alter_assembly_dropContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_drop(s) + } +} + +func (s *Alter_assembly_dropContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_drop(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_drop() (localctx IAlter_assembly_dropContext) { + localctx = NewAlter_assembly_dropContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 74, TSqlParserRULE_alter_assembly_drop) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1827) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_add_clauseContext is an interface to support dynamic dispatch. +type IAlter_assembly_add_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_asssembly_add_clause_start() IAlter_asssembly_add_clause_startContext + Alter_assembly_client_file_clause() IAlter_assembly_client_file_clauseContext + + // IsAlter_assembly_add_clauseContext differentiates from other interfaces. + IsAlter_assembly_add_clauseContext() +} + +type Alter_assembly_add_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_add_clauseContext() *Alter_assembly_add_clauseContext { + var p = new(Alter_assembly_add_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_add_clause + return p +} + +func InitEmptyAlter_assembly_add_clauseContext(p *Alter_assembly_add_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_add_clause +} + +func (*Alter_assembly_add_clauseContext) IsAlter_assembly_add_clauseContext() {} + +func NewAlter_assembly_add_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_add_clauseContext { + var p = new(Alter_assembly_add_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_add_clause + + return p +} + +func (s *Alter_assembly_add_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_add_clauseContext) Alter_asssembly_add_clause_start() IAlter_asssembly_add_clause_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_asssembly_add_clause_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_asssembly_add_clause_startContext) +} + +func (s *Alter_assembly_add_clauseContext) Alter_assembly_client_file_clause() IAlter_assembly_client_file_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_client_file_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_client_file_clauseContext) +} + +func (s *Alter_assembly_add_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_add_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_add_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_add_clause(s) + } +} + +func (s *Alter_assembly_add_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_add_clause(s) + } +} + +func (s *Alter_assembly_add_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_add_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_add_clause() (localctx IAlter_assembly_add_clauseContext) { + localctx = NewAlter_assembly_add_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 76, TSqlParserRULE_alter_assembly_add_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1829) + p.Alter_asssembly_add_clause_start() + } + { + p.SetState(1830) + p.Alter_assembly_client_file_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_asssembly_add_clause_startContext is an interface to support dynamic dispatch. +type IAlter_asssembly_add_clause_startContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + FILE() antlr.TerminalNode + FROM() antlr.TerminalNode + + // IsAlter_asssembly_add_clause_startContext differentiates from other interfaces. + IsAlter_asssembly_add_clause_startContext() +} + +type Alter_asssembly_add_clause_startContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_asssembly_add_clause_startContext() *Alter_asssembly_add_clause_startContext { + var p = new(Alter_asssembly_add_clause_startContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_asssembly_add_clause_start + return p +} + +func InitEmptyAlter_asssembly_add_clause_startContext(p *Alter_asssembly_add_clause_startContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_asssembly_add_clause_start +} + +func (*Alter_asssembly_add_clause_startContext) IsAlter_asssembly_add_clause_startContext() {} + +func NewAlter_asssembly_add_clause_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_asssembly_add_clause_startContext { + var p = new(Alter_asssembly_add_clause_startContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_asssembly_add_clause_start + + return p +} + +func (s *Alter_asssembly_add_clause_startContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_asssembly_add_clause_startContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_asssembly_add_clause_startContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Alter_asssembly_add_clause_startContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Alter_asssembly_add_clause_startContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_asssembly_add_clause_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_asssembly_add_clause_startContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_asssembly_add_clause_start(s) + } +} + +func (s *Alter_asssembly_add_clause_startContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_asssembly_add_clause_start(s) + } +} + +func (s *Alter_asssembly_add_clause_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_asssembly_add_clause_start(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_asssembly_add_clause_start() (localctx IAlter_asssembly_add_clause_startContext) { + localctx = NewAlter_asssembly_add_clause_startContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 78, TSqlParserRULE_alter_asssembly_add_clause_start) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1832) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1833) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1834) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_client_file_clauseContext is an interface to support dynamic dispatch. +type IAlter_assembly_client_file_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_assembly_file_name() IAlter_assembly_file_nameContext + Alter_assembly_as() IAlter_assembly_asContext + Id_() IId_Context + + // IsAlter_assembly_client_file_clauseContext differentiates from other interfaces. + IsAlter_assembly_client_file_clauseContext() +} + +type Alter_assembly_client_file_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_client_file_clauseContext() *Alter_assembly_client_file_clauseContext { + var p = new(Alter_assembly_client_file_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_client_file_clause + return p +} + +func InitEmptyAlter_assembly_client_file_clauseContext(p *Alter_assembly_client_file_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_client_file_clause +} + +func (*Alter_assembly_client_file_clauseContext) IsAlter_assembly_client_file_clauseContext() {} + +func NewAlter_assembly_client_file_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_client_file_clauseContext { + var p = new(Alter_assembly_client_file_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_client_file_clause + + return p +} + +func (s *Alter_assembly_client_file_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_client_file_clauseContext) Alter_assembly_file_name() IAlter_assembly_file_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_file_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_file_nameContext) +} + +func (s *Alter_assembly_client_file_clauseContext) Alter_assembly_as() IAlter_assembly_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_asContext) +} + +func (s *Alter_assembly_client_file_clauseContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_assembly_client_file_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_client_file_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_client_file_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_client_file_clause(s) + } +} + +func (s *Alter_assembly_client_file_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_client_file_clause(s) + } +} + +func (s *Alter_assembly_client_file_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_client_file_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_client_file_clause() (localctx IAlter_assembly_client_file_clauseContext) { + localctx = NewAlter_assembly_client_file_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 80, TSqlParserRULE_alter_assembly_client_file_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1836) + p.Alter_assembly_file_name() + } + p.SetState(1840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(1837) + p.Alter_assembly_as() + } + { + p.SetState(1838) + p.Id_() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_file_nameContext is an interface to support dynamic dispatch. +type IAlter_assembly_file_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRING() antlr.TerminalNode + + // IsAlter_assembly_file_nameContext differentiates from other interfaces. + IsAlter_assembly_file_nameContext() +} + +type Alter_assembly_file_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_file_nameContext() *Alter_assembly_file_nameContext { + var p = new(Alter_assembly_file_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_file_name + return p +} + +func InitEmptyAlter_assembly_file_nameContext(p *Alter_assembly_file_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_file_name +} + +func (*Alter_assembly_file_nameContext) IsAlter_assembly_file_nameContext() {} + +func NewAlter_assembly_file_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_file_nameContext { + var p = new(Alter_assembly_file_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_file_name + + return p +} + +func (s *Alter_assembly_file_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_file_nameContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Alter_assembly_file_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_file_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_file_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_file_name(s) + } +} + +func (s *Alter_assembly_file_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_file_name(s) + } +} + +func (s *Alter_assembly_file_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_file_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_file_name() (localctx IAlter_assembly_file_nameContext) { + localctx = NewAlter_assembly_file_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 82, TSqlParserRULE_alter_assembly_file_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1842) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_file_bitsContext is an interface to support dynamic dispatch. +type IAlter_assembly_file_bitsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_assembly_as() IAlter_assembly_asContext + Id_() IId_Context + + // IsAlter_assembly_file_bitsContext differentiates from other interfaces. + IsAlter_assembly_file_bitsContext() +} + +type Alter_assembly_file_bitsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_file_bitsContext() *Alter_assembly_file_bitsContext { + var p = new(Alter_assembly_file_bitsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_file_bits + return p +} + +func InitEmptyAlter_assembly_file_bitsContext(p *Alter_assembly_file_bitsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_file_bits +} + +func (*Alter_assembly_file_bitsContext) IsAlter_assembly_file_bitsContext() {} + +func NewAlter_assembly_file_bitsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_file_bitsContext { + var p = new(Alter_assembly_file_bitsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_file_bits + + return p +} + +func (s *Alter_assembly_file_bitsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_file_bitsContext) Alter_assembly_as() IAlter_assembly_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_asContext) +} + +func (s *Alter_assembly_file_bitsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_assembly_file_bitsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_file_bitsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_file_bitsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_file_bits(s) + } +} + +func (s *Alter_assembly_file_bitsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_file_bits(s) + } +} + +func (s *Alter_assembly_file_bitsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_file_bits(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_file_bits() (localctx IAlter_assembly_file_bitsContext) { + localctx = NewAlter_assembly_file_bitsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 84, TSqlParserRULE_alter_assembly_file_bits) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1844) + p.Alter_assembly_as() + } + { + p.SetState(1845) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_asContext is an interface to support dynamic dispatch. +type IAlter_assembly_asContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS() antlr.TerminalNode + + // IsAlter_assembly_asContext differentiates from other interfaces. + IsAlter_assembly_asContext() +} + +type Alter_assembly_asContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_asContext() *Alter_assembly_asContext { + var p = new(Alter_assembly_asContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_as + return p +} + +func InitEmptyAlter_assembly_asContext(p *Alter_assembly_asContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_as +} + +func (*Alter_assembly_asContext) IsAlter_assembly_asContext() {} + +func NewAlter_assembly_asContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_asContext { + var p = new(Alter_assembly_asContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_as + + return p +} + +func (s *Alter_assembly_asContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_asContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Alter_assembly_asContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_asContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_asContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_as(s) + } +} + +func (s *Alter_assembly_asContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_as(s) + } +} + +func (s *Alter_assembly_asContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_as(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_as() (localctx IAlter_assembly_asContext) { + localctx = NewAlter_assembly_asContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 86, TSqlParserRULE_alter_assembly_as) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1847) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_with_clauseContext is an interface to support dynamic dispatch. +type IAlter_assembly_with_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_assembly_with() IAlter_assembly_withContext + Assembly_option() IAssembly_optionContext + + // IsAlter_assembly_with_clauseContext differentiates from other interfaces. + IsAlter_assembly_with_clauseContext() +} + +type Alter_assembly_with_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_with_clauseContext() *Alter_assembly_with_clauseContext { + var p = new(Alter_assembly_with_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_with_clause + return p +} + +func InitEmptyAlter_assembly_with_clauseContext(p *Alter_assembly_with_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_with_clause +} + +func (*Alter_assembly_with_clauseContext) IsAlter_assembly_with_clauseContext() {} + +func NewAlter_assembly_with_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_with_clauseContext { + var p = new(Alter_assembly_with_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_with_clause + + return p +} + +func (s *Alter_assembly_with_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_with_clauseContext) Alter_assembly_with() IAlter_assembly_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_assembly_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_assembly_withContext) +} + +func (s *Alter_assembly_with_clauseContext) Assembly_option() IAssembly_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssembly_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssembly_optionContext) +} + +func (s *Alter_assembly_with_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_with_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_with_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_with_clause(s) + } +} + +func (s *Alter_assembly_with_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_with_clause(s) + } +} + +func (s *Alter_assembly_with_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_with_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_with_clause() (localctx IAlter_assembly_with_clauseContext) { + localctx = NewAlter_assembly_with_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 88, TSqlParserRULE_alter_assembly_with_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1849) + p.Alter_assembly_with() + } + { + p.SetState(1850) + p.assembly_option(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_assembly_withContext is an interface to support dynamic dispatch. +type IAlter_assembly_withContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + + // IsAlter_assembly_withContext differentiates from other interfaces. + IsAlter_assembly_withContext() +} + +type Alter_assembly_withContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_assembly_withContext() *Alter_assembly_withContext { + var p = new(Alter_assembly_withContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_with + return p +} + +func InitEmptyAlter_assembly_withContext(p *Alter_assembly_withContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_assembly_with +} + +func (*Alter_assembly_withContext) IsAlter_assembly_withContext() {} + +func NewAlter_assembly_withContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_withContext { + var p = new(Alter_assembly_withContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_assembly_with + + return p +} + +func (s *Alter_assembly_withContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_assembly_withContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_assembly_withContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_assembly_withContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_assembly_withContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_assembly_with(s) + } +} + +func (s *Alter_assembly_withContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_assembly_with(s) + } +} + +func (s *Alter_assembly_withContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_assembly_with(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_assembly_with() (localctx IAlter_assembly_withContext) { + localctx = NewAlter_assembly_withContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 90, TSqlParserRULE_alter_assembly_with) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1852) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClient_assembly_specifierContext is an interface to support dynamic dispatch. +type IClient_assembly_specifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Network_file_share() INetwork_file_shareContext + Local_file() ILocal_fileContext + STRING() antlr.TerminalNode + + // IsClient_assembly_specifierContext differentiates from other interfaces. + IsClient_assembly_specifierContext() +} + +type Client_assembly_specifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClient_assembly_specifierContext() *Client_assembly_specifierContext { + var p = new(Client_assembly_specifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_client_assembly_specifier + return p +} + +func InitEmptyClient_assembly_specifierContext(p *Client_assembly_specifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_client_assembly_specifier +} + +func (*Client_assembly_specifierContext) IsClient_assembly_specifierContext() {} + +func NewClient_assembly_specifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Client_assembly_specifierContext { + var p = new(Client_assembly_specifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_client_assembly_specifier + + return p +} + +func (s *Client_assembly_specifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Client_assembly_specifierContext) Network_file_share() INetwork_file_shareContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INetwork_file_shareContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INetwork_file_shareContext) +} + +func (s *Client_assembly_specifierContext) Local_file() ILocal_fileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILocal_fileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILocal_fileContext) +} + +func (s *Client_assembly_specifierContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Client_assembly_specifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Client_assembly_specifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Client_assembly_specifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterClient_assembly_specifier(s) + } +} + +func (s *Client_assembly_specifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitClient_assembly_specifier(s) + } +} + +func (s *Client_assembly_specifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitClient_assembly_specifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Client_assembly_specifier() (localctx IClient_assembly_specifierContext) { + localctx = NewClient_assembly_specifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 92, TSqlParserRULE_client_assembly_specifier) + p.SetState(1857) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDOUBLE_BACK_SLASH: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1854) + p.Network_file_share() + } + + case TSqlParserDISK_DRIVE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1855) + p.Local_file() + } + + case TSqlParserSTRING: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1856) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssembly_optionContext is an interface to support dynamic dispatch. +type IAssembly_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PERMISSION_SET() antlr.TerminalNode + EQUAL() antlr.TerminalNode + SAFE() antlr.TerminalNode + EXTERNAL_ACCESS() antlr.TerminalNode + UNSAFE() antlr.TerminalNode + VISIBILITY() antlr.TerminalNode + On_off() IOn_offContext + UNCHECKED() antlr.TerminalNode + DATA() antlr.TerminalNode + Assembly_option() IAssembly_optionContext + COMMA() antlr.TerminalNode + + // IsAssembly_optionContext differentiates from other interfaces. + IsAssembly_optionContext() +} + +type Assembly_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssembly_optionContext() *Assembly_optionContext { + var p = new(Assembly_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_assembly_option + return p +} + +func InitEmptyAssembly_optionContext(p *Assembly_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_assembly_option +} + +func (*Assembly_optionContext) IsAssembly_optionContext() {} + +func NewAssembly_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assembly_optionContext { + var p = new(Assembly_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_assembly_option + + return p +} + +func (s *Assembly_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Assembly_optionContext) PERMISSION_SET() antlr.TerminalNode { + return s.GetToken(TSqlParserPERMISSION_SET, 0) +} + +func (s *Assembly_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Assembly_optionContext) SAFE() antlr.TerminalNode { + return s.GetToken(TSqlParserSAFE, 0) +} + +func (s *Assembly_optionContext) EXTERNAL_ACCESS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL_ACCESS, 0) +} + +func (s *Assembly_optionContext) UNSAFE() antlr.TerminalNode { + return s.GetToken(TSqlParserUNSAFE, 0) +} + +func (s *Assembly_optionContext) VISIBILITY() antlr.TerminalNode { + return s.GetToken(TSqlParserVISIBILITY, 0) +} + +func (s *Assembly_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Assembly_optionContext) UNCHECKED() antlr.TerminalNode { + return s.GetToken(TSqlParserUNCHECKED, 0) +} + +func (s *Assembly_optionContext) DATA() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA, 0) +} + +func (s *Assembly_optionContext) Assembly_option() IAssembly_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssembly_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssembly_optionContext) +} + +func (s *Assembly_optionContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Assembly_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Assembly_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Assembly_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAssembly_option(s) + } +} + +func (s *Assembly_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAssembly_option(s) + } +} + +func (s *Assembly_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAssembly_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Assembly_option() (localctx IAssembly_optionContext) { + return p.assembly_option(0) +} + +func (p *TSqlParser) assembly_option(_p int) (localctx IAssembly_optionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewAssembly_optionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IAssembly_optionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 94 + p.EnterRecursionRule(localctx, 94, TSqlParserRULE_assembly_option, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPERMISSION_SET: + { + p.SetState(1860) + p.Match(TSqlParserPERMISSION_SET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1861) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1862) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserEXTERNAL_ACCESS || _la == TSqlParserSAFE || _la == TSqlParserUNSAFE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserVISIBILITY: + { + p.SetState(1863) + p.Match(TSqlParserVISIBILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1864) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1865) + p.On_off() + } + + case TSqlParserUNCHECKED: + { + p.SetState(1866) + p.Match(TSqlParserUNCHECKED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1867) + p.Match(TSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(1874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 80, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewAssembly_optionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, TSqlParserRULE_assembly_option) + p.SetState(1870) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(1871) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1876) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 80, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INetwork_file_shareContext is an interface to support dynamic dispatch. +type INetwork_file_shareContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Network_file_start() INetwork_file_startContext + Network_computer() INetwork_computerContext + File_path() IFile_pathContext + + // IsNetwork_file_shareContext differentiates from other interfaces. + IsNetwork_file_shareContext() +} + +type Network_file_shareContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNetwork_file_shareContext() *Network_file_shareContext { + var p = new(Network_file_shareContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_network_file_share + return p +} + +func InitEmptyNetwork_file_shareContext(p *Network_file_shareContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_network_file_share +} + +func (*Network_file_shareContext) IsNetwork_file_shareContext() {} + +func NewNetwork_file_shareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Network_file_shareContext { + var p = new(Network_file_shareContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_network_file_share + + return p +} + +func (s *Network_file_shareContext) GetParser() antlr.Parser { return s.parser } + +func (s *Network_file_shareContext) Network_file_start() INetwork_file_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INetwork_file_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INetwork_file_startContext) +} + +func (s *Network_file_shareContext) Network_computer() INetwork_computerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INetwork_computerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INetwork_computerContext) +} + +func (s *Network_file_shareContext) File_path() IFile_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_pathContext) +} + +func (s *Network_file_shareContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Network_file_shareContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Network_file_shareContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterNetwork_file_share(s) + } +} + +func (s *Network_file_shareContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitNetwork_file_share(s) + } +} + +func (s *Network_file_shareContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitNetwork_file_share(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Network_file_share() (localctx INetwork_file_shareContext) { + localctx = NewNetwork_file_shareContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 96, TSqlParserRULE_network_file_share) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1877) + p.Network_file_start() + } + { + p.SetState(1878) + p.Network_computer() + } + { + p.SetState(1879) + p.File_path() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INetwork_computerContext is an interface to support dynamic dispatch. +type INetwork_computerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetComputer_name returns the computer_name rule contexts. + GetComputer_name() IId_Context + + // SetComputer_name sets the computer_name rule contexts. + SetComputer_name(IId_Context) + + // Getter signatures + Id_() IId_Context + + // IsNetwork_computerContext differentiates from other interfaces. + IsNetwork_computerContext() +} + +type Network_computerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + computer_name IId_Context +} + +func NewEmptyNetwork_computerContext() *Network_computerContext { + var p = new(Network_computerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_network_computer + return p +} + +func InitEmptyNetwork_computerContext(p *Network_computerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_network_computer +} + +func (*Network_computerContext) IsNetwork_computerContext() {} + +func NewNetwork_computerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Network_computerContext { + var p = new(Network_computerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_network_computer + + return p +} + +func (s *Network_computerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Network_computerContext) GetComputer_name() IId_Context { return s.computer_name } + +func (s *Network_computerContext) SetComputer_name(v IId_Context) { s.computer_name = v } + +func (s *Network_computerContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Network_computerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Network_computerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Network_computerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterNetwork_computer(s) + } +} + +func (s *Network_computerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitNetwork_computer(s) + } +} + +func (s *Network_computerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitNetwork_computer(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Network_computer() (localctx INetwork_computerContext) { + localctx = NewNetwork_computerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 98, TSqlParserRULE_network_computer) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1881) + + var _x = p.Id_() + + localctx.(*Network_computerContext).computer_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INetwork_file_startContext is an interface to support dynamic dispatch. +type INetwork_file_startContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DOUBLE_BACK_SLASH() antlr.TerminalNode + + // IsNetwork_file_startContext differentiates from other interfaces. + IsNetwork_file_startContext() +} + +type Network_file_startContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNetwork_file_startContext() *Network_file_startContext { + var p = new(Network_file_startContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_network_file_start + return p +} + +func InitEmptyNetwork_file_startContext(p *Network_file_startContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_network_file_start +} + +func (*Network_file_startContext) IsNetwork_file_startContext() {} + +func NewNetwork_file_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Network_file_startContext { + var p = new(Network_file_startContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_network_file_start + + return p +} + +func (s *Network_file_startContext) GetParser() antlr.Parser { return s.parser } + +func (s *Network_file_startContext) DOUBLE_BACK_SLASH() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_BACK_SLASH, 0) +} + +func (s *Network_file_startContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Network_file_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Network_file_startContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterNetwork_file_start(s) + } +} + +func (s *Network_file_startContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitNetwork_file_start(s) + } +} + +func (s *Network_file_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitNetwork_file_start(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Network_file_start() (localctx INetwork_file_startContext) { + localctx = NewNetwork_file_startContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 100, TSqlParserRULE_network_file_start) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1883) + p.Match(TSqlParserDOUBLE_BACK_SLASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFile_pathContext is an interface to support dynamic dispatch. +type IFile_pathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + File_directory_path_separator() IFile_directory_path_separatorContext + File_path() IFile_pathContext + Id_() IId_Context + + // IsFile_pathContext differentiates from other interfaces. + IsFile_pathContext() +} + +type File_pathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_pathContext() *File_pathContext { + var p = new(File_pathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_file_path + return p +} + +func InitEmptyFile_pathContext(p *File_pathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_file_path +} + +func (*File_pathContext) IsFile_pathContext() {} + +func NewFile_pathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_pathContext { + var p = new(File_pathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_file_path + + return p +} + +func (s *File_pathContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_pathContext) File_directory_path_separator() IFile_directory_path_separatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_directory_path_separatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_directory_path_separatorContext) +} + +func (s *File_pathContext) File_path() IFile_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_pathContext) +} + +func (s *File_pathContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *File_pathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_pathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_pathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFile_path(s) + } +} + +func (s *File_pathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFile_path(s) + } +} + +func (s *File_pathContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFile_path(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) File_path() (localctx IFile_pathContext) { + localctx = NewFile_pathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 102, TSqlParserRULE_file_path) + p.SetState(1889) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserBACKSLASH: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1885) + p.File_directory_path_separator() + } + { + p.SetState(1886) + p.File_path() + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1888) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFile_directory_path_separatorContext is an interface to support dynamic dispatch. +type IFile_directory_path_separatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BACKSLASH() antlr.TerminalNode + + // IsFile_directory_path_separatorContext differentiates from other interfaces. + IsFile_directory_path_separatorContext() +} + +type File_directory_path_separatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_directory_path_separatorContext() *File_directory_path_separatorContext { + var p = new(File_directory_path_separatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_file_directory_path_separator + return p +} + +func InitEmptyFile_directory_path_separatorContext(p *File_directory_path_separatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_file_directory_path_separator +} + +func (*File_directory_path_separatorContext) IsFile_directory_path_separatorContext() {} + +func NewFile_directory_path_separatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_directory_path_separatorContext { + var p = new(File_directory_path_separatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_file_directory_path_separator + + return p +} + +func (s *File_directory_path_separatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_directory_path_separatorContext) BACKSLASH() antlr.TerminalNode { + return s.GetToken(TSqlParserBACKSLASH, 0) +} + +func (s *File_directory_path_separatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_directory_path_separatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_directory_path_separatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFile_directory_path_separator(s) + } +} + +func (s *File_directory_path_separatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFile_directory_path_separator(s) + } +} + +func (s *File_directory_path_separatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFile_directory_path_separator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) File_directory_path_separator() (localctx IFile_directory_path_separatorContext) { + localctx = NewFile_directory_path_separatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 104, TSqlParserRULE_file_directory_path_separator) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1891) + p.Match(TSqlParserBACKSLASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILocal_fileContext is an interface to support dynamic dispatch. +type ILocal_fileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Local_drive() ILocal_driveContext + File_path() IFile_pathContext + + // IsLocal_fileContext differentiates from other interfaces. + IsLocal_fileContext() +} + +type Local_fileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLocal_fileContext() *Local_fileContext { + var p = new(Local_fileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_local_file + return p +} + +func InitEmptyLocal_fileContext(p *Local_fileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_local_file +} + +func (*Local_fileContext) IsLocal_fileContext() {} + +func NewLocal_fileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Local_fileContext { + var p = new(Local_fileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_local_file + + return p +} + +func (s *Local_fileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Local_fileContext) Local_drive() ILocal_driveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILocal_driveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILocal_driveContext) +} + +func (s *Local_fileContext) File_path() IFile_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_pathContext) +} + +func (s *Local_fileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Local_fileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Local_fileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterLocal_file(s) + } +} + +func (s *Local_fileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitLocal_file(s) + } +} + +func (s *Local_fileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitLocal_file(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Local_file() (localctx ILocal_fileContext) { + localctx = NewLocal_fileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 106, TSqlParserRULE_local_file) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1893) + p.Local_drive() + } + { + p.SetState(1894) + p.File_path() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILocal_driveContext is an interface to support dynamic dispatch. +type ILocal_driveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DISK_DRIVE() antlr.TerminalNode + + // IsLocal_driveContext differentiates from other interfaces. + IsLocal_driveContext() +} + +type Local_driveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLocal_driveContext() *Local_driveContext { + var p = new(Local_driveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_local_drive + return p +} + +func InitEmptyLocal_driveContext(p *Local_driveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_local_drive +} + +func (*Local_driveContext) IsLocal_driveContext() {} + +func NewLocal_driveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Local_driveContext { + var p = new(Local_driveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_local_drive + + return p +} + +func (s *Local_driveContext) GetParser() antlr.Parser { return s.parser } + +func (s *Local_driveContext) DISK_DRIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserDISK_DRIVE, 0) +} + +func (s *Local_driveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Local_driveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Local_driveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterLocal_drive(s) + } +} + +func (s *Local_driveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitLocal_drive(s) + } +} + +func (s *Local_driveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitLocal_drive(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Local_drive() (localctx ILocal_driveContext) { + localctx = NewLocal_driveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 108, TSqlParserRULE_local_drive) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1896) + p.Match(TSqlParserDISK_DRIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMultiple_local_filesContext is an interface to support dynamic dispatch. +type IMultiple_local_filesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Multiple_local_file_start() IMultiple_local_file_startContext + Local_file() ILocal_fileContext + SINGLE_QUOTE() antlr.TerminalNode + COMMA() antlr.TerminalNode + + // IsMultiple_local_filesContext differentiates from other interfaces. + IsMultiple_local_filesContext() +} + +type Multiple_local_filesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMultiple_local_filesContext() *Multiple_local_filesContext { + var p = new(Multiple_local_filesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_multiple_local_files + return p +} + +func InitEmptyMultiple_local_filesContext(p *Multiple_local_filesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_multiple_local_files +} + +func (*Multiple_local_filesContext) IsMultiple_local_filesContext() {} + +func NewMultiple_local_filesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Multiple_local_filesContext { + var p = new(Multiple_local_filesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_multiple_local_files + + return p +} + +func (s *Multiple_local_filesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Multiple_local_filesContext) Multiple_local_file_start() IMultiple_local_file_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiple_local_file_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultiple_local_file_startContext) +} + +func (s *Multiple_local_filesContext) Local_file() ILocal_fileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILocal_fileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILocal_fileContext) +} + +func (s *Multiple_local_filesContext) SINGLE_QUOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserSINGLE_QUOTE, 0) +} + +func (s *Multiple_local_filesContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Multiple_local_filesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Multiple_local_filesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Multiple_local_filesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMultiple_local_files(s) + } +} + +func (s *Multiple_local_filesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMultiple_local_files(s) + } +} + +func (s *Multiple_local_filesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMultiple_local_files(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Multiple_local_files() (localctx IMultiple_local_filesContext) { + localctx = NewMultiple_local_filesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 110, TSqlParserRULE_multiple_local_files) + p.SetState(1904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSINGLE_QUOTE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1898) + p.Multiple_local_file_start() + } + { + p.SetState(1899) + p.Local_file() + } + { + p.SetState(1900) + p.Match(TSqlParserSINGLE_QUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1901) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDISK_DRIVE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1903) + p.Local_file() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMultiple_local_file_startContext is an interface to support dynamic dispatch. +type IMultiple_local_file_startContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SINGLE_QUOTE() antlr.TerminalNode + + // IsMultiple_local_file_startContext differentiates from other interfaces. + IsMultiple_local_file_startContext() +} + +type Multiple_local_file_startContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMultiple_local_file_startContext() *Multiple_local_file_startContext { + var p = new(Multiple_local_file_startContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_multiple_local_file_start + return p +} + +func InitEmptyMultiple_local_file_startContext(p *Multiple_local_file_startContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_multiple_local_file_start +} + +func (*Multiple_local_file_startContext) IsMultiple_local_file_startContext() {} + +func NewMultiple_local_file_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Multiple_local_file_startContext { + var p = new(Multiple_local_file_startContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_multiple_local_file_start + + return p +} + +func (s *Multiple_local_file_startContext) GetParser() antlr.Parser { return s.parser } + +func (s *Multiple_local_file_startContext) SINGLE_QUOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserSINGLE_QUOTE, 0) +} + +func (s *Multiple_local_file_startContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Multiple_local_file_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Multiple_local_file_startContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMultiple_local_file_start(s) + } +} + +func (s *Multiple_local_file_startContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMultiple_local_file_start(s) + } +} + +func (s *Multiple_local_file_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMultiple_local_file_start(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Multiple_local_file_start() (localctx IMultiple_local_file_startContext) { + localctx = NewMultiple_local_file_startContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 112, TSqlParserRULE_multiple_local_file_start) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1906) + p.Match(TSqlParserSINGLE_QUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_assemblyContext is an interface to support dynamic dispatch. +type ICreate_assemblyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAssembly_name returns the assembly_name rule contexts. + GetAssembly_name() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // SetAssembly_name sets the assembly_name rule contexts. + SetAssembly_name(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + ASSEMBLY() antlr.TerminalNode + FROM() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AUTHORIZATION() antlr.TerminalNode + WITH() antlr.TerminalNode + PERMISSION_SET() antlr.TerminalNode + EQUAL() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllBINARY() []antlr.TerminalNode + BINARY(i int) antlr.TerminalNode + SAFE() antlr.TerminalNode + EXTERNAL_ACCESS() antlr.TerminalNode + UNSAFE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_assemblyContext differentiates from other interfaces. + IsCreate_assemblyContext() +} + +type Create_assemblyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + assembly_name IId_Context + owner_name IId_Context +} + +func NewEmptyCreate_assemblyContext() *Create_assemblyContext { + var p = new(Create_assemblyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_assembly + return p +} + +func InitEmptyCreate_assemblyContext(p *Create_assemblyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_assembly +} + +func (*Create_assemblyContext) IsCreate_assemblyContext() {} + +func NewCreate_assemblyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_assemblyContext { + var p = new(Create_assemblyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_assembly + + return p +} + +func (s *Create_assemblyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_assemblyContext) GetAssembly_name() IId_Context { return s.assembly_name } + +func (s *Create_assemblyContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Create_assemblyContext) SetAssembly_name(v IId_Context) { s.assembly_name = v } + +func (s *Create_assemblyContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Create_assemblyContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_assemblyContext) ASSEMBLY() antlr.TerminalNode { + return s.GetToken(TSqlParserASSEMBLY, 0) +} + +func (s *Create_assemblyContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Create_assemblyContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_assemblyContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_assemblyContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_assemblyContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_assemblyContext) PERMISSION_SET() antlr.TerminalNode { + return s.GetToken(TSqlParserPERMISSION_SET, 0) +} + +func (s *Create_assemblyContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_assemblyContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Create_assemblyContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Create_assemblyContext) AllBINARY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBINARY) +} + +func (s *Create_assemblyContext) BINARY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY, i) +} + +func (s *Create_assemblyContext) SAFE() antlr.TerminalNode { + return s.GetToken(TSqlParserSAFE, 0) +} + +func (s *Create_assemblyContext) EXTERNAL_ACCESS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL_ACCESS, 0) +} + +func (s *Create_assemblyContext) UNSAFE() antlr.TerminalNode { + return s.GetToken(TSqlParserUNSAFE, 0) +} + +func (s *Create_assemblyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_assemblyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_assemblyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_assemblyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_assemblyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_assembly(s) + } +} + +func (s *Create_assemblyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_assembly(s) + } +} + +func (s *Create_assemblyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_assembly(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_assembly() (localctx ICreate_assemblyContext) { + localctx = NewCreate_assemblyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 114, TSqlParserRULE_create_assembly) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1908) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1909) + p.Match(TSqlParserASSEMBLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1910) + + var _x = p.Id_() + + localctx.(*Create_assemblyContext).assembly_name = _x + } + p.SetState(1913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(1911) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1912) + + var _x = p.Id_() + + localctx.(*Create_assemblyContext).owner_name = _x + } + + } + { + p.SetState(1915) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1920) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-1184)) & ^0x3f) == 0 && ((int64(1)<<(_la-1184))&16777219) != 0) { + p.SetState(1917) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(1916) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1919) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserSTRING || _la == TSqlParserBINARY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + p.SetState(1922) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(1928) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 86, p.GetParserRuleContext()) == 1 { + { + p.SetState(1924) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1925) + p.Match(TSqlParserPERMISSION_SET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1926) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1927) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserEXTERNAL_ACCESS || _la == TSqlParserSAFE || _la == TSqlParserUNSAFE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_assemblyContext is an interface to support dynamic dispatch. +type IDrop_assemblyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAssembly_name returns the assembly_name rule contexts. + GetAssembly_name() IId_Context + + // SetAssembly_name sets the assembly_name rule contexts. + SetAssembly_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + ASSEMBLY() antlr.TerminalNode + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + WITH() antlr.TerminalNode + NO() antlr.TerminalNode + DEPENDENTS() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDrop_assemblyContext differentiates from other interfaces. + IsDrop_assemblyContext() +} + +type Drop_assemblyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + assembly_name IId_Context +} + +func NewEmptyDrop_assemblyContext() *Drop_assemblyContext { + var p = new(Drop_assemblyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_assembly + return p +} + +func InitEmptyDrop_assemblyContext(p *Drop_assemblyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_assembly +} + +func (*Drop_assemblyContext) IsDrop_assemblyContext() {} + +func NewDrop_assemblyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_assemblyContext { + var p = new(Drop_assemblyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_assembly + + return p +} + +func (s *Drop_assemblyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_assemblyContext) GetAssembly_name() IId_Context { return s.assembly_name } + +func (s *Drop_assemblyContext) SetAssembly_name(v IId_Context) { s.assembly_name = v } + +func (s *Drop_assemblyContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_assemblyContext) ASSEMBLY() antlr.TerminalNode { + return s.GetToken(TSqlParserASSEMBLY, 0) +} + +func (s *Drop_assemblyContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_assemblyContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_assemblyContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Drop_assemblyContext) NO() antlr.TerminalNode { + return s.GetToken(TSqlParserNO, 0) +} + +func (s *Drop_assemblyContext) DEPENDENTS() antlr.TerminalNode { + return s.GetToken(TSqlParserDEPENDENTS, 0) +} + +func (s *Drop_assemblyContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_assemblyContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_assemblyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Drop_assemblyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Drop_assemblyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_assemblyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_assemblyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_assembly(s) + } +} + +func (s *Drop_assemblyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_assembly(s) + } +} + +func (s *Drop_assemblyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_assembly(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_assembly() (localctx IDrop_assemblyContext) { + localctx = NewDrop_assemblyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 116, TSqlParserRULE_drop_assembly) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1930) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1931) + p.Match(TSqlParserASSEMBLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(1932) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1933) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1940) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(1937) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(1936) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1939) + + var _x = p.Id_() + + localctx.(*Drop_assemblyContext).assembly_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(1942) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 89, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(1947) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 90, p.GetParserRuleContext()) == 1 { + { + p.SetState(1944) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1945) + p.Match(TSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1946) + p.Match(TSqlParserDEPENDENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_asymmetric_keyContext is an interface to support dynamic dispatch. +type IAlter_asymmetric_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAsym_Key_Name returns the Asym_Key_Name rule contexts. + GetAsym_Key_Name() IId_Context + + // SetAsym_Key_Name sets the Asym_Key_Name rule contexts. + SetAsym_Key_Name(IId_Context) + + // Getter signatures + Alter_asymmetric_key_start() IAlter_asymmetric_key_startContext + Id_() IId_Context + Asymmetric_key_option() IAsymmetric_key_optionContext + REMOVE() antlr.TerminalNode + PRIVATE() antlr.TerminalNode + KEY() antlr.TerminalNode + + // IsAlter_asymmetric_keyContext differentiates from other interfaces. + IsAlter_asymmetric_keyContext() +} + +type Alter_asymmetric_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + Asym_Key_Name IId_Context +} + +func NewEmptyAlter_asymmetric_keyContext() *Alter_asymmetric_keyContext { + var p = new(Alter_asymmetric_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_asymmetric_key + return p +} + +func InitEmptyAlter_asymmetric_keyContext(p *Alter_asymmetric_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_asymmetric_key +} + +func (*Alter_asymmetric_keyContext) IsAlter_asymmetric_keyContext() {} + +func NewAlter_asymmetric_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_asymmetric_keyContext { + var p = new(Alter_asymmetric_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_asymmetric_key + + return p +} + +func (s *Alter_asymmetric_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_asymmetric_keyContext) GetAsym_Key_Name() IId_Context { return s.Asym_Key_Name } + +func (s *Alter_asymmetric_keyContext) SetAsym_Key_Name(v IId_Context) { s.Asym_Key_Name = v } + +func (s *Alter_asymmetric_keyContext) Alter_asymmetric_key_start() IAlter_asymmetric_key_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_asymmetric_key_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_asymmetric_key_startContext) +} + +func (s *Alter_asymmetric_keyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_asymmetric_keyContext) Asymmetric_key_option() IAsymmetric_key_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAsymmetric_key_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAsymmetric_key_optionContext) +} + +func (s *Alter_asymmetric_keyContext) REMOVE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOVE, 0) +} + +func (s *Alter_asymmetric_keyContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIVATE, 0) +} + +func (s *Alter_asymmetric_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Alter_asymmetric_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_asymmetric_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_asymmetric_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_asymmetric_key(s) + } +} + +func (s *Alter_asymmetric_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_asymmetric_key(s) + } +} + +func (s *Alter_asymmetric_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_asymmetric_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_asymmetric_key() (localctx IAlter_asymmetric_keyContext) { + localctx = NewAlter_asymmetric_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 118, TSqlParserRULE_alter_asymmetric_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1949) + p.Alter_asymmetric_key_start() + } + { + p.SetState(1950) + + var _x = p.Id_() + + localctx.(*Alter_asymmetric_keyContext).Asym_Key_Name = _x + } + p.SetState(1955) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserWITH: + { + p.SetState(1951) + p.Asymmetric_key_option() + } + + case TSqlParserREMOVE: + { + p.SetState(1952) + p.Match(TSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1953) + p.Match(TSqlParserPRIVATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1954) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_asymmetric_key_startContext is an interface to support dynamic dispatch. +type IAlter_asymmetric_key_startContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + ASYMMETRIC() antlr.TerminalNode + KEY() antlr.TerminalNode + + // IsAlter_asymmetric_key_startContext differentiates from other interfaces. + IsAlter_asymmetric_key_startContext() +} + +type Alter_asymmetric_key_startContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_asymmetric_key_startContext() *Alter_asymmetric_key_startContext { + var p = new(Alter_asymmetric_key_startContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_asymmetric_key_start + return p +} + +func InitEmptyAlter_asymmetric_key_startContext(p *Alter_asymmetric_key_startContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_asymmetric_key_start +} + +func (*Alter_asymmetric_key_startContext) IsAlter_asymmetric_key_startContext() {} + +func NewAlter_asymmetric_key_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_asymmetric_key_startContext { + var p = new(Alter_asymmetric_key_startContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_asymmetric_key_start + + return p +} + +func (s *Alter_asymmetric_key_startContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_asymmetric_key_startContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_asymmetric_key_startContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, 0) +} + +func (s *Alter_asymmetric_key_startContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Alter_asymmetric_key_startContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_asymmetric_key_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_asymmetric_key_startContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_asymmetric_key_start(s) + } +} + +func (s *Alter_asymmetric_key_startContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_asymmetric_key_start(s) + } +} + +func (s *Alter_asymmetric_key_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_asymmetric_key_start(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_asymmetric_key_start() (localctx IAlter_asymmetric_key_startContext) { + localctx = NewAlter_asymmetric_key_startContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 120, TSqlParserRULE_alter_asymmetric_key_start) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1957) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1958) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1959) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAsymmetric_key_optionContext is an interface to support dynamic dispatch. +type IAsymmetric_key_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Asymmetric_key_option_start() IAsymmetric_key_option_startContext + AllAsymmetric_key_password_change_option() []IAsymmetric_key_password_change_optionContext + Asymmetric_key_password_change_option(i int) IAsymmetric_key_password_change_optionContext + RR_BRACKET() antlr.TerminalNode + COMMA() antlr.TerminalNode + + // IsAsymmetric_key_optionContext differentiates from other interfaces. + IsAsymmetric_key_optionContext() +} + +type Asymmetric_key_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAsymmetric_key_optionContext() *Asymmetric_key_optionContext { + var p = new(Asymmetric_key_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_asymmetric_key_option + return p +} + +func InitEmptyAsymmetric_key_optionContext(p *Asymmetric_key_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_asymmetric_key_option +} + +func (*Asymmetric_key_optionContext) IsAsymmetric_key_optionContext() {} + +func NewAsymmetric_key_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Asymmetric_key_optionContext { + var p = new(Asymmetric_key_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_asymmetric_key_option + + return p +} + +func (s *Asymmetric_key_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Asymmetric_key_optionContext) Asymmetric_key_option_start() IAsymmetric_key_option_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAsymmetric_key_option_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAsymmetric_key_option_startContext) +} + +func (s *Asymmetric_key_optionContext) AllAsymmetric_key_password_change_option() []IAsymmetric_key_password_change_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAsymmetric_key_password_change_optionContext); ok { + len++ + } + } + + tst := make([]IAsymmetric_key_password_change_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAsymmetric_key_password_change_optionContext); ok { + tst[i] = t.(IAsymmetric_key_password_change_optionContext) + i++ + } + } + + return tst +} + +func (s *Asymmetric_key_optionContext) Asymmetric_key_password_change_option(i int) IAsymmetric_key_password_change_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAsymmetric_key_password_change_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAsymmetric_key_password_change_optionContext) +} + +func (s *Asymmetric_key_optionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Asymmetric_key_optionContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Asymmetric_key_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Asymmetric_key_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Asymmetric_key_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAsymmetric_key_option(s) + } +} + +func (s *Asymmetric_key_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAsymmetric_key_option(s) + } +} + +func (s *Asymmetric_key_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAsymmetric_key_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Asymmetric_key_option() (localctx IAsymmetric_key_optionContext) { + localctx = NewAsymmetric_key_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 122, TSqlParserRULE_asymmetric_key_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1961) + p.Asymmetric_key_option_start() + } + { + p.SetState(1962) + p.Asymmetric_key_password_change_option() + } + p.SetState(1965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(1963) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1964) + p.Asymmetric_key_password_change_option() + } + + } + { + p.SetState(1967) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAsymmetric_key_option_startContext is an interface to support dynamic dispatch. +type IAsymmetric_key_option_startContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + PRIVATE() antlr.TerminalNode + KEY() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + + // IsAsymmetric_key_option_startContext differentiates from other interfaces. + IsAsymmetric_key_option_startContext() +} + +type Asymmetric_key_option_startContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAsymmetric_key_option_startContext() *Asymmetric_key_option_startContext { + var p = new(Asymmetric_key_option_startContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_asymmetric_key_option_start + return p +} + +func InitEmptyAsymmetric_key_option_startContext(p *Asymmetric_key_option_startContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_asymmetric_key_option_start +} + +func (*Asymmetric_key_option_startContext) IsAsymmetric_key_option_startContext() {} + +func NewAsymmetric_key_option_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Asymmetric_key_option_startContext { + var p = new(Asymmetric_key_option_startContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_asymmetric_key_option_start + + return p +} + +func (s *Asymmetric_key_option_startContext) GetParser() antlr.Parser { return s.parser } + +func (s *Asymmetric_key_option_startContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Asymmetric_key_option_startContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIVATE, 0) +} + +func (s *Asymmetric_key_option_startContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Asymmetric_key_option_startContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Asymmetric_key_option_startContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Asymmetric_key_option_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Asymmetric_key_option_startContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAsymmetric_key_option_start(s) + } +} + +func (s *Asymmetric_key_option_startContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAsymmetric_key_option_start(s) + } +} + +func (s *Asymmetric_key_option_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAsymmetric_key_option_start(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Asymmetric_key_option_start() (localctx IAsymmetric_key_option_startContext) { + localctx = NewAsymmetric_key_option_startContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 124, TSqlParserRULE_asymmetric_key_option_start) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1969) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1970) + p.Match(TSqlParserPRIVATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1971) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1972) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAsymmetric_key_password_change_optionContext is an interface to support dynamic dispatch. +type IAsymmetric_key_password_change_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECRYPTION() antlr.TerminalNode + BY() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + EQUAL() antlr.TerminalNode + STRING() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + + // IsAsymmetric_key_password_change_optionContext differentiates from other interfaces. + IsAsymmetric_key_password_change_optionContext() +} + +type Asymmetric_key_password_change_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAsymmetric_key_password_change_optionContext() *Asymmetric_key_password_change_optionContext { + var p = new(Asymmetric_key_password_change_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_asymmetric_key_password_change_option + return p +} + +func InitEmptyAsymmetric_key_password_change_optionContext(p *Asymmetric_key_password_change_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_asymmetric_key_password_change_option +} + +func (*Asymmetric_key_password_change_optionContext) IsAsymmetric_key_password_change_optionContext() { +} + +func NewAsymmetric_key_password_change_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Asymmetric_key_password_change_optionContext { + var p = new(Asymmetric_key_password_change_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_asymmetric_key_password_change_option + + return p +} + +func (s *Asymmetric_key_password_change_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Asymmetric_key_password_change_optionContext) DECRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserDECRYPTION, 0) +} + +func (s *Asymmetric_key_password_change_optionContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Asymmetric_key_password_change_optionContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Asymmetric_key_password_change_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Asymmetric_key_password_change_optionContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Asymmetric_key_password_change_optionContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Asymmetric_key_password_change_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Asymmetric_key_password_change_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Asymmetric_key_password_change_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAsymmetric_key_password_change_option(s) + } +} + +func (s *Asymmetric_key_password_change_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAsymmetric_key_password_change_option(s) + } +} + +func (s *Asymmetric_key_password_change_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAsymmetric_key_password_change_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Asymmetric_key_password_change_option() (localctx IAsymmetric_key_password_change_optionContext) { + localctx = NewAsymmetric_key_password_change_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 126, TSqlParserRULE_asymmetric_key_password_change_option) + p.SetState(1984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECRYPTION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1974) + p.Match(TSqlParserDECRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1975) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1976) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1977) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1978) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserENCRYPTION: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1979) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1980) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1981) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1982) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1983) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_asymmetric_keyContext is an interface to support dynamic dispatch. +type ICreate_asymmetric_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetProvider_key_name returns the provider_key_name token. + GetProvider_key_name() antlr.Token + + // GetAsymmetric_key_password returns the asymmetric_key_password token. + GetAsymmetric_key_password() antlr.Token + + // SetProvider_key_name sets the provider_key_name token. + SetProvider_key_name(antlr.Token) + + // SetAsymmetric_key_password sets the asymmetric_key_password token. + SetAsymmetric_key_password(antlr.Token) + + // GetAsym_Key_Nam returns the Asym_Key_Nam rule contexts. + GetAsym_Key_Nam() IId_Context + + // GetDatabase_principal_name returns the database_principal_name rule contexts. + GetDatabase_principal_name() IId_Context + + // GetAssembly_Name returns the Assembly_Name rule contexts. + GetAssembly_Name() IId_Context + + // GetProvider_Name returns the Provider_Name rule contexts. + GetProvider_Name() IId_Context + + // SetAsym_Key_Nam sets the Asym_Key_Nam rule contexts. + SetAsym_Key_Nam(IId_Context) + + // SetDatabase_principal_name sets the database_principal_name rule contexts. + SetDatabase_principal_name(IId_Context) + + // SetAssembly_Name sets the Assembly_Name rule contexts. + SetAssembly_Name(IId_Context) + + // SetProvider_Name sets the Provider_Name rule contexts. + SetProvider_Name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + ASYMMETRIC() antlr.TerminalNode + KEY() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AUTHORIZATION() antlr.TerminalNode + FROM() antlr.TerminalNode + WITH() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + BY() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + FILE() antlr.TerminalNode + EXECUTABLE_FILE() antlr.TerminalNode + ASSEMBLY() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + ALGORITHM() antlr.TerminalNode + PROVIDER_KEY_NAME() antlr.TerminalNode + CREATION_DISPOSITION() antlr.TerminalNode + RSA_4096() antlr.TerminalNode + RSA_3072() antlr.TerminalNode + RSA_2048() antlr.TerminalNode + RSA_1024() antlr.TerminalNode + RSA_512() antlr.TerminalNode + CREATE_NEW() antlr.TerminalNode + OPEN_EXISTING() antlr.TerminalNode + + // IsCreate_asymmetric_keyContext differentiates from other interfaces. + IsCreate_asymmetric_keyContext() +} + +type Create_asymmetric_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + Asym_Key_Nam IId_Context + database_principal_name IId_Context + Assembly_Name IId_Context + Provider_Name IId_Context + provider_key_name antlr.Token + asymmetric_key_password antlr.Token +} + +func NewEmptyCreate_asymmetric_keyContext() *Create_asymmetric_keyContext { + var p = new(Create_asymmetric_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_asymmetric_key + return p +} + +func InitEmptyCreate_asymmetric_keyContext(p *Create_asymmetric_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_asymmetric_key +} + +func (*Create_asymmetric_keyContext) IsCreate_asymmetric_keyContext() {} + +func NewCreate_asymmetric_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_asymmetric_keyContext { + var p = new(Create_asymmetric_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_asymmetric_key + + return p +} + +func (s *Create_asymmetric_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_asymmetric_keyContext) GetProvider_key_name() antlr.Token { return s.provider_key_name } + +func (s *Create_asymmetric_keyContext) GetAsymmetric_key_password() antlr.Token { + return s.asymmetric_key_password +} + +func (s *Create_asymmetric_keyContext) SetProvider_key_name(v antlr.Token) { s.provider_key_name = v } + +func (s *Create_asymmetric_keyContext) SetAsymmetric_key_password(v antlr.Token) { + s.asymmetric_key_password = v +} + +func (s *Create_asymmetric_keyContext) GetAsym_Key_Nam() IId_Context { return s.Asym_Key_Nam } + +func (s *Create_asymmetric_keyContext) GetDatabase_principal_name() IId_Context { + return s.database_principal_name +} + +func (s *Create_asymmetric_keyContext) GetAssembly_Name() IId_Context { return s.Assembly_Name } + +func (s *Create_asymmetric_keyContext) GetProvider_Name() IId_Context { return s.Provider_Name } + +func (s *Create_asymmetric_keyContext) SetAsym_Key_Nam(v IId_Context) { s.Asym_Key_Nam = v } + +func (s *Create_asymmetric_keyContext) SetDatabase_principal_name(v IId_Context) { + s.database_principal_name = v +} + +func (s *Create_asymmetric_keyContext) SetAssembly_Name(v IId_Context) { s.Assembly_Name = v } + +func (s *Create_asymmetric_keyContext) SetProvider_Name(v IId_Context) { s.Provider_Name = v } + +func (s *Create_asymmetric_keyContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_asymmetric_keyContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, 0) +} + +func (s *Create_asymmetric_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Create_asymmetric_keyContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_asymmetric_keyContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_asymmetric_keyContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_asymmetric_keyContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Create_asymmetric_keyContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_asymmetric_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Create_asymmetric_keyContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Create_asymmetric_keyContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Create_asymmetric_keyContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_asymmetric_keyContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_asymmetric_keyContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Create_asymmetric_keyContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Create_asymmetric_keyContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Create_asymmetric_keyContext) EXECUTABLE_FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXECUTABLE_FILE, 0) +} + +func (s *Create_asymmetric_keyContext) ASSEMBLY() antlr.TerminalNode { + return s.GetToken(TSqlParserASSEMBLY, 0) +} + +func (s *Create_asymmetric_keyContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER, 0) +} + +func (s *Create_asymmetric_keyContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(TSqlParserALGORITHM, 0) +} + +func (s *Create_asymmetric_keyContext) PROVIDER_KEY_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER_KEY_NAME, 0) +} + +func (s *Create_asymmetric_keyContext) CREATION_DISPOSITION() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATION_DISPOSITION, 0) +} + +func (s *Create_asymmetric_keyContext) RSA_4096() antlr.TerminalNode { + return s.GetToken(TSqlParserRSA_4096, 0) +} + +func (s *Create_asymmetric_keyContext) RSA_3072() antlr.TerminalNode { + return s.GetToken(TSqlParserRSA_3072, 0) +} + +func (s *Create_asymmetric_keyContext) RSA_2048() antlr.TerminalNode { + return s.GetToken(TSqlParserRSA_2048, 0) +} + +func (s *Create_asymmetric_keyContext) RSA_1024() antlr.TerminalNode { + return s.GetToken(TSqlParserRSA_1024, 0) +} + +func (s *Create_asymmetric_keyContext) RSA_512() antlr.TerminalNode { + return s.GetToken(TSqlParserRSA_512, 0) +} + +func (s *Create_asymmetric_keyContext) CREATE_NEW() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE_NEW, 0) +} + +func (s *Create_asymmetric_keyContext) OPEN_EXISTING() antlr.TerminalNode { + return s.GetToken(TSqlParserOPEN_EXISTING, 0) +} + +func (s *Create_asymmetric_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_asymmetric_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_asymmetric_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_asymmetric_key(s) + } +} + +func (s *Create_asymmetric_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_asymmetric_key(s) + } +} + +func (s *Create_asymmetric_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_asymmetric_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_asymmetric_key() (localctx ICreate_asymmetric_keyContext) { + localctx = NewCreate_asymmetric_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 128, TSqlParserRULE_create_asymmetric_key) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1986) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1987) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1988) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1989) + + var _x = p.Id_() + + localctx.(*Create_asymmetric_keyContext).Asym_Key_Nam = _x + } + p.SetState(1992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(1990) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1991) + + var _x = p.Id_() + + localctx.(*Create_asymmetric_keyContext).database_principal_name = _x + } + + } + p.SetState(2007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFROM { + { + p.SetState(1994) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2005) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFILE: + { + p.SetState(1995) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1996) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1997) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEXECUTABLE_FILE: + { + p.SetState(1998) + p.Match(TSqlParserEXECUTABLE_FILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1999) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2000) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserASSEMBLY: + { + p.SetState(2001) + p.Match(TSqlParserASSEMBLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2002) + + var _x = p.Id_() + + localctx.(*Create_asymmetric_keyContext).Assembly_Name = _x + } + + case TSqlParserPROVIDER: + { + p.SetState(2003) + p.Match(TSqlParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2004) + + var _x = p.Id_() + + localctx.(*Create_asymmetric_keyContext).Provider_Name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(2021) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 98, p.GetParserRuleContext()) == 1 { + { + p.SetState(2009) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALGORITHM: + { + p.SetState(2010) + p.Match(TSqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2011) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2012) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-845)) & ^0x3f) == 0 && ((int64(1)<<(_la-845))&31) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserPROVIDER_KEY_NAME: + { + p.SetState(2013) + p.Match(TSqlParserPROVIDER_KEY_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2014) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2015) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_asymmetric_keyContext).provider_key_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCREATION_DISPOSITION: + { + p.SetState(2016) + p.Match(TSqlParserCREATION_DISPOSITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2017) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2018) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCREATE_NEW || _la == TSqlParserOPEN_EXISTING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2028) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 99, p.GetParserRuleContext()) == 1 { + { + p.SetState(2023) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2024) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2025) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2026) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2027) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_asymmetric_keyContext).asymmetric_key_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_asymmetric_keyContext is an interface to support dynamic dispatch. +type IDrop_asymmetric_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKey_name returns the key_name rule contexts. + GetKey_name() IId_Context + + // SetKey_name sets the key_name rule contexts. + SetKey_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + ASYMMETRIC() antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + Id_() IId_Context + REMOVE() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + + // IsDrop_asymmetric_keyContext differentiates from other interfaces. + IsDrop_asymmetric_keyContext() +} + +type Drop_asymmetric_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + key_name IId_Context +} + +func NewEmptyDrop_asymmetric_keyContext() *Drop_asymmetric_keyContext { + var p = new(Drop_asymmetric_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_asymmetric_key + return p +} + +func InitEmptyDrop_asymmetric_keyContext(p *Drop_asymmetric_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_asymmetric_key +} + +func (*Drop_asymmetric_keyContext) IsDrop_asymmetric_keyContext() {} + +func NewDrop_asymmetric_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_asymmetric_keyContext { + var p = new(Drop_asymmetric_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_asymmetric_key + + return p +} + +func (s *Drop_asymmetric_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_asymmetric_keyContext) GetKey_name() IId_Context { return s.key_name } + +func (s *Drop_asymmetric_keyContext) SetKey_name(v IId_Context) { s.key_name = v } + +func (s *Drop_asymmetric_keyContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_asymmetric_keyContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, 0) +} + +func (s *Drop_asymmetric_keyContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserKEY) +} + +func (s *Drop_asymmetric_keyContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, i) +} + +func (s *Drop_asymmetric_keyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_asymmetric_keyContext) REMOVE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOVE, 0) +} + +func (s *Drop_asymmetric_keyContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER, 0) +} + +func (s *Drop_asymmetric_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_asymmetric_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_asymmetric_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_asymmetric_key(s) + } +} + +func (s *Drop_asymmetric_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_asymmetric_key(s) + } +} + +func (s *Drop_asymmetric_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_asymmetric_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_asymmetric_key() (localctx IDrop_asymmetric_keyContext) { + localctx = NewDrop_asymmetric_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 130, TSqlParserRULE_drop_asymmetric_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2030) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2031) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2032) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2033) + + var _x = p.Id_() + + localctx.(*Drop_asymmetric_keyContext).key_name = _x + } + p.SetState(2037) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 100, p.GetParserRuleContext()) == 1 { + { + p.SetState(2034) + p.Match(TSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2035) + p.Match(TSqlParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2036) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_authorizationContext is an interface to support dynamic dispatch. +type IAlter_authorizationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEntity returns the entity rule contexts. + GetEntity() IEntity_nameContext + + // SetEntity sets the entity rule contexts. + SetEntity(IEntity_nameContext) + + // Getter signatures + Alter_authorization_start() IAlter_authorization_startContext + Entity_to() IEntity_toContext + Authorization_grantee() IAuthorization_granteeContext + Entity_name() IEntity_nameContext + Class_type() IClass_typeContext + Colon_colon() IColon_colonContext + + // IsAlter_authorizationContext differentiates from other interfaces. + IsAlter_authorizationContext() +} + +type Alter_authorizationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + entity IEntity_nameContext +} + +func NewEmptyAlter_authorizationContext() *Alter_authorizationContext { + var p = new(Alter_authorizationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_authorization + return p +} + +func InitEmptyAlter_authorizationContext(p *Alter_authorizationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_authorization +} + +func (*Alter_authorizationContext) IsAlter_authorizationContext() {} + +func NewAlter_authorizationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_authorizationContext { + var p = new(Alter_authorizationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_authorization + + return p +} + +func (s *Alter_authorizationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_authorizationContext) GetEntity() IEntity_nameContext { return s.entity } + +func (s *Alter_authorizationContext) SetEntity(v IEntity_nameContext) { s.entity = v } + +func (s *Alter_authorizationContext) Alter_authorization_start() IAlter_authorization_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_authorization_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_authorization_startContext) +} + +func (s *Alter_authorizationContext) Entity_to() IEntity_toContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEntity_toContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEntity_toContext) +} + +func (s *Alter_authorizationContext) Authorization_grantee() IAuthorization_granteeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuthorization_granteeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuthorization_granteeContext) +} + +func (s *Alter_authorizationContext) Entity_name() IEntity_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEntity_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEntity_nameContext) +} + +func (s *Alter_authorizationContext) Class_type() IClass_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClass_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClass_typeContext) +} + +func (s *Alter_authorizationContext) Colon_colon() IColon_colonContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColon_colonContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColon_colonContext) +} + +func (s *Alter_authorizationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_authorizationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_authorizationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_authorization(s) + } +} + +func (s *Alter_authorizationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_authorization(s) + } +} + +func (s *Alter_authorizationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_authorization(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_authorization() (localctx IAlter_authorizationContext) { + localctx = NewAlter_authorizationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 132, TSqlParserRULE_alter_authorization) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2039) + p.Alter_authorization_start() + } + p.SetState(2043) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 101, p.GetParserRuleContext()) == 1 { + { + p.SetState(2040) + p.Class_type() + } + { + p.SetState(2041) + p.Colon_colon() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2045) + + var _x = p.Entity_name() + + localctx.(*Alter_authorizationContext).entity = _x + } + { + p.SetState(2046) + p.Entity_to() + } + { + p.SetState(2047) + p.Authorization_grantee() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAuthorization_granteeContext is an interface to support dynamic dispatch. +type IAuthorization_granteeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPrincipal_name returns the principal_name rule contexts. + GetPrincipal_name() IId_Context + + // SetPrincipal_name sets the principal_name rule contexts. + SetPrincipal_name(IId_Context) + + // Getter signatures + Id_() IId_Context + SCHEMA() antlr.TerminalNode + OWNER() antlr.TerminalNode + + // IsAuthorization_granteeContext differentiates from other interfaces. + IsAuthorization_granteeContext() +} + +type Authorization_granteeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + principal_name IId_Context +} + +func NewEmptyAuthorization_granteeContext() *Authorization_granteeContext { + var p = new(Authorization_granteeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_authorization_grantee + return p +} + +func InitEmptyAuthorization_granteeContext(p *Authorization_granteeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_authorization_grantee +} + +func (*Authorization_granteeContext) IsAuthorization_granteeContext() {} + +func NewAuthorization_granteeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Authorization_granteeContext { + var p = new(Authorization_granteeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_authorization_grantee + + return p +} + +func (s *Authorization_granteeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Authorization_granteeContext) GetPrincipal_name() IId_Context { return s.principal_name } + +func (s *Authorization_granteeContext) SetPrincipal_name(v IId_Context) { s.principal_name = v } + +func (s *Authorization_granteeContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Authorization_granteeContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Authorization_granteeContext) OWNER() antlr.TerminalNode { + return s.GetToken(TSqlParserOWNER, 0) +} + +func (s *Authorization_granteeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Authorization_granteeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Authorization_granteeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAuthorization_grantee(s) + } +} + +func (s *Authorization_granteeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAuthorization_grantee(s) + } +} + +func (s *Authorization_granteeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAuthorization_grantee(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Authorization_grantee() (localctx IAuthorization_granteeContext) { + localctx = NewAuthorization_granteeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 134, TSqlParserRULE_authorization_grantee) + p.SetState(2052) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2049) + + var _x = p.Id_() + + localctx.(*Authorization_granteeContext).principal_name = _x + } + + case TSqlParserSCHEMA: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2050) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2051) + p.Match(TSqlParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEntity_toContext is an interface to support dynamic dispatch. +type IEntity_toContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TO() antlr.TerminalNode + + // IsEntity_toContext differentiates from other interfaces. + IsEntity_toContext() +} + +type Entity_toContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEntity_toContext() *Entity_toContext { + var p = new(Entity_toContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_entity_to + return p +} + +func InitEmptyEntity_toContext(p *Entity_toContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_entity_to +} + +func (*Entity_toContext) IsEntity_toContext() {} + +func NewEntity_toContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Entity_toContext { + var p = new(Entity_toContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_entity_to + + return p +} + +func (s *Entity_toContext) GetParser() antlr.Parser { return s.parser } + +func (s *Entity_toContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Entity_toContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Entity_toContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Entity_toContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEntity_to(s) + } +} + +func (s *Entity_toContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEntity_to(s) + } +} + +func (s *Entity_toContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEntity_to(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Entity_to() (localctx IEntity_toContext) { + localctx = NewEntity_toContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 136, TSqlParserRULE_entity_to) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2054) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColon_colonContext is an interface to support dynamic dispatch. +type IColon_colonContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DOUBLE_COLON() antlr.TerminalNode + + // IsColon_colonContext differentiates from other interfaces. + IsColon_colonContext() +} + +type Colon_colonContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColon_colonContext() *Colon_colonContext { + var p = new(Colon_colonContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_colon_colon + return p +} + +func InitEmptyColon_colonContext(p *Colon_colonContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_colon_colon +} + +func (*Colon_colonContext) IsColon_colonContext() {} + +func NewColon_colonContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Colon_colonContext { + var p = new(Colon_colonContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_colon_colon + + return p +} + +func (s *Colon_colonContext) GetParser() antlr.Parser { return s.parser } + +func (s *Colon_colonContext) DOUBLE_COLON() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_COLON, 0) +} + +func (s *Colon_colonContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Colon_colonContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Colon_colonContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColon_colon(s) + } +} + +func (s *Colon_colonContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColon_colon(s) + } +} + +func (s *Colon_colonContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColon_colon(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Colon_colon() (localctx IColon_colonContext) { + localctx = NewColon_colonContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 138, TSqlParserRULE_colon_colon) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2056) + p.Match(TSqlParserDOUBLE_COLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_authorization_startContext is an interface to support dynamic dispatch. +type IAlter_authorization_startContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + ON() antlr.TerminalNode + + // IsAlter_authorization_startContext differentiates from other interfaces. + IsAlter_authorization_startContext() +} + +type Alter_authorization_startContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_authorization_startContext() *Alter_authorization_startContext { + var p = new(Alter_authorization_startContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_authorization_start + return p +} + +func InitEmptyAlter_authorization_startContext(p *Alter_authorization_startContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_authorization_start +} + +func (*Alter_authorization_startContext) IsAlter_authorization_startContext() {} + +func NewAlter_authorization_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_authorization_startContext { + var p = new(Alter_authorization_startContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_authorization_start + + return p +} + +func (s *Alter_authorization_startContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_authorization_startContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_authorization_startContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Alter_authorization_startContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Alter_authorization_startContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_authorization_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_authorization_startContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_authorization_start(s) + } +} + +func (s *Alter_authorization_startContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_authorization_start(s) + } +} + +func (s *Alter_authorization_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_authorization_start(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_authorization_start() (localctx IAlter_authorization_startContext) { + localctx = NewAlter_authorization_startContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 140, TSqlParserRULE_alter_authorization_start) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2058) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2059) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2060) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_authorization_for_sql_databaseContext is an interface to support dynamic dispatch. +type IAlter_authorization_for_sql_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEntity returns the entity rule contexts. + GetEntity() IEntity_nameContext + + // SetEntity sets the entity rule contexts. + SetEntity(IEntity_nameContext) + + // Getter signatures + Alter_authorization_start() IAlter_authorization_startContext + Entity_to() IEntity_toContext + Authorization_grantee() IAuthorization_granteeContext + Entity_name() IEntity_nameContext + Class_type_for_sql_database() IClass_type_for_sql_databaseContext + Colon_colon() IColon_colonContext + + // IsAlter_authorization_for_sql_databaseContext differentiates from other interfaces. + IsAlter_authorization_for_sql_databaseContext() +} + +type Alter_authorization_for_sql_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + entity IEntity_nameContext +} + +func NewEmptyAlter_authorization_for_sql_databaseContext() *Alter_authorization_for_sql_databaseContext { + var p = new(Alter_authorization_for_sql_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_authorization_for_sql_database + return p +} + +func InitEmptyAlter_authorization_for_sql_databaseContext(p *Alter_authorization_for_sql_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_authorization_for_sql_database +} + +func (*Alter_authorization_for_sql_databaseContext) IsAlter_authorization_for_sql_databaseContext() {} + +func NewAlter_authorization_for_sql_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_authorization_for_sql_databaseContext { + var p = new(Alter_authorization_for_sql_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_authorization_for_sql_database + + return p +} + +func (s *Alter_authorization_for_sql_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_authorization_for_sql_databaseContext) GetEntity() IEntity_nameContext { + return s.entity +} + +func (s *Alter_authorization_for_sql_databaseContext) SetEntity(v IEntity_nameContext) { s.entity = v } + +func (s *Alter_authorization_for_sql_databaseContext) Alter_authorization_start() IAlter_authorization_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_authorization_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_authorization_startContext) +} + +func (s *Alter_authorization_for_sql_databaseContext) Entity_to() IEntity_toContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEntity_toContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEntity_toContext) +} + +func (s *Alter_authorization_for_sql_databaseContext) Authorization_grantee() IAuthorization_granteeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuthorization_granteeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuthorization_granteeContext) +} + +func (s *Alter_authorization_for_sql_databaseContext) Entity_name() IEntity_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEntity_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEntity_nameContext) +} + +func (s *Alter_authorization_for_sql_databaseContext) Class_type_for_sql_database() IClass_type_for_sql_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClass_type_for_sql_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClass_type_for_sql_databaseContext) +} + +func (s *Alter_authorization_for_sql_databaseContext) Colon_colon() IColon_colonContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColon_colonContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColon_colonContext) +} + +func (s *Alter_authorization_for_sql_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_authorization_for_sql_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_authorization_for_sql_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_authorization_for_sql_database(s) + } +} + +func (s *Alter_authorization_for_sql_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_authorization_for_sql_database(s) + } +} + +func (s *Alter_authorization_for_sql_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_authorization_for_sql_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_authorization_for_sql_database() (localctx IAlter_authorization_for_sql_databaseContext) { + localctx = NewAlter_authorization_for_sql_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 142, TSqlParserRULE_alter_authorization_for_sql_database) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2062) + p.Alter_authorization_start() + } + p.SetState(2066) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 103, p.GetParserRuleContext()) == 1 { + { + p.SetState(2063) + p.Class_type_for_sql_database() + } + { + p.SetState(2064) + p.Colon_colon() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2068) + + var _x = p.Entity_name() + + localctx.(*Alter_authorization_for_sql_databaseContext).entity = _x + } + { + p.SetState(2069) + p.Entity_to() + } + { + p.SetState(2070) + p.Authorization_grantee() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_authorization_for_azure_dwContext is an interface to support dynamic dispatch. +type IAlter_authorization_for_azure_dwContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEntity returns the entity rule contexts. + GetEntity() IEntity_name_for_azure_dwContext + + // SetEntity sets the entity rule contexts. + SetEntity(IEntity_name_for_azure_dwContext) + + // Getter signatures + Alter_authorization_start() IAlter_authorization_startContext + Entity_to() IEntity_toContext + Authorization_grantee() IAuthorization_granteeContext + Entity_name_for_azure_dw() IEntity_name_for_azure_dwContext + Class_type_for_azure_dw() IClass_type_for_azure_dwContext + Colon_colon() IColon_colonContext + + // IsAlter_authorization_for_azure_dwContext differentiates from other interfaces. + IsAlter_authorization_for_azure_dwContext() +} + +type Alter_authorization_for_azure_dwContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + entity IEntity_name_for_azure_dwContext +} + +func NewEmptyAlter_authorization_for_azure_dwContext() *Alter_authorization_for_azure_dwContext { + var p = new(Alter_authorization_for_azure_dwContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_authorization_for_azure_dw + return p +} + +func InitEmptyAlter_authorization_for_azure_dwContext(p *Alter_authorization_for_azure_dwContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_authorization_for_azure_dw +} + +func (*Alter_authorization_for_azure_dwContext) IsAlter_authorization_for_azure_dwContext() {} + +func NewAlter_authorization_for_azure_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_authorization_for_azure_dwContext { + var p = new(Alter_authorization_for_azure_dwContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_authorization_for_azure_dw + + return p +} + +func (s *Alter_authorization_for_azure_dwContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_authorization_for_azure_dwContext) GetEntity() IEntity_name_for_azure_dwContext { + return s.entity +} + +func (s *Alter_authorization_for_azure_dwContext) SetEntity(v IEntity_name_for_azure_dwContext) { + s.entity = v +} + +func (s *Alter_authorization_for_azure_dwContext) Alter_authorization_start() IAlter_authorization_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_authorization_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_authorization_startContext) +} + +func (s *Alter_authorization_for_azure_dwContext) Entity_to() IEntity_toContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEntity_toContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEntity_toContext) +} + +func (s *Alter_authorization_for_azure_dwContext) Authorization_grantee() IAuthorization_granteeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuthorization_granteeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuthorization_granteeContext) +} + +func (s *Alter_authorization_for_azure_dwContext) Entity_name_for_azure_dw() IEntity_name_for_azure_dwContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEntity_name_for_azure_dwContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEntity_name_for_azure_dwContext) +} + +func (s *Alter_authorization_for_azure_dwContext) Class_type_for_azure_dw() IClass_type_for_azure_dwContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClass_type_for_azure_dwContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClass_type_for_azure_dwContext) +} + +func (s *Alter_authorization_for_azure_dwContext) Colon_colon() IColon_colonContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColon_colonContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColon_colonContext) +} + +func (s *Alter_authorization_for_azure_dwContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_authorization_for_azure_dwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_authorization_for_azure_dwContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_authorization_for_azure_dw(s) + } +} + +func (s *Alter_authorization_for_azure_dwContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_authorization_for_azure_dw(s) + } +} + +func (s *Alter_authorization_for_azure_dwContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_authorization_for_azure_dw(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_authorization_for_azure_dw() (localctx IAlter_authorization_for_azure_dwContext) { + localctx = NewAlter_authorization_for_azure_dwContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 144, TSqlParserRULE_alter_authorization_for_azure_dw) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2072) + p.Alter_authorization_start() + } + p.SetState(2076) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 104, p.GetParserRuleContext()) == 1 { + { + p.SetState(2073) + p.Class_type_for_azure_dw() + } + { + p.SetState(2074) + p.Colon_colon() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2078) + + var _x = p.Entity_name_for_azure_dw() + + localctx.(*Alter_authorization_for_azure_dwContext).entity = _x + } + { + p.SetState(2079) + p.Entity_to() + } + { + p.SetState(2080) + p.Authorization_grantee() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_authorization_for_parallel_dwContext is an interface to support dynamic dispatch. +type IAlter_authorization_for_parallel_dwContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEntity returns the entity rule contexts. + GetEntity() IEntity_name_for_parallel_dwContext + + // SetEntity sets the entity rule contexts. + SetEntity(IEntity_name_for_parallel_dwContext) + + // Getter signatures + Alter_authorization_start() IAlter_authorization_startContext + Entity_to() IEntity_toContext + Authorization_grantee() IAuthorization_granteeContext + Entity_name_for_parallel_dw() IEntity_name_for_parallel_dwContext + Class_type_for_parallel_dw() IClass_type_for_parallel_dwContext + Colon_colon() IColon_colonContext + + // IsAlter_authorization_for_parallel_dwContext differentiates from other interfaces. + IsAlter_authorization_for_parallel_dwContext() +} + +type Alter_authorization_for_parallel_dwContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + entity IEntity_name_for_parallel_dwContext +} + +func NewEmptyAlter_authorization_for_parallel_dwContext() *Alter_authorization_for_parallel_dwContext { + var p = new(Alter_authorization_for_parallel_dwContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_authorization_for_parallel_dw + return p +} + +func InitEmptyAlter_authorization_for_parallel_dwContext(p *Alter_authorization_for_parallel_dwContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_authorization_for_parallel_dw +} + +func (*Alter_authorization_for_parallel_dwContext) IsAlter_authorization_for_parallel_dwContext() {} + +func NewAlter_authorization_for_parallel_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_authorization_for_parallel_dwContext { + var p = new(Alter_authorization_for_parallel_dwContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_authorization_for_parallel_dw + + return p +} + +func (s *Alter_authorization_for_parallel_dwContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_authorization_for_parallel_dwContext) GetEntity() IEntity_name_for_parallel_dwContext { + return s.entity +} + +func (s *Alter_authorization_for_parallel_dwContext) SetEntity(v IEntity_name_for_parallel_dwContext) { + s.entity = v +} + +func (s *Alter_authorization_for_parallel_dwContext) Alter_authorization_start() IAlter_authorization_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_authorization_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_authorization_startContext) +} + +func (s *Alter_authorization_for_parallel_dwContext) Entity_to() IEntity_toContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEntity_toContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEntity_toContext) +} + +func (s *Alter_authorization_for_parallel_dwContext) Authorization_grantee() IAuthorization_granteeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuthorization_granteeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuthorization_granteeContext) +} + +func (s *Alter_authorization_for_parallel_dwContext) Entity_name_for_parallel_dw() IEntity_name_for_parallel_dwContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEntity_name_for_parallel_dwContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEntity_name_for_parallel_dwContext) +} + +func (s *Alter_authorization_for_parallel_dwContext) Class_type_for_parallel_dw() IClass_type_for_parallel_dwContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClass_type_for_parallel_dwContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClass_type_for_parallel_dwContext) +} + +func (s *Alter_authorization_for_parallel_dwContext) Colon_colon() IColon_colonContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColon_colonContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColon_colonContext) +} + +func (s *Alter_authorization_for_parallel_dwContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_authorization_for_parallel_dwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_authorization_for_parallel_dwContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_authorization_for_parallel_dw(s) + } +} + +func (s *Alter_authorization_for_parallel_dwContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_authorization_for_parallel_dw(s) + } +} + +func (s *Alter_authorization_for_parallel_dwContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_authorization_for_parallel_dw(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_authorization_for_parallel_dw() (localctx IAlter_authorization_for_parallel_dwContext) { + localctx = NewAlter_authorization_for_parallel_dwContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 146, TSqlParserRULE_alter_authorization_for_parallel_dw) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2082) + p.Alter_authorization_start() + } + p.SetState(2086) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 105, p.GetParserRuleContext()) == 1 { + { + p.SetState(2083) + p.Class_type_for_parallel_dw() + } + { + p.SetState(2084) + p.Colon_colon() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2088) + + var _x = p.Entity_name_for_parallel_dw() + + localctx.(*Alter_authorization_for_parallel_dwContext).entity = _x + } + { + p.SetState(2089) + p.Entity_to() + } + { + p.SetState(2090) + p.Authorization_grantee() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClass_typeContext is an interface to support dynamic dispatch. +type IClass_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT() antlr.TerminalNode + ASSEMBLY() antlr.TerminalNode + ASYMMETRIC() antlr.TerminalNode + KEY() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + GROUP() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + CONTRACT() antlr.TerminalNode + TYPE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + ENDPOINT() antlr.TerminalNode + FULLTEXT() antlr.TerminalNode + CATALOG() antlr.TerminalNode + STOPLIST() antlr.TerminalNode + MESSAGE() antlr.TerminalNode + REMOTE() antlr.TerminalNode + SERVICE() antlr.TerminalNode + BINDING() antlr.TerminalNode + ROLE() antlr.TerminalNode + ROUTE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + SEARCH() antlr.TerminalNode + PROPERTY() antlr.TerminalNode + LIST() antlr.TerminalNode + SERVER() antlr.TerminalNode + SYMMETRIC() antlr.TerminalNode + XML() antlr.TerminalNode + COLLECTION() antlr.TerminalNode + + // IsClass_typeContext differentiates from other interfaces. + IsClass_typeContext() +} + +type Class_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClass_typeContext() *Class_typeContext { + var p = new(Class_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_class_type + return p +} + +func InitEmptyClass_typeContext(p *Class_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_class_type +} + +func (*Class_typeContext) IsClass_typeContext() {} + +func NewClass_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Class_typeContext { + var p = new(Class_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_class_type + + return p +} + +func (s *Class_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Class_typeContext) OBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT, 0) +} + +func (s *Class_typeContext) ASSEMBLY() antlr.TerminalNode { + return s.GetToken(TSqlParserASSEMBLY, 0) +} + +func (s *Class_typeContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, 0) +} + +func (s *Class_typeContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Class_typeContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(TSqlParserAVAILABILITY, 0) +} + +func (s *Class_typeContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *Class_typeContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Class_typeContext) CONTRACT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTRACT, 0) +} + +func (s *Class_typeContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *Class_typeContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Class_typeContext) ENDPOINT() antlr.TerminalNode { + return s.GetToken(TSqlParserENDPOINT, 0) +} + +func (s *Class_typeContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXT, 0) +} + +func (s *Class_typeContext) CATALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserCATALOG, 0) +} + +func (s *Class_typeContext) STOPLIST() antlr.TerminalNode { + return s.GetToken(TSqlParserSTOPLIST, 0) +} + +func (s *Class_typeContext) MESSAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE, 0) +} + +func (s *Class_typeContext) REMOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOTE, 0) +} + +func (s *Class_typeContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *Class_typeContext) BINDING() antlr.TerminalNode { + return s.GetToken(TSqlParserBINDING, 0) +} + +func (s *Class_typeContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Class_typeContext) ROUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserROUTE, 0) +} + +func (s *Class_typeContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Class_typeContext) SEARCH() antlr.TerminalNode { + return s.GetToken(TSqlParserSEARCH, 0) +} + +func (s *Class_typeContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserPROPERTY, 0) +} + +func (s *Class_typeContext) LIST() antlr.TerminalNode { + return s.GetToken(TSqlParserLIST, 0) +} + +func (s *Class_typeContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Class_typeContext) SYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserSYMMETRIC, 0) +} + +func (s *Class_typeContext) XML() antlr.TerminalNode { + return s.GetToken(TSqlParserXML, 0) +} + +func (s *Class_typeContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLECTION, 0) +} + +func (s *Class_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Class_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Class_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterClass_type(s) + } +} + +func (s *Class_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitClass_type(s) + } +} + +func (s *Class_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitClass_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Class_type() (localctx IClass_typeContext) { + localctx = NewClass_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 148, TSqlParserRULE_class_type) + p.SetState(2126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 106, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2092) + p.Match(TSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2093) + p.Match(TSqlParserASSEMBLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2094) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2095) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2096) + p.Match(TSqlParserAVAILABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2097) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2098) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2099) + p.Match(TSqlParserCONTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2100) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2101) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2102) + p.Match(TSqlParserENDPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2103) + p.Match(TSqlParserFULLTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2104) + p.Match(TSqlParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2105) + p.Match(TSqlParserFULLTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2106) + p.Match(TSqlParserSTOPLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2107) + p.Match(TSqlParserMESSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2108) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2109) + p.Match(TSqlParserREMOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2110) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2111) + p.Match(TSqlParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2112) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2113) + p.Match(TSqlParserROUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2114) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2115) + p.Match(TSqlParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2116) + p.Match(TSqlParserPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2117) + p.Match(TSqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2118) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2119) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(2120) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(2121) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2122) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(2123) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2124) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2125) + p.Match(TSqlParserCOLLECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClass_type_for_sql_databaseContext is an interface to support dynamic dispatch. +type IClass_type_for_sql_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT() antlr.TerminalNode + ASSEMBLY() antlr.TerminalNode + ASYMMETRIC() antlr.TerminalNode + KEY() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + TYPE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + FULLTEXT() antlr.TerminalNode + CATALOG() antlr.TerminalNode + STOPLIST() antlr.TerminalNode + ROLE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + SEARCH() antlr.TerminalNode + PROPERTY() antlr.TerminalNode + LIST() antlr.TerminalNode + SYMMETRIC() antlr.TerminalNode + XML() antlr.TerminalNode + COLLECTION() antlr.TerminalNode + + // IsClass_type_for_sql_databaseContext differentiates from other interfaces. + IsClass_type_for_sql_databaseContext() +} + +type Class_type_for_sql_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClass_type_for_sql_databaseContext() *Class_type_for_sql_databaseContext { + var p = new(Class_type_for_sql_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_class_type_for_sql_database + return p +} + +func InitEmptyClass_type_for_sql_databaseContext(p *Class_type_for_sql_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_class_type_for_sql_database +} + +func (*Class_type_for_sql_databaseContext) IsClass_type_for_sql_databaseContext() {} + +func NewClass_type_for_sql_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Class_type_for_sql_databaseContext { + var p = new(Class_type_for_sql_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_class_type_for_sql_database + + return p +} + +func (s *Class_type_for_sql_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Class_type_for_sql_databaseContext) OBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT, 0) +} + +func (s *Class_type_for_sql_databaseContext) ASSEMBLY() antlr.TerminalNode { + return s.GetToken(TSqlParserASSEMBLY, 0) +} + +func (s *Class_type_for_sql_databaseContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, 0) +} + +func (s *Class_type_for_sql_databaseContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Class_type_for_sql_databaseContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Class_type_for_sql_databaseContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *Class_type_for_sql_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Class_type_for_sql_databaseContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXT, 0) +} + +func (s *Class_type_for_sql_databaseContext) CATALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserCATALOG, 0) +} + +func (s *Class_type_for_sql_databaseContext) STOPLIST() antlr.TerminalNode { + return s.GetToken(TSqlParserSTOPLIST, 0) +} + +func (s *Class_type_for_sql_databaseContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Class_type_for_sql_databaseContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Class_type_for_sql_databaseContext) SEARCH() antlr.TerminalNode { + return s.GetToken(TSqlParserSEARCH, 0) +} + +func (s *Class_type_for_sql_databaseContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserPROPERTY, 0) +} + +func (s *Class_type_for_sql_databaseContext) LIST() antlr.TerminalNode { + return s.GetToken(TSqlParserLIST, 0) +} + +func (s *Class_type_for_sql_databaseContext) SYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserSYMMETRIC, 0) +} + +func (s *Class_type_for_sql_databaseContext) XML() antlr.TerminalNode { + return s.GetToken(TSqlParserXML, 0) +} + +func (s *Class_type_for_sql_databaseContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLECTION, 0) +} + +func (s *Class_type_for_sql_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Class_type_for_sql_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Class_type_for_sql_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterClass_type_for_sql_database(s) + } +} + +func (s *Class_type_for_sql_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitClass_type_for_sql_database(s) + } +} + +func (s *Class_type_for_sql_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitClass_type_for_sql_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Class_type_for_sql_database() (localctx IClass_type_for_sql_databaseContext) { + localctx = NewClass_type_for_sql_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 150, TSqlParserRULE_class_type_for_sql_database) + p.SetState(2149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 107, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2128) + p.Match(TSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2129) + p.Match(TSqlParserASSEMBLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2130) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2131) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2132) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2133) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2134) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2135) + p.Match(TSqlParserFULLTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2136) + p.Match(TSqlParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2137) + p.Match(TSqlParserFULLTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2138) + p.Match(TSqlParserSTOPLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2139) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2140) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2141) + p.Match(TSqlParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2142) + p.Match(TSqlParserPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2143) + p.Match(TSqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2144) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2145) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2146) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2147) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2148) + p.Match(TSqlParserCOLLECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClass_type_for_azure_dwContext is an interface to support dynamic dispatch. +type IClass_type_for_azure_dwContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SCHEMA() antlr.TerminalNode + OBJECT() antlr.TerminalNode + + // IsClass_type_for_azure_dwContext differentiates from other interfaces. + IsClass_type_for_azure_dwContext() +} + +type Class_type_for_azure_dwContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClass_type_for_azure_dwContext() *Class_type_for_azure_dwContext { + var p = new(Class_type_for_azure_dwContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_class_type_for_azure_dw + return p +} + +func InitEmptyClass_type_for_azure_dwContext(p *Class_type_for_azure_dwContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_class_type_for_azure_dw +} + +func (*Class_type_for_azure_dwContext) IsClass_type_for_azure_dwContext() {} + +func NewClass_type_for_azure_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Class_type_for_azure_dwContext { + var p = new(Class_type_for_azure_dwContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_class_type_for_azure_dw + + return p +} + +func (s *Class_type_for_azure_dwContext) GetParser() antlr.Parser { return s.parser } + +func (s *Class_type_for_azure_dwContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Class_type_for_azure_dwContext) OBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT, 0) +} + +func (s *Class_type_for_azure_dwContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Class_type_for_azure_dwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Class_type_for_azure_dwContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterClass_type_for_azure_dw(s) + } +} + +func (s *Class_type_for_azure_dwContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitClass_type_for_azure_dw(s) + } +} + +func (s *Class_type_for_azure_dwContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitClass_type_for_azure_dw(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Class_type_for_azure_dw() (localctx IClass_type_for_azure_dwContext) { + localctx = NewClass_type_for_azure_dwContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 152, TSqlParserRULE_class_type_for_azure_dw) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2151) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOBJECT || _la == TSqlParserSCHEMA) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClass_type_for_parallel_dwContext is an interface to support dynamic dispatch. +type IClass_type_for_parallel_dwContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + OBJECT() antlr.TerminalNode + + // IsClass_type_for_parallel_dwContext differentiates from other interfaces. + IsClass_type_for_parallel_dwContext() +} + +type Class_type_for_parallel_dwContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClass_type_for_parallel_dwContext() *Class_type_for_parallel_dwContext { + var p = new(Class_type_for_parallel_dwContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_class_type_for_parallel_dw + return p +} + +func InitEmptyClass_type_for_parallel_dwContext(p *Class_type_for_parallel_dwContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_class_type_for_parallel_dw +} + +func (*Class_type_for_parallel_dwContext) IsClass_type_for_parallel_dwContext() {} + +func NewClass_type_for_parallel_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Class_type_for_parallel_dwContext { + var p = new(Class_type_for_parallel_dwContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_class_type_for_parallel_dw + + return p +} + +func (s *Class_type_for_parallel_dwContext) GetParser() antlr.Parser { return s.parser } + +func (s *Class_type_for_parallel_dwContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Class_type_for_parallel_dwContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Class_type_for_parallel_dwContext) OBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT, 0) +} + +func (s *Class_type_for_parallel_dwContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Class_type_for_parallel_dwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Class_type_for_parallel_dwContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterClass_type_for_parallel_dw(s) + } +} + +func (s *Class_type_for_parallel_dwContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitClass_type_for_parallel_dw(s) + } +} + +func (s *Class_type_for_parallel_dwContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitClass_type_for_parallel_dw(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Class_type_for_parallel_dw() (localctx IClass_type_for_parallel_dwContext) { + localctx = NewClass_type_for_parallel_dwContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 154, TSqlParserRULE_class_type_for_parallel_dw) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2153) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDATABASE || _la == TSqlParserOBJECT || _la == TSqlParserSCHEMA) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClass_type_for_grantContext is an interface to support dynamic dispatch. +type IClass_type_for_grantContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + APPLICATION() antlr.TerminalNode + ROLE() antlr.TerminalNode + ASSEMBLY() antlr.TerminalNode + ASYMMETRIC() antlr.TerminalNode + KEY() antlr.TerminalNode + AUDIT() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + GROUP() antlr.TerminalNode + BROKER() antlr.TerminalNode + PRIORITY() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + COLUMN() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + MASTER() antlr.TerminalNode + CONTRACT() antlr.TerminalNode + CREDENTIAL() antlr.TerminalNode + CRYPTOGRAPHIC() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + EVENT() antlr.TerminalNode + SESSION() antlr.TerminalNode + SCOPED() antlr.TerminalNode + CONFIGURATION() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + GOVERNOR() antlr.TerminalNode + ENDPOINT() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + OBJECT() antlr.TerminalNode + SERVER() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + DATA() antlr.TerminalNode + SOURCE() antlr.TerminalNode + FILE() antlr.TerminalNode + FORMAT() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + POOL() antlr.TerminalNode + TABLE() antlr.TerminalNode + CATALOG() antlr.TerminalNode + STOPLIST() antlr.TerminalNode + LOGIN() antlr.TerminalNode + MESSAGE() antlr.TerminalNode + TYPE() antlr.TerminalNode + PARTITION() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + SCHEME() antlr.TerminalNode + REMOTE() antlr.TerminalNode + SERVICE() antlr.TerminalNode + BINDING() antlr.TerminalNode + ROUTE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + SEARCH() antlr.TerminalNode + PROPERTY() antlr.TerminalNode + LIST() antlr.TerminalNode + SQL() antlr.TerminalNode + SYMMETRIC() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + USER() antlr.TerminalNode + XML() antlr.TerminalNode + COLLECTION() antlr.TerminalNode + + // IsClass_type_for_grantContext differentiates from other interfaces. + IsClass_type_for_grantContext() +} + +type Class_type_for_grantContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClass_type_for_grantContext() *Class_type_for_grantContext { + var p = new(Class_type_for_grantContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_class_type_for_grant + return p +} + +func InitEmptyClass_type_for_grantContext(p *Class_type_for_grantContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_class_type_for_grant +} + +func (*Class_type_for_grantContext) IsClass_type_for_grantContext() {} + +func NewClass_type_for_grantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Class_type_for_grantContext { + var p = new(Class_type_for_grantContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_class_type_for_grant + + return p +} + +func (s *Class_type_for_grantContext) GetParser() antlr.Parser { return s.parser } + +func (s *Class_type_for_grantContext) APPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLICATION, 0) +} + +func (s *Class_type_for_grantContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Class_type_for_grantContext) ASSEMBLY() antlr.TerminalNode { + return s.GetToken(TSqlParserASSEMBLY, 0) +} + +func (s *Class_type_for_grantContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, 0) +} + +func (s *Class_type_for_grantContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Class_type_for_grantContext) AUDIT() antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT, 0) +} + +func (s *Class_type_for_grantContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(TSqlParserAVAILABILITY, 0) +} + +func (s *Class_type_for_grantContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *Class_type_for_grantContext) BROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserBROKER, 0) +} + +func (s *Class_type_for_grantContext) PRIORITY() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIORITY, 0) +} + +func (s *Class_type_for_grantContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Class_type_for_grantContext) COLUMN() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMN, 0) +} + +func (s *Class_type_for_grantContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Class_type_for_grantContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *Class_type_for_grantContext) CONTRACT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTRACT, 0) +} + +func (s *Class_type_for_grantContext) CREDENTIAL() antlr.TerminalNode { + return s.GetToken(TSqlParserCREDENTIAL, 0) +} + +func (s *Class_type_for_grantContext) CRYPTOGRAPHIC() antlr.TerminalNode { + return s.GetToken(TSqlParserCRYPTOGRAPHIC, 0) +} + +func (s *Class_type_for_grantContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER, 0) +} + +func (s *Class_type_for_grantContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Class_type_for_grantContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserSPECIFICATION, 0) +} + +func (s *Class_type_for_grantContext) EVENT() antlr.TerminalNode { + return s.GetToken(TSqlParserEVENT, 0) +} + +func (s *Class_type_for_grantContext) SESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserSESSION, 0) +} + +func (s *Class_type_for_grantContext) SCOPED() antlr.TerminalNode { + return s.GetToken(TSqlParserSCOPED, 0) +} + +func (s *Class_type_for_grantContext) CONFIGURATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONFIGURATION, 0) +} + +func (s *Class_type_for_grantContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESOURCE, 0) +} + +func (s *Class_type_for_grantContext) GOVERNOR() antlr.TerminalNode { + return s.GetToken(TSqlParserGOVERNOR, 0) +} + +func (s *Class_type_for_grantContext) ENDPOINT() antlr.TerminalNode { + return s.GetToken(TSqlParserENDPOINT, 0) +} + +func (s *Class_type_for_grantContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserNOTIFICATION, 0) +} + +func (s *Class_type_for_grantContext) OBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT, 0) +} + +func (s *Class_type_for_grantContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Class_type_for_grantContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Class_type_for_grantContext) DATA() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA, 0) +} + +func (s *Class_type_for_grantContext) SOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserSOURCE, 0) +} + +func (s *Class_type_for_grantContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Class_type_for_grantContext) FORMAT() antlr.TerminalNode { + return s.GetToken(TSqlParserFORMAT, 0) +} + +func (s *Class_type_for_grantContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(TSqlParserLIBRARY, 0) +} + +func (s *Class_type_for_grantContext) POOL() antlr.TerminalNode { + return s.GetToken(TSqlParserPOOL, 0) +} + +func (s *Class_type_for_grantContext) TABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLE, 0) +} + +func (s *Class_type_for_grantContext) CATALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserCATALOG, 0) +} + +func (s *Class_type_for_grantContext) STOPLIST() antlr.TerminalNode { + return s.GetToken(TSqlParserSTOPLIST, 0) +} + +func (s *Class_type_for_grantContext) LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, 0) +} + +func (s *Class_type_for_grantContext) MESSAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE, 0) +} + +func (s *Class_type_for_grantContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *Class_type_for_grantContext) PARTITION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITION, 0) +} + +func (s *Class_type_for_grantContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(TSqlParserFUNCTION, 0) +} + +func (s *Class_type_for_grantContext) SCHEME() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEME, 0) +} + +func (s *Class_type_for_grantContext) REMOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOTE, 0) +} + +func (s *Class_type_for_grantContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *Class_type_for_grantContext) BINDING() antlr.TerminalNode { + return s.GetToken(TSqlParserBINDING, 0) +} + +func (s *Class_type_for_grantContext) ROUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserROUTE, 0) +} + +func (s *Class_type_for_grantContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Class_type_for_grantContext) SEARCH() antlr.TerminalNode { + return s.GetToken(TSqlParserSEARCH, 0) +} + +func (s *Class_type_for_grantContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserPROPERTY, 0) +} + +func (s *Class_type_for_grantContext) LIST() antlr.TerminalNode { + return s.GetToken(TSqlParserLIST, 0) +} + +func (s *Class_type_for_grantContext) SQL() antlr.TerminalNode { + return s.GetToken(TSqlParserSQL, 0) +} + +func (s *Class_type_for_grantContext) SYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserSYMMETRIC, 0) +} + +func (s *Class_type_for_grantContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIGGER, 0) +} + +func (s *Class_type_for_grantContext) USER() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER, 0) +} + +func (s *Class_type_for_grantContext) XML() antlr.TerminalNode { + return s.GetToken(TSqlParserXML, 0) +} + +func (s *Class_type_for_grantContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLECTION, 0) +} + +func (s *Class_type_for_grantContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Class_type_for_grantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Class_type_for_grantContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterClass_type_for_grant(s) + } +} + +func (s *Class_type_for_grantContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitClass_type_for_grant(s) + } +} + +func (s *Class_type_for_grantContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitClass_type_for_grant(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Class_type_for_grant() (localctx IClass_type_for_grantContext) { + localctx = NewClass_type_for_grantContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 156, TSqlParserRULE_class_type_for_grant) + var _la int + + p.SetState(2246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAPPLICATION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2155) + p.Match(TSqlParserAPPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2156) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserASSEMBLY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2157) + p.Match(TSqlParserASSEMBLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserASYMMETRIC: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2158) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2159) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserAUDIT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2160) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserAVAILABILITY: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2161) + p.Match(TSqlParserAVAILABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2162) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserBROKER: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2163) + p.Match(TSqlParserBROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2164) + p.Match(TSqlParserPRIORITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCERTIFICATE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2165) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCOLUMN: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2166) + p.Match(TSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2167) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserENCRYPTION || _la == TSqlParserMASTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2168) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCONTRACT: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2169) + p.Match(TSqlParserCONTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCREDENTIAL: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2170) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCRYPTOGRAPHIC: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2171) + p.Match(TSqlParserCRYPTOGRAPHIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2172) + p.Match(TSqlParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDATABASE: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2173) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case TSqlParserAUDIT: + { + p.SetState(2174) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2175) + p.Match(TSqlParserSPECIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserENCRYPTION: + { + p.SetState(2176) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2177) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEVENT: + { + p.SetState(2178) + p.Match(TSqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2179) + p.Match(TSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSCOPED: + { + p.SetState(2180) + p.Match(TSqlParserSCOPED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCONFIGURATION: + { + p.SetState(2181) + p.Match(TSqlParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCREDENTIAL: + { + p.SetState(2182) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserRESOURCE: + { + p.SetState(2183) + p.Match(TSqlParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2184) + p.Match(TSqlParserGOVERNOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserDOUBLE_COLON: + + default: + } + + case TSqlParserENDPOINT: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2189) + p.Match(TSqlParserENDPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEVENT: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2190) + p.Match(TSqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2191) + p.Match(TSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNOTIFICATION: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2192) + p.Match(TSqlParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2193) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDATABASE || _la == TSqlParserOBJECT || _la == TSqlParserSERVER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserEXTERNAL: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2194) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2205) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDATA: + { + p.SetState(2195) + p.Match(TSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2196) + p.Match(TSqlParserSOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserFILE: + { + p.SetState(2197) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2198) + p.Match(TSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserLIBRARY: + { + p.SetState(2199) + p.Match(TSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserRESOURCE: + { + p.SetState(2200) + p.Match(TSqlParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2201) + p.Match(TSqlParserPOOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTABLE: + { + p.SetState(2202) + p.Match(TSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCATALOG: + { + p.SetState(2203) + p.Match(TSqlParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSTOPLIST: + { + p.SetState(2204) + p.Match(TSqlParserSTOPLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserLOGIN: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2207) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMASTER: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2208) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2209) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMESSAGE: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(2210) + p.Match(TSqlParserMESSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2211) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserOBJECT: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(2212) + p.Match(TSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPARTITION: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(2213) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2214) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFUNCTION || _la == TSqlParserSCHEME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserREMOTE: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(2215) + p.Match(TSqlParserREMOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2216) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2217) + p.Match(TSqlParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserRESOURCE: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(2218) + p.Match(TSqlParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2219) + p.Match(TSqlParserGOVERNOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserROLE: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(2220) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserROUTE: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(2221) + p.Match(TSqlParserROUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSCHEMA: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(2222) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSEARCH: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(2223) + p.Match(TSqlParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2224) + p.Match(TSqlParserPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2225) + p.Match(TSqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSERVER: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(2226) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2232) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case TSqlParserAUDIT: + { + p.SetState(2227) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2229) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSPECIFICATION { + { + p.SetState(2228) + p.Match(TSqlParserSPECIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserROLE: + { + p.SetState(2231) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDOUBLE_COLON: + + default: + } + + case TSqlParserSERVICE: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(2234) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSQL: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(2235) + p.Match(TSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2236) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSYMMETRIC: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(2237) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2238) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTRIGGER: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(2239) + p.Match(TSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2240) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDATABASE || _la == TSqlParserSERVER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserTYPE: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(2241) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserUSER: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(2242) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserXML: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(2243) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2244) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2245) + p.Match(TSqlParserCOLLECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_availability_groupContext is an interface to support dynamic dispatch. +type IDrop_availability_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetGroup_name returns the group_name rule contexts. + GetGroup_name() IId_Context + + // SetGroup_name sets the group_name rule contexts. + SetGroup_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + GROUP() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_availability_groupContext differentiates from other interfaces. + IsDrop_availability_groupContext() +} + +type Drop_availability_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + group_name IId_Context +} + +func NewEmptyDrop_availability_groupContext() *Drop_availability_groupContext { + var p = new(Drop_availability_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_availability_group + return p +} + +func InitEmptyDrop_availability_groupContext(p *Drop_availability_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_availability_group +} + +func (*Drop_availability_groupContext) IsDrop_availability_groupContext() {} + +func NewDrop_availability_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_availability_groupContext { + var p = new(Drop_availability_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_availability_group + + return p +} + +func (s *Drop_availability_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_availability_groupContext) GetGroup_name() IId_Context { return s.group_name } + +func (s *Drop_availability_groupContext) SetGroup_name(v IId_Context) { s.group_name = v } + +func (s *Drop_availability_groupContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_availability_groupContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(TSqlParserAVAILABILITY, 0) +} + +func (s *Drop_availability_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *Drop_availability_groupContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_availability_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_availability_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_availability_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_availability_group(s) + } +} + +func (s *Drop_availability_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_availability_group(s) + } +} + +func (s *Drop_availability_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_availability_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_availability_group() (localctx IDrop_availability_groupContext) { + localctx = NewDrop_availability_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 158, TSqlParserRULE_drop_availability_group) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2248) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2249) + p.Match(TSqlParserAVAILABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2250) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2251) + + var _x = p.Id_() + + localctx.(*Drop_availability_groupContext).group_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_availability_groupContext is an interface to support dynamic dispatch. +type IAlter_availability_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_availability_group_start() IAlter_availability_group_startContext + Alter_availability_group_options() IAlter_availability_group_optionsContext + + // IsAlter_availability_groupContext differentiates from other interfaces. + IsAlter_availability_groupContext() +} + +type Alter_availability_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_availability_groupContext() *Alter_availability_groupContext { + var p = new(Alter_availability_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_availability_group + return p +} + +func InitEmptyAlter_availability_groupContext(p *Alter_availability_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_availability_group +} + +func (*Alter_availability_groupContext) IsAlter_availability_groupContext() {} + +func NewAlter_availability_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_availability_groupContext { + var p = new(Alter_availability_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_availability_group + + return p +} + +func (s *Alter_availability_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_availability_groupContext) Alter_availability_group_start() IAlter_availability_group_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_availability_group_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_availability_group_startContext) +} + +func (s *Alter_availability_groupContext) Alter_availability_group_options() IAlter_availability_group_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_availability_group_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_availability_group_optionsContext) +} + +func (s *Alter_availability_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_availability_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_availability_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_availability_group(s) + } +} + +func (s *Alter_availability_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_availability_group(s) + } +} + +func (s *Alter_availability_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_availability_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_availability_group() (localctx IAlter_availability_groupContext) { + localctx = NewAlter_availability_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 160, TSqlParserRULE_alter_availability_group) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2253) + p.Alter_availability_group_start() + } + { + p.SetState(2254) + p.Alter_availability_group_options() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_availability_group_startContext is an interface to support dynamic dispatch. +type IAlter_availability_group_startContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetGroup_name returns the group_name rule contexts. + GetGroup_name() IId_Context + + // SetGroup_name sets the group_name rule contexts. + SetGroup_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + GROUP() antlr.TerminalNode + Id_() IId_Context + + // IsAlter_availability_group_startContext differentiates from other interfaces. + IsAlter_availability_group_startContext() +} + +type Alter_availability_group_startContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + group_name IId_Context +} + +func NewEmptyAlter_availability_group_startContext() *Alter_availability_group_startContext { + var p = new(Alter_availability_group_startContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_availability_group_start + return p +} + +func InitEmptyAlter_availability_group_startContext(p *Alter_availability_group_startContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_availability_group_start +} + +func (*Alter_availability_group_startContext) IsAlter_availability_group_startContext() {} + +func NewAlter_availability_group_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_availability_group_startContext { + var p = new(Alter_availability_group_startContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_availability_group_start + + return p +} + +func (s *Alter_availability_group_startContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_availability_group_startContext) GetGroup_name() IId_Context { return s.group_name } + +func (s *Alter_availability_group_startContext) SetGroup_name(v IId_Context) { s.group_name = v } + +func (s *Alter_availability_group_startContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_availability_group_startContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(TSqlParserAVAILABILITY, 0) +} + +func (s *Alter_availability_group_startContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *Alter_availability_group_startContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_availability_group_startContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_availability_group_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_availability_group_startContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_availability_group_start(s) + } +} + +func (s *Alter_availability_group_startContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_availability_group_start(s) + } +} + +func (s *Alter_availability_group_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_availability_group_start(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_availability_group_start() (localctx IAlter_availability_group_startContext) { + localctx = NewAlter_availability_group_startContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 162, TSqlParserRULE_alter_availability_group_start) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2256) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2257) + p.Match(TSqlParserAVAILABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2258) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2259) + + var _x = p.Id_() + + localctx.(*Alter_availability_group_startContext).group_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_availability_group_optionsContext is an interface to support dynamic dispatch. +type IAlter_availability_group_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMilliseconds returns the milliseconds token. + GetMilliseconds() antlr.Token + + // GetServer_instance returns the server_instance token. + GetServer_instance() antlr.Token + + // GetSession_timeout returns the session_timeout token. + GetSession_timeout() antlr.Token + + // GetAg_name returns the ag_name token. + GetAg_name() antlr.Token + + // GetAg_name_modified returns the ag_name_modified token. + GetAg_name_modified() antlr.Token + + // GetListener_name returns the listener_name token. + GetListener_name() antlr.Token + + // SetMilliseconds sets the milliseconds token. + SetMilliseconds(antlr.Token) + + // SetServer_instance sets the server_instance token. + SetServer_instance(antlr.Token) + + // SetSession_timeout sets the session_timeout token. + SetSession_timeout(antlr.Token) + + // SetAg_name sets the ag_name token. + SetAg_name(antlr.Token) + + // SetAg_name_modified sets the ag_name_modified token. + SetAg_name_modified(antlr.Token) + + // SetListener_name sets the listener_name token. + SetListener_name(antlr.Token) + + // GetDatabase_name returns the database_name rule contexts. + GetDatabase_name() IId_Context + + // SetDatabase_name sets the database_name rule contexts. + SetDatabase_name(IId_Context) + + // Getter signatures + SET() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AUTOMATED_BACKUP_PREFERENCE() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + FAILURE_CONDITION_LEVEL() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + HEALTH_CHECK_TIMEOUT() antlr.TerminalNode + DB_FAILOVER() antlr.TerminalNode + REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + SECONDARY_ONLY() antlr.TerminalNode + SECONDARY() antlr.TerminalNode + NONE() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + ADD() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + REMOVE() antlr.TerminalNode + REPLICA() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + ENDPOINT_URL() antlr.TerminalNode + AllAVAILABILITY_MODE() []antlr.TerminalNode + AVAILABILITY_MODE(i int) antlr.TerminalNode + AllFAILOVER_MODE() []antlr.TerminalNode + FAILOVER_MODE(i int) antlr.TerminalNode + AllSEEDING_MODE() []antlr.TerminalNode + SEEDING_MODE(i int) antlr.TerminalNode + BACKUP_PRIORITY() antlr.TerminalNode + PRIMARY_ROLE() antlr.TerminalNode + AllALLOW_CONNECTIONS() []antlr.TerminalNode + ALLOW_CONNECTIONS(i int) antlr.TerminalNode + SECONDARY_ROLE() antlr.TerminalNode + AllSYNCHRONOUS_COMMIT() []antlr.TerminalNode + SYNCHRONOUS_COMMIT(i int) antlr.TerminalNode + AllASYNCHRONOUS_COMMIT() []antlr.TerminalNode + ASYNCHRONOUS_COMMIT(i int) antlr.TerminalNode + AllAUTOMATIC() []antlr.TerminalNode + AUTOMATIC(i int) antlr.TerminalNode + AllMANUAL() []antlr.TerminalNode + MANUAL(i int) antlr.TerminalNode + READ_WRITE() antlr.TerminalNode + ALL() antlr.TerminalNode + READ_ONLY() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + READ_ONLY_ROUTING_LIST() antlr.TerminalNode + NO() antlr.TerminalNode + SESSION_TIMEOUT() antlr.TerminalNode + MODIFY() antlr.TerminalNode + JOIN() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllLISTENER_URL() []antlr.TerminalNode + LISTENER_URL(i int) antlr.TerminalNode + GRANT() antlr.TerminalNode + CREATE() antlr.TerminalNode + ANY() antlr.TerminalNode + DENY() antlr.TerminalNode + FAILOVER() antlr.TerminalNode + FORCE_FAILOVER_ALLOW_DATA_LOSS() antlr.TerminalNode + LISTENER() antlr.TerminalNode + DHCP() antlr.TerminalNode + IP() antlr.TerminalNode + AllIp_v4_failover() []IIp_v4_failoverContext + Ip_v4_failover(i int) IIp_v4_failoverContext + PORT() antlr.TerminalNode + AllIp_v6_failover() []IIp_v6_failoverContext + Ip_v6_failover(i int) IIp_v6_failoverContext + RESTART() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + DTC_SUPPORT() antlr.TerminalNode + PER_DB() antlr.TerminalNode + + // IsAlter_availability_group_optionsContext differentiates from other interfaces. + IsAlter_availability_group_optionsContext() +} + +type Alter_availability_group_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + milliseconds antlr.Token + database_name IId_Context + server_instance antlr.Token + session_timeout antlr.Token + ag_name antlr.Token + ag_name_modified antlr.Token + listener_name antlr.Token +} + +func NewEmptyAlter_availability_group_optionsContext() *Alter_availability_group_optionsContext { + var p = new(Alter_availability_group_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_availability_group_options + return p +} + +func InitEmptyAlter_availability_group_optionsContext(p *Alter_availability_group_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_availability_group_options +} + +func (*Alter_availability_group_optionsContext) IsAlter_availability_group_optionsContext() {} + +func NewAlter_availability_group_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_availability_group_optionsContext { + var p = new(Alter_availability_group_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_availability_group_options + + return p +} + +func (s *Alter_availability_group_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_availability_group_optionsContext) GetMilliseconds() antlr.Token { + return s.milliseconds +} + +func (s *Alter_availability_group_optionsContext) GetServer_instance() antlr.Token { + return s.server_instance +} + +func (s *Alter_availability_group_optionsContext) GetSession_timeout() antlr.Token { + return s.session_timeout +} + +func (s *Alter_availability_group_optionsContext) GetAg_name() antlr.Token { return s.ag_name } + +func (s *Alter_availability_group_optionsContext) GetAg_name_modified() antlr.Token { + return s.ag_name_modified +} + +func (s *Alter_availability_group_optionsContext) GetListener_name() antlr.Token { + return s.listener_name +} + +func (s *Alter_availability_group_optionsContext) SetMilliseconds(v antlr.Token) { s.milliseconds = v } + +func (s *Alter_availability_group_optionsContext) SetServer_instance(v antlr.Token) { + s.server_instance = v +} + +func (s *Alter_availability_group_optionsContext) SetSession_timeout(v antlr.Token) { + s.session_timeout = v +} + +func (s *Alter_availability_group_optionsContext) SetAg_name(v antlr.Token) { s.ag_name = v } + +func (s *Alter_availability_group_optionsContext) SetAg_name_modified(v antlr.Token) { + s.ag_name_modified = v +} + +func (s *Alter_availability_group_optionsContext) SetListener_name(v antlr.Token) { + s.listener_name = v +} + +func (s *Alter_availability_group_optionsContext) GetDatabase_name() IId_Context { + return s.database_name +} + +func (s *Alter_availability_group_optionsContext) SetDatabase_name(v IId_Context) { + s.database_name = v +} + +func (s *Alter_availability_group_optionsContext) SET() antlr.TerminalNode { + return s.GetToken(TSqlParserSET, 0) +} + +func (s *Alter_availability_group_optionsContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Alter_availability_group_optionsContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Alter_availability_group_optionsContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Alter_availability_group_optionsContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Alter_availability_group_optionsContext) AUTOMATED_BACKUP_PREFERENCE() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTOMATED_BACKUP_PREFERENCE, 0) +} + +func (s *Alter_availability_group_optionsContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_availability_group_optionsContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_availability_group_optionsContext) FAILURE_CONDITION_LEVEL() antlr.TerminalNode { + return s.GetToken(TSqlParserFAILURE_CONDITION_LEVEL, 0) +} + +func (s *Alter_availability_group_optionsContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Alter_availability_group_optionsContext) HEALTH_CHECK_TIMEOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserHEALTH_CHECK_TIMEOUT, 0) +} + +func (s *Alter_availability_group_optionsContext) DB_FAILOVER() antlr.TerminalNode { + return s.GetToken(TSqlParserDB_FAILOVER, 0) +} + +func (s *Alter_availability_group_optionsContext) REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT() antlr.TerminalNode { + return s.GetToken(TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, 0) +} + +func (s *Alter_availability_group_optionsContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIMARY, 0) +} + +func (s *Alter_availability_group_optionsContext) SECONDARY_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserSECONDARY_ONLY, 0) +} + +func (s *Alter_availability_group_optionsContext) SECONDARY() antlr.TerminalNode { + return s.GetToken(TSqlParserSECONDARY, 0) +} + +func (s *Alter_availability_group_optionsContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Alter_availability_group_optionsContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Alter_availability_group_optionsContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Alter_availability_group_optionsContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_availability_group_optionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Alter_availability_group_optionsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_availability_group_optionsContext) REMOVE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOVE, 0) +} + +func (s *Alter_availability_group_optionsContext) REPLICA() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLICA, 0) +} + +func (s *Alter_availability_group_optionsContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Alter_availability_group_optionsContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Alter_availability_group_optionsContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(TSqlParserWITH) +} + +func (s *Alter_availability_group_optionsContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, i) +} + +func (s *Alter_availability_group_optionsContext) ENDPOINT_URL() antlr.TerminalNode { + return s.GetToken(TSqlParserENDPOINT_URL, 0) +} + +func (s *Alter_availability_group_optionsContext) AllAVAILABILITY_MODE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAVAILABILITY_MODE) +} + +func (s *Alter_availability_group_optionsContext) AVAILABILITY_MODE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAVAILABILITY_MODE, i) +} + +func (s *Alter_availability_group_optionsContext) AllFAILOVER_MODE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFAILOVER_MODE) +} + +func (s *Alter_availability_group_optionsContext) FAILOVER_MODE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFAILOVER_MODE, i) +} + +func (s *Alter_availability_group_optionsContext) AllSEEDING_MODE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSEEDING_MODE) +} + +func (s *Alter_availability_group_optionsContext) SEEDING_MODE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSEEDING_MODE, i) +} + +func (s *Alter_availability_group_optionsContext) BACKUP_PRIORITY() antlr.TerminalNode { + return s.GetToken(TSqlParserBACKUP_PRIORITY, 0) +} + +func (s *Alter_availability_group_optionsContext) PRIMARY_ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIMARY_ROLE, 0) +} + +func (s *Alter_availability_group_optionsContext) AllALLOW_CONNECTIONS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserALLOW_CONNECTIONS) +} + +func (s *Alter_availability_group_optionsContext) ALLOW_CONNECTIONS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_CONNECTIONS, i) +} + +func (s *Alter_availability_group_optionsContext) SECONDARY_ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSECONDARY_ROLE, 0) +} + +func (s *Alter_availability_group_optionsContext) AllSYNCHRONOUS_COMMIT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSYNCHRONOUS_COMMIT) +} + +func (s *Alter_availability_group_optionsContext) SYNCHRONOUS_COMMIT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSYNCHRONOUS_COMMIT, i) +} + +func (s *Alter_availability_group_optionsContext) AllASYNCHRONOUS_COMMIT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserASYNCHRONOUS_COMMIT) +} + +func (s *Alter_availability_group_optionsContext) ASYNCHRONOUS_COMMIT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserASYNCHRONOUS_COMMIT, i) +} + +func (s *Alter_availability_group_optionsContext) AllAUTOMATIC() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAUTOMATIC) +} + +func (s *Alter_availability_group_optionsContext) AUTOMATIC(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAUTOMATIC, i) +} + +func (s *Alter_availability_group_optionsContext) AllMANUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMANUAL) +} + +func (s *Alter_availability_group_optionsContext) MANUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMANUAL, i) +} + +func (s *Alter_availability_group_optionsContext) READ_WRITE() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_WRITE, 0) +} + +func (s *Alter_availability_group_optionsContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Alter_availability_group_optionsContext) READ_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_ONLY, 0) +} + +func (s *Alter_availability_group_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_availability_group_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_availability_group_optionsContext) READ_ONLY_ROUTING_LIST() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_ONLY_ROUTING_LIST, 0) +} + +func (s *Alter_availability_group_optionsContext) NO() antlr.TerminalNode { + return s.GetToken(TSqlParserNO, 0) +} + +func (s *Alter_availability_group_optionsContext) SESSION_TIMEOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserSESSION_TIMEOUT, 0) +} + +func (s *Alter_availability_group_optionsContext) MODIFY() antlr.TerminalNode { + return s.GetToken(TSqlParserMODIFY, 0) +} + +func (s *Alter_availability_group_optionsContext) JOIN() antlr.TerminalNode { + return s.GetToken(TSqlParserJOIN, 0) +} + +func (s *Alter_availability_group_optionsContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(TSqlParserAVAILABILITY, 0) +} + +func (s *Alter_availability_group_optionsContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *Alter_availability_group_optionsContext) AllLISTENER_URL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLISTENER_URL) +} + +func (s *Alter_availability_group_optionsContext) LISTENER_URL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLISTENER_URL, i) +} + +func (s *Alter_availability_group_optionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(TSqlParserGRANT, 0) +} + +func (s *Alter_availability_group_optionsContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Alter_availability_group_optionsContext) ANY() antlr.TerminalNode { + return s.GetToken(TSqlParserANY, 0) +} + +func (s *Alter_availability_group_optionsContext) DENY() antlr.TerminalNode { + return s.GetToken(TSqlParserDENY, 0) +} + +func (s *Alter_availability_group_optionsContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(TSqlParserFAILOVER, 0) +} + +func (s *Alter_availability_group_optionsContext) FORCE_FAILOVER_ALLOW_DATA_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, 0) +} + +func (s *Alter_availability_group_optionsContext) LISTENER() antlr.TerminalNode { + return s.GetToken(TSqlParserLISTENER, 0) +} + +func (s *Alter_availability_group_optionsContext) DHCP() antlr.TerminalNode { + return s.GetToken(TSqlParserDHCP, 0) +} + +func (s *Alter_availability_group_optionsContext) IP() antlr.TerminalNode { + return s.GetToken(TSqlParserIP, 0) +} + +func (s *Alter_availability_group_optionsContext) AllIp_v4_failover() []IIp_v4_failoverContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIp_v4_failoverContext); ok { + len++ + } + } + + tst := make([]IIp_v4_failoverContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIp_v4_failoverContext); ok { + tst[i] = t.(IIp_v4_failoverContext) + i++ + } + } + + return tst +} + +func (s *Alter_availability_group_optionsContext) Ip_v4_failover(i int) IIp_v4_failoverContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIp_v4_failoverContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIp_v4_failoverContext) +} + +func (s *Alter_availability_group_optionsContext) PORT() antlr.TerminalNode { + return s.GetToken(TSqlParserPORT, 0) +} + +func (s *Alter_availability_group_optionsContext) AllIp_v6_failover() []IIp_v6_failoverContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIp_v6_failoverContext); ok { + len++ + } + } + + tst := make([]IIp_v6_failoverContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIp_v6_failoverContext); ok { + tst[i] = t.(IIp_v6_failoverContext) + i++ + } + } + + return tst +} + +func (s *Alter_availability_group_optionsContext) Ip_v6_failover(i int) IIp_v6_failoverContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIp_v6_failoverContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIp_v6_failoverContext) +} + +func (s *Alter_availability_group_optionsContext) RESTART() antlr.TerminalNode { + return s.GetToken(TSqlParserRESTART, 0) +} + +func (s *Alter_availability_group_optionsContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(TSqlParserOFFLINE, 0) +} + +func (s *Alter_availability_group_optionsContext) DTC_SUPPORT() antlr.TerminalNode { + return s.GetToken(TSqlParserDTC_SUPPORT, 0) +} + +func (s *Alter_availability_group_optionsContext) PER_DB() antlr.TerminalNode { + return s.GetToken(TSqlParserPER_DB, 0) +} + +func (s *Alter_availability_group_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_availability_group_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_availability_group_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_availability_group_options(s) + } +} + +func (s *Alter_availability_group_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_availability_group_options(s) + } +} + +func (s *Alter_availability_group_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_availability_group_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_availability_group_options() (localctx IAlter_availability_group_optionsContext) { + localctx = NewAlter_availability_group_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 164, TSqlParserRULE_alter_availability_group_options) + var _la int + + p.SetState(2616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 157, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2261) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2262) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(2278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAUTOMATED_BACKUP_PREFERENCE: + { + p.SetState(2263) + p.Match(TSqlParserAUTOMATED_BACKUP_PREFERENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2264) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2265) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNONE || _la == TSqlParserPRIMARY || _la == TSqlParserSECONDARY || _la == TSqlParserSECONDARY_ONLY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserFAILURE_CONDITION_LEVEL: + { + p.SetState(2266) + p.Match(TSqlParserFAILURE_CONDITION_LEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2267) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2268) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserHEALTH_CHECK_TIMEOUT: + { + p.SetState(2269) + p.Match(TSqlParserHEALTH_CHECK_TIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2270) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2271) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_availability_group_optionsContext).milliseconds = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDB_FAILOVER: + { + p.SetState(2272) + p.Match(TSqlParserDB_FAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2273) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2274) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT: + { + p.SetState(2275) + p.Match(TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2276) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2277) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(2280) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2281) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2282) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2283) + + var _x = p.Id_() + + localctx.(*Alter_availability_group_optionsContext).database_name = _x + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2284) + p.Match(TSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2285) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2286) + + var _x = p.Id_() + + localctx.(*Alter_availability_group_optionsContext).database_name = _x + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2287) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2288) + p.Match(TSqlParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2289) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2290) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_availability_group_optionsContext).server_instance = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2291) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2292) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(2296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserENDPOINT_URL { + { + p.SetState(2293) + p.Match(TSqlParserENDPOINT_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2294) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2295) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2304) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 117, p.GetParserRuleContext()) == 1 { + p.SetState(2299) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2298) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2301) + p.Match(TSqlParserAVAILABILITY_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2302) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2303) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserASYNCHRONOUS_COMMIT || _la == TSqlParserSYNCHRONOUS_COMMIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2312) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 119, p.GetParserRuleContext()) == 1 { + p.SetState(2307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2306) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2309) + p.Match(TSqlParserFAILOVER_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2310) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2311) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAUTOMATIC || _la == TSqlParserMANUAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2320) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 121, p.GetParserRuleContext()) == 1 { + p.SetState(2315) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2314) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2317) + p.Match(TSqlParserSEEDING_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2318) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2319) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAUTOMATIC || _la == TSqlParserMANUAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2328) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 123, p.GetParserRuleContext()) == 1 { + p.SetState(2323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2322) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2325) + p.Match(TSqlParserBACKUP_PRIORITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2326) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2327) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2339) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 125, p.GetParserRuleContext()) == 1 { + p.SetState(2331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2330) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2333) + p.Match(TSqlParserPRIMARY_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2334) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2335) + p.Match(TSqlParserALLOW_CONNECTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2336) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2337) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALL || _la == TSqlParserREAD_WRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2338) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2350) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSECONDARY_ROLE || _la == TSqlParserCOMMA { + p.SetState(2342) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2341) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2344) + p.Match(TSqlParserSECONDARY_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2345) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2346) + p.Match(TSqlParserALLOW_CONNECTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2347) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2348) + p.Match(TSqlParserREAD_ONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2349) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + { + p.SetState(2352) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2353) + p.Match(TSqlParserSECONDARY_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2354) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALLOW_CONNECTIONS: + { + p.SetState(2355) + p.Match(TSqlParserALLOW_CONNECTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2356) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2357) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALL || _la == TSqlParserNO || _la == TSqlParserREAD_ONLY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserREAD_ONLY_ROUTING_LIST: + { + p.SetState(2358) + p.Match(TSqlParserREAD_ONLY_ROUTING_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2359) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2360) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2361) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2362) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2365) + p.Match(TSqlParserPRIMARY_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2366) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALLOW_CONNECTIONS: + { + p.SetState(2367) + p.Match(TSqlParserALLOW_CONNECTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2368) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2369) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALL || _la == TSqlParserNO || _la == TSqlParserREAD_ONLY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserREAD_ONLY_ROUTING_LIST: + { + p.SetState(2370) + p.Match(TSqlParserREAD_ONLY_ROUTING_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2371) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2372) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING, TSqlParserRR_BRACKET, TSqlParserCOMMA: + p.SetState(2379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserSTRING || _la == TSqlParserCOMMA { + p.SetState(2374) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2373) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2376) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(2381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case TSqlParserNONE: + { + p.SetState(2382) + p.Match(TSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(2385) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSESSION_TIMEOUT: + { + p.SetState(2386) + p.Match(TSqlParserSESSION_TIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2387) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2388) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_availability_group_optionsContext).session_timeout = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2391) + p.Match(TSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2392) + p.Match(TSqlParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2393) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2394) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_availability_group_optionsContext).server_instance = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserWITH: + { + p.SetState(2395) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2396) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2412) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserENDPOINT_URL: + { + p.SetState(2397) + p.Match(TSqlParserENDPOINT_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2398) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2399) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserAVAILABILITY_MODE: + { + p.SetState(2400) + p.Match(TSqlParserAVAILABILITY_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2401) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2402) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserASYNCHRONOUS_COMMIT || _la == TSqlParserSYNCHRONOUS_COMMIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserFAILOVER_MODE: + { + p.SetState(2403) + p.Match(TSqlParserFAILOVER_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2404) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2405) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAUTOMATIC || _la == TSqlParserMANUAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserSEEDING_MODE: + { + p.SetState(2406) + p.Match(TSqlParserSEEDING_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2407) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2408) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAUTOMATIC || _la == TSqlParserMANUAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserBACKUP_PRIORITY: + { + p.SetState(2409) + p.Match(TSqlParserBACKUP_PRIORITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2410) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2411) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserSECONDARY_ROLE: + { + p.SetState(2414) + p.Match(TSqlParserSECONDARY_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2415) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALLOW_CONNECTIONS: + { + p.SetState(2416) + p.Match(TSqlParserALLOW_CONNECTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2417) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2418) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALL || _la == TSqlParserNO || _la == TSqlParserREAD_ONLY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserREAD_ONLY_ROUTING_LIST: + { + p.SetState(2419) + p.Match(TSqlParserREAD_ONLY_ROUTING_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2420) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2421) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2422) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2423) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserPRIMARY_ROLE: + { + p.SetState(2426) + p.Match(TSqlParserPRIMARY_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2427) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2450) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALLOW_CONNECTIONS: + { + p.SetState(2428) + p.Match(TSqlParserALLOW_CONNECTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2429) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2430) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALL || _la == TSqlParserNO || _la == TSqlParserREAD_ONLY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserREAD_ONLY_ROUTING_LIST: + { + p.SetState(2431) + p.Match(TSqlParserREAD_ONLY_ROUTING_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2432) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2433) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2444) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING, TSqlParserRR_BRACKET, TSqlParserCOMMA: + p.SetState(2440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserSTRING || _la == TSqlParserCOMMA { + p.SetState(2435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2434) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2437) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(2442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case TSqlParserNONE: + { + p.SetState(2443) + p.Match(TSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(2446) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSESSION_TIMEOUT: + { + p.SetState(2447) + p.Match(TSqlParserSESSION_TIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2448) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2449) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_availability_group_optionsContext).session_timeout = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(2454) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2455) + p.Match(TSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2456) + p.Match(TSqlParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2457) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2458) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2459) + p.Match(TSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2460) + p.Match(TSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2461) + p.Match(TSqlParserAVAILABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2462) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2463) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserSTRING || _la == TSqlParserCOMMA { + p.SetState(2465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2464) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2467) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_availability_group_optionsContext).ag_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2468) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2469) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2470) + p.Match(TSqlParserLISTENER_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2471) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2472) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2473) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2474) + p.Match(TSqlParserAVAILABILITY_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2475) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2476) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserASYNCHRONOUS_COMMIT || _la == TSqlParserSYNCHRONOUS_COMMIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2477) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2478) + p.Match(TSqlParserFAILOVER_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2479) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2480) + p.Match(TSqlParserMANUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2481) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2482) + p.Match(TSqlParserSEEDING_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2483) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2484) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAUTOMATIC || _la == TSqlParserMANUAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2485) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(2488) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2490) + p.Match(TSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2491) + p.Match(TSqlParserAVAILABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2492) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2493) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2528) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserSTRING || _la == TSqlParserCOMMA { + p.SetState(2495) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2494) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2497) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_availability_group_optionsContext).ag_name_modified = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2498) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2499) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2500) + p.Match(TSqlParserLISTENER_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2501) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2502) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2509) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 144, p.GetParserRuleContext()) == 1 { + p.SetState(2504) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2503) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2506) + p.Match(TSqlParserAVAILABILITY_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2507) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2508) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserASYNCHRONOUS_COMMIT || _la == TSqlParserSYNCHRONOUS_COMMIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2517) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 146, p.GetParserRuleContext()) == 1 { + p.SetState(2512) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2511) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2514) + p.Match(TSqlParserFAILOVER_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2515) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2516) + p.Match(TSqlParserMANUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSEEDING_MODE || _la == TSqlParserCOMMA { + p.SetState(2520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2519) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2522) + p.Match(TSqlParserSEEDING_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2523) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2524) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAUTOMATIC || _la == TSqlParserMANUAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(2527) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(2530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2532) + p.Match(TSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2533) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2534) + p.Match(TSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2535) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2536) + p.Match(TSqlParserDENY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2537) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2538) + p.Match(TSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2539) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2540) + p.Match(TSqlParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2541) + p.Match(TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2542) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2543) + p.Match(TSqlParserLISTENER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2544) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_availability_group_optionsContext).listener_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2545) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2581) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 154, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2546) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2547) + p.Match(TSqlParserDHCP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2548) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2549) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2550) + p.Ip_v4_failover() + } + { + p.SetState(2551) + p.Ip_v4_failover() + } + { + p.SetState(2552) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(2554) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2555) + p.Match(TSqlParserIP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2556) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(2570) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserLR_BRACKET || _la == TSqlParserCOMMA { + p.SetState(2558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2557) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2560) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 151, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2561) + p.Ip_v4_failover() + } + { + p.SetState(2562) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2563) + p.Ip_v4_failover() + } + + case 2: + { + p.SetState(2565) + p.Ip_v6_failover() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(2568) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(2572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2574) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2579) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2575) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2576) + p.Match(TSqlParserPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2577) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2578) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(2583) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2585) + p.Match(TSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2586) + p.Match(TSqlParserLISTENER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserADD: + { + p.SetState(2587) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2588) + p.Match(TSqlParserIP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2589) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2594) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 155, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2590) + p.Ip_v4_failover() + } + { + p.SetState(2591) + p.Ip_v4_failover() + } + + case 2: + { + p.SetState(2593) + p.Ip_v6_failover() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(2596) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPORT: + { + p.SetState(2598) + p.Match(TSqlParserPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2599) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2600) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2603) + p.Match(TSqlParserRESTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2604) + p.Match(TSqlParserLISTENER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2605) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(2606) + p.Match(TSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2607) + p.Match(TSqlParserLISTENER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2608) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(2609) + p.Match(TSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(2610) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2611) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2612) + p.Match(TSqlParserDTC_SUPPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2613) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2614) + p.Match(TSqlParserPER_DB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2615) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIp_v4_failoverContext is an interface to support dynamic dispatch. +type IIp_v4_failoverContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRING() antlr.TerminalNode + + // IsIp_v4_failoverContext differentiates from other interfaces. + IsIp_v4_failoverContext() +} + +type Ip_v4_failoverContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIp_v4_failoverContext() *Ip_v4_failoverContext { + var p = new(Ip_v4_failoverContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_ip_v4_failover + return p +} + +func InitEmptyIp_v4_failoverContext(p *Ip_v4_failoverContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_ip_v4_failover +} + +func (*Ip_v4_failoverContext) IsIp_v4_failoverContext() {} + +func NewIp_v4_failoverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ip_v4_failoverContext { + var p = new(Ip_v4_failoverContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_ip_v4_failover + + return p +} + +func (s *Ip_v4_failoverContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ip_v4_failoverContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Ip_v4_failoverContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ip_v4_failoverContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ip_v4_failoverContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterIp_v4_failover(s) + } +} + +func (s *Ip_v4_failoverContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitIp_v4_failover(s) + } +} + +func (s *Ip_v4_failoverContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitIp_v4_failover(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Ip_v4_failover() (localctx IIp_v4_failoverContext) { + localctx = NewIp_v4_failoverContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 166, TSqlParserRULE_ip_v4_failover) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2618) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIp_v6_failoverContext is an interface to support dynamic dispatch. +type IIp_v6_failoverContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRING() antlr.TerminalNode + + // IsIp_v6_failoverContext differentiates from other interfaces. + IsIp_v6_failoverContext() +} + +type Ip_v6_failoverContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIp_v6_failoverContext() *Ip_v6_failoverContext { + var p = new(Ip_v6_failoverContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_ip_v6_failover + return p +} + +func InitEmptyIp_v6_failoverContext(p *Ip_v6_failoverContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_ip_v6_failover +} + +func (*Ip_v6_failoverContext) IsIp_v6_failoverContext() {} + +func NewIp_v6_failoverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ip_v6_failoverContext { + var p = new(Ip_v6_failoverContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_ip_v6_failover + + return p +} + +func (s *Ip_v6_failoverContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ip_v6_failoverContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Ip_v6_failoverContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ip_v6_failoverContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ip_v6_failoverContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterIp_v6_failover(s) + } +} + +func (s *Ip_v6_failoverContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitIp_v6_failover(s) + } +} + +func (s *Ip_v6_failoverContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitIp_v6_failover(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Ip_v6_failover() (localctx IIp_v6_failoverContext) { + localctx = NewIp_v6_failoverContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 168, TSqlParserRULE_ip_v6_failover) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2620) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_or_alter_broker_priorityContext is an interface to support dynamic dispatch. +type ICreate_or_alter_broker_priorityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRemoteServiceName returns the RemoteServiceName token. + GetRemoteServiceName() antlr.Token + + // GetPriorityValue returns the PriorityValue token. + GetPriorityValue() antlr.Token + + // SetRemoteServiceName sets the RemoteServiceName token. + SetRemoteServiceName(antlr.Token) + + // SetPriorityValue sets the PriorityValue token. + SetPriorityValue(antlr.Token) + + // GetConversationPriorityName returns the ConversationPriorityName rule contexts. + GetConversationPriorityName() IId_Context + + // SetConversationPriorityName sets the ConversationPriorityName rule contexts. + SetConversationPriorityName(IId_Context) + + // Getter signatures + BROKER() antlr.TerminalNode + PRIORITY() antlr.TerminalNode + FOR() antlr.TerminalNode + CONVERSATION() antlr.TerminalNode + SET() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + CREATE() antlr.TerminalNode + ALTER() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + CONTRACT_NAME() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + LOCAL_SERVICE_NAME() antlr.TerminalNode + REMOTE_SERVICE_NAME() antlr.TerminalNode + PRIORITY_LEVEL() antlr.TerminalNode + AllANY() []antlr.TerminalNode + ANY(i int) antlr.TerminalNode + DEFAULT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + STRING() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + DOUBLE_FORWARD_SLASH() antlr.TerminalNode + + // IsCreate_or_alter_broker_priorityContext differentiates from other interfaces. + IsCreate_or_alter_broker_priorityContext() +} + +type Create_or_alter_broker_priorityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ConversationPriorityName IId_Context + RemoteServiceName antlr.Token + PriorityValue antlr.Token +} + +func NewEmptyCreate_or_alter_broker_priorityContext() *Create_or_alter_broker_priorityContext { + var p = new(Create_or_alter_broker_priorityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_broker_priority + return p +} + +func InitEmptyCreate_or_alter_broker_priorityContext(p *Create_or_alter_broker_priorityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_broker_priority +} + +func (*Create_or_alter_broker_priorityContext) IsCreate_or_alter_broker_priorityContext() {} + +func NewCreate_or_alter_broker_priorityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_broker_priorityContext { + var p = new(Create_or_alter_broker_priorityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_or_alter_broker_priority + + return p +} + +func (s *Create_or_alter_broker_priorityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_or_alter_broker_priorityContext) GetRemoteServiceName() antlr.Token { + return s.RemoteServiceName +} + +func (s *Create_or_alter_broker_priorityContext) GetPriorityValue() antlr.Token { + return s.PriorityValue +} + +func (s *Create_or_alter_broker_priorityContext) SetRemoteServiceName(v antlr.Token) { + s.RemoteServiceName = v +} + +func (s *Create_or_alter_broker_priorityContext) SetPriorityValue(v antlr.Token) { s.PriorityValue = v } + +func (s *Create_or_alter_broker_priorityContext) GetConversationPriorityName() IId_Context { + return s.ConversationPriorityName +} + +func (s *Create_or_alter_broker_priorityContext) SetConversationPriorityName(v IId_Context) { + s.ConversationPriorityName = v +} + +func (s *Create_or_alter_broker_priorityContext) BROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserBROKER, 0) +} + +func (s *Create_or_alter_broker_priorityContext) PRIORITY() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIORITY, 0) +} + +func (s *Create_or_alter_broker_priorityContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_or_alter_broker_priorityContext) CONVERSATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONVERSATION, 0) +} + +func (s *Create_or_alter_broker_priorityContext) SET() antlr.TerminalNode { + return s.GetToken(TSqlParserSET, 0) +} + +func (s *Create_or_alter_broker_priorityContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_or_alter_broker_priorityContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_or_alter_broker_priorityContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_or_alter_broker_priorityContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Create_or_alter_broker_priorityContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_or_alter_broker_priorityContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_or_alter_broker_priorityContext) CONTRACT_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTRACT_NAME, 0) +} + +func (s *Create_or_alter_broker_priorityContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_or_alter_broker_priorityContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_or_alter_broker_priorityContext) LOCAL_SERVICE_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_SERVICE_NAME, 0) +} + +func (s *Create_or_alter_broker_priorityContext) REMOTE_SERVICE_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOTE_SERVICE_NAME, 0) +} + +func (s *Create_or_alter_broker_priorityContext) PRIORITY_LEVEL() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIORITY_LEVEL, 0) +} + +func (s *Create_or_alter_broker_priorityContext) AllANY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserANY) +} + +func (s *Create_or_alter_broker_priorityContext) ANY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserANY, i) +} + +func (s *Create_or_alter_broker_priorityContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Create_or_alter_broker_priorityContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_or_alter_broker_priorityContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_or_alter_broker_priorityContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_or_alter_broker_priorityContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Create_or_alter_broker_priorityContext) DOUBLE_FORWARD_SLASH() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_FORWARD_SLASH, 0) +} + +func (s *Create_or_alter_broker_priorityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_or_alter_broker_priorityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_or_alter_broker_priorityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_or_alter_broker_priority(s) + } +} + +func (s *Create_or_alter_broker_priorityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_or_alter_broker_priority(s) + } +} + +func (s *Create_or_alter_broker_priorityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_or_alter_broker_priority(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_or_alter_broker_priority() (localctx ICreate_or_alter_broker_priorityContext) { + localctx = NewCreate_or_alter_broker_priorityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 170, TSqlParserRULE_create_or_alter_broker_priority) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2622) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALTER || _la == TSqlParserCREATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2623) + p.Match(TSqlParserBROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2624) + p.Match(TSqlParserPRIORITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2625) + + var _x = p.Id_() + + localctx.(*Create_or_alter_broker_priorityContext).ConversationPriorityName = _x + } + { + p.SetState(2626) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2627) + p.Match(TSqlParserCONVERSATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2628) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2629) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2639) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCONTRACT_NAME { + { + p.SetState(2630) + p.Match(TSqlParserCONTRACT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2631) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(2632) + p.Id_() + } + + case TSqlParserANY: + { + p.SetState(2633) + p.Match(TSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2636) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(2653) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLOCAL_SERVICE_NAME { + { + p.SetState(2641) + p.Match(TSqlParserLOCAL_SERVICE_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2642) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2648) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDOUBLE_FORWARD_SLASH, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + p.SetState(2644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserDOUBLE_FORWARD_SLASH { + { + p.SetState(2643) + p.Match(TSqlParserDOUBLE_FORWARD_SLASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2646) + p.Id_() + } + + case TSqlParserANY: + { + p.SetState(2647) + p.Match(TSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2650) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(2664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserREMOTE_SERVICE_NAME { + { + p.SetState(2655) + p.Match(TSqlParserREMOTE_SERVICE_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2656) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2659) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(2657) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_or_alter_broker_priorityContext).RemoteServiceName = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserANY: + { + p.SetState(2658) + p.Match(TSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2661) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(2672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPRIORITY_LEVEL { + { + p.SetState(2666) + p.Match(TSqlParserPRIORITY_LEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2667) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2670) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(2668) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_or_alter_broker_priorityContext).PriorityValue = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDEFAULT: + { + p.SetState(2669) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + { + p.SetState(2674) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_broker_priorityContext is an interface to support dynamic dispatch. +type IDrop_broker_priorityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetConversationPriorityName returns the ConversationPriorityName rule contexts. + GetConversationPriorityName() IId_Context + + // SetConversationPriorityName sets the ConversationPriorityName rule contexts. + SetConversationPriorityName(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + BROKER() antlr.TerminalNode + PRIORITY() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_broker_priorityContext differentiates from other interfaces. + IsDrop_broker_priorityContext() +} + +type Drop_broker_priorityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ConversationPriorityName IId_Context +} + +func NewEmptyDrop_broker_priorityContext() *Drop_broker_priorityContext { + var p = new(Drop_broker_priorityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_broker_priority + return p +} + +func InitEmptyDrop_broker_priorityContext(p *Drop_broker_priorityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_broker_priority +} + +func (*Drop_broker_priorityContext) IsDrop_broker_priorityContext() {} + +func NewDrop_broker_priorityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_broker_priorityContext { + var p = new(Drop_broker_priorityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_broker_priority + + return p +} + +func (s *Drop_broker_priorityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_broker_priorityContext) GetConversationPriorityName() IId_Context { + return s.ConversationPriorityName +} + +func (s *Drop_broker_priorityContext) SetConversationPriorityName(v IId_Context) { + s.ConversationPriorityName = v +} + +func (s *Drop_broker_priorityContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_broker_priorityContext) BROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserBROKER, 0) +} + +func (s *Drop_broker_priorityContext) PRIORITY() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIORITY, 0) +} + +func (s *Drop_broker_priorityContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_broker_priorityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_broker_priorityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_broker_priorityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_broker_priority(s) + } +} + +func (s *Drop_broker_priorityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_broker_priority(s) + } +} + +func (s *Drop_broker_priorityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_broker_priority(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_broker_priority() (localctx IDrop_broker_priorityContext) { + localctx = NewDrop_broker_priorityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 172, TSqlParserRULE_drop_broker_priority) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2676) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2677) + p.Match(TSqlParserBROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2678) + p.Match(TSqlParserPRIORITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2679) + + var _x = p.Id_() + + localctx.(*Drop_broker_priorityContext).ConversationPriorityName = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_certificateContext is an interface to support dynamic dispatch. +type IAlter_certificateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCertificate_name returns the certificate_name rule contexts. + GetCertificate_name() IId_Context + + // SetCertificate_name sets the certificate_name rule contexts. + SetCertificate_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + Id_() IId_Context + REMOVE() antlr.TerminalNode + PRIVATE_KEY() antlr.TerminalNode + WITH() antlr.TerminalNode + PRIVATE() antlr.TerminalNode + KEY() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + ACTIVE() antlr.TerminalNode + FOR() antlr.TerminalNode + BEGIN_DIALOG() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + AllFILE() []antlr.TerminalNode + FILE(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllDECRYPTION() []antlr.TerminalNode + DECRYPTION(i int) antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + AllPASSWORD() []antlr.TerminalNode + PASSWORD(i int) antlr.TerminalNode + AllENCRYPTION() []antlr.TerminalNode + ENCRYPTION(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_certificateContext differentiates from other interfaces. + IsAlter_certificateContext() +} + +type Alter_certificateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + certificate_name IId_Context +} + +func NewEmptyAlter_certificateContext() *Alter_certificateContext { + var p = new(Alter_certificateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_certificate + return p +} + +func InitEmptyAlter_certificateContext(p *Alter_certificateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_certificate +} + +func (*Alter_certificateContext) IsAlter_certificateContext() {} + +func NewAlter_certificateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_certificateContext { + var p = new(Alter_certificateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_certificate + + return p +} + +func (s *Alter_certificateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_certificateContext) GetCertificate_name() IId_Context { return s.certificate_name } + +func (s *Alter_certificateContext) SetCertificate_name(v IId_Context) { s.certificate_name = v } + +func (s *Alter_certificateContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_certificateContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Alter_certificateContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_certificateContext) REMOVE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOVE, 0) +} + +func (s *Alter_certificateContext) PRIVATE_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIVATE_KEY, 0) +} + +func (s *Alter_certificateContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_certificateContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIVATE, 0) +} + +func (s *Alter_certificateContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Alter_certificateContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Alter_certificateContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Alter_certificateContext) ACTIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserACTIVE, 0) +} + +func (s *Alter_certificateContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Alter_certificateContext) BEGIN_DIALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserBEGIN_DIALOG, 0) +} + +func (s *Alter_certificateContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_certificateContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_certificateContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Alter_certificateContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Alter_certificateContext) AllFILE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFILE) +} + +func (s *Alter_certificateContext) FILE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, i) +} + +func (s *Alter_certificateContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Alter_certificateContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Alter_certificateContext) AllDECRYPTION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECRYPTION) +} + +func (s *Alter_certificateContext) DECRYPTION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECRYPTION, i) +} + +func (s *Alter_certificateContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBY) +} + +func (s *Alter_certificateContext) BY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBY, i) +} + +func (s *Alter_certificateContext) AllPASSWORD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserPASSWORD) +} + +func (s *Alter_certificateContext) PASSWORD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, i) +} + +func (s *Alter_certificateContext) AllENCRYPTION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserENCRYPTION) +} + +func (s *Alter_certificateContext) ENCRYPTION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, i) +} + +func (s *Alter_certificateContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_certificateContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_certificateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_certificateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_certificateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_certificate(s) + } +} + +func (s *Alter_certificateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_certificate(s) + } +} + +func (s *Alter_certificateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_certificate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_certificate() (localctx IAlter_certificateContext) { + localctx = NewAlter_certificateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 174, TSqlParserRULE_alter_certificate) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2681) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2682) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2683) + + var _x = p.Id_() + + localctx.(*Alter_certificateContext).certificate_name = _x + } + p.SetState(2723) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 175, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2684) + p.Match(TSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2685) + p.Match(TSqlParserPRIVATE_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(2686) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2687) + p.Match(TSqlParserPRIVATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2688) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2689) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserDECRYPTION || _la == TSqlParserENCRYPTION || _la == TSqlParserFILE { + p.SetState(2712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFILE: + { + p.SetState(2690) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2691) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2692) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2694) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2693) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserDECRYPTION: + { + p.SetState(2696) + p.Match(TSqlParserDECRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2697) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2698) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2699) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2700) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2702) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2701) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserENCRYPTION: + { + p.SetState(2704) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2705) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2706) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2707) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2708) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2710) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2709) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(2714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2716) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(2717) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2718) + p.Match(TSqlParserACTIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2719) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2720) + p.Match(TSqlParserBEGIN_DIALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2721) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2722) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_column_encryption_keyContext is an interface to support dynamic dispatch. +type IAlter_column_encryption_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAlgorithm_name returns the algorithm_name token. + GetAlgorithm_name() antlr.Token + + // SetAlgorithm_name sets the algorithm_name token. + SetAlgorithm_name(antlr.Token) + + // GetColumn_encryption_key returns the column_encryption_key rule contexts. + GetColumn_encryption_key() IId_Context + + // GetColumn_master_key_name returns the column_master_key_name rule contexts. + GetColumn_master_key_name() IId_Context + + // SetColumn_encryption_key sets the column_encryption_key rule contexts. + SetColumn_encryption_key(IId_Context) + + // SetColumn_master_key_name sets the column_master_key_name rule contexts. + SetColumn_master_key_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + COLUMN() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + KEY() antlr.TerminalNode + VALUE() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + COLUMN_MASTER_KEY() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ALGORITHM() antlr.TerminalNode + ENCRYPTED_VALUE() antlr.TerminalNode + BINARY() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsAlter_column_encryption_keyContext differentiates from other interfaces. + IsAlter_column_encryption_keyContext() +} + +type Alter_column_encryption_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + column_encryption_key IId_Context + column_master_key_name IId_Context + algorithm_name antlr.Token +} + +func NewEmptyAlter_column_encryption_keyContext() *Alter_column_encryption_keyContext { + var p = new(Alter_column_encryption_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_column_encryption_key + return p +} + +func InitEmptyAlter_column_encryption_keyContext(p *Alter_column_encryption_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_column_encryption_key +} + +func (*Alter_column_encryption_keyContext) IsAlter_column_encryption_keyContext() {} + +func NewAlter_column_encryption_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_column_encryption_keyContext { + var p = new(Alter_column_encryption_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_column_encryption_key + + return p +} + +func (s *Alter_column_encryption_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_column_encryption_keyContext) GetAlgorithm_name() antlr.Token { return s.algorithm_name } + +func (s *Alter_column_encryption_keyContext) SetAlgorithm_name(v antlr.Token) { s.algorithm_name = v } + +func (s *Alter_column_encryption_keyContext) GetColumn_encryption_key() IId_Context { + return s.column_encryption_key +} + +func (s *Alter_column_encryption_keyContext) GetColumn_master_key_name() IId_Context { + return s.column_master_key_name +} + +func (s *Alter_column_encryption_keyContext) SetColumn_encryption_key(v IId_Context) { + s.column_encryption_key = v +} + +func (s *Alter_column_encryption_keyContext) SetColumn_master_key_name(v IId_Context) { + s.column_master_key_name = v +} + +func (s *Alter_column_encryption_keyContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_column_encryption_keyContext) COLUMN() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMN, 0) +} + +func (s *Alter_column_encryption_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Alter_column_encryption_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Alter_column_encryption_keyContext) VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserVALUE, 0) +} + +func (s *Alter_column_encryption_keyContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Alter_column_encryption_keyContext) COLUMN_MASTER_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMN_MASTER_KEY, 0) +} + +func (s *Alter_column_encryption_keyContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_column_encryption_keyContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_column_encryption_keyContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Alter_column_encryption_keyContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_column_encryption_keyContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_column_encryption_keyContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_column_encryption_keyContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Alter_column_encryption_keyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_column_encryption_keyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_column_encryption_keyContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(TSqlParserALGORITHM, 0) +} + +func (s *Alter_column_encryption_keyContext) ENCRYPTED_VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTED_VALUE, 0) +} + +func (s *Alter_column_encryption_keyContext) BINARY() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY, 0) +} + +func (s *Alter_column_encryption_keyContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Alter_column_encryption_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_column_encryption_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_column_encryption_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_column_encryption_key(s) + } +} + +func (s *Alter_column_encryption_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_column_encryption_key(s) + } +} + +func (s *Alter_column_encryption_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_column_encryption_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_column_encryption_key() (localctx IAlter_column_encryption_keyContext) { + localctx = NewAlter_column_encryption_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 176, TSqlParserRULE_alter_column_encryption_key) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2725) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2726) + p.Match(TSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2727) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2728) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2729) + + var _x = p.Id_() + + localctx.(*Alter_column_encryption_keyContext).column_encryption_key = _x + } + { + p.SetState(2730) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserADD || _la == TSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2731) + p.Match(TSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2732) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2733) + p.Match(TSqlParserCOLUMN_MASTER_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2734) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2735) + + var _x = p.Id_() + + localctx.(*Alter_column_encryption_keyContext).column_master_key_name = _x + } + p.SetState(2744) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2736) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2737) + p.Match(TSqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2738) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2739) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_column_encryption_keyContext).algorithm_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2740) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2741) + p.Match(TSqlParserENCRYPTED_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2742) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2743) + p.Match(TSqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2746) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_column_encryption_keyContext is an interface to support dynamic dispatch. +type ICreate_column_encryption_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAlgorithm_name returns the algorithm_name token. + GetAlgorithm_name() antlr.Token + + // GetEncrypted_value returns the encrypted_value token. + GetEncrypted_value() antlr.Token + + // SetAlgorithm_name sets the algorithm_name token. + SetAlgorithm_name(antlr.Token) + + // SetEncrypted_value sets the encrypted_value token. + SetEncrypted_value(antlr.Token) + + // GetColumn_encryption_key returns the column_encryption_key rule contexts. + GetColumn_encryption_key() IId_Context + + // GetColumn_master_key_name returns the column_master_key_name rule contexts. + GetColumn_master_key_name() IId_Context + + // SetColumn_encryption_key sets the column_encryption_key rule contexts. + SetColumn_encryption_key(IId_Context) + + // SetColumn_master_key_name sets the column_master_key_name rule contexts. + SetColumn_master_key_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + COLUMN() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + KEY() antlr.TerminalNode + WITH() antlr.TerminalNode + VALUES() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllCOLUMN_MASTER_KEY() []antlr.TerminalNode + COLUMN_MASTER_KEY(i int) antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllALGORITHM() []antlr.TerminalNode + ALGORITHM(i int) antlr.TerminalNode + AllENCRYPTED_VALUE() []antlr.TerminalNode + ENCRYPTED_VALUE(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllBINARY() []antlr.TerminalNode + BINARY(i int) antlr.TerminalNode + + // IsCreate_column_encryption_keyContext differentiates from other interfaces. + IsCreate_column_encryption_keyContext() +} + +type Create_column_encryption_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + column_encryption_key IId_Context + column_master_key_name IId_Context + algorithm_name antlr.Token + encrypted_value antlr.Token +} + +func NewEmptyCreate_column_encryption_keyContext() *Create_column_encryption_keyContext { + var p = new(Create_column_encryption_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_column_encryption_key + return p +} + +func InitEmptyCreate_column_encryption_keyContext(p *Create_column_encryption_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_column_encryption_key +} + +func (*Create_column_encryption_keyContext) IsCreate_column_encryption_keyContext() {} + +func NewCreate_column_encryption_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_column_encryption_keyContext { + var p = new(Create_column_encryption_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_column_encryption_key + + return p +} + +func (s *Create_column_encryption_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_column_encryption_keyContext) GetAlgorithm_name() antlr.Token { + return s.algorithm_name +} + +func (s *Create_column_encryption_keyContext) GetEncrypted_value() antlr.Token { + return s.encrypted_value +} + +func (s *Create_column_encryption_keyContext) SetAlgorithm_name(v antlr.Token) { s.algorithm_name = v } + +func (s *Create_column_encryption_keyContext) SetEncrypted_value(v antlr.Token) { + s.encrypted_value = v +} + +func (s *Create_column_encryption_keyContext) GetColumn_encryption_key() IId_Context { + return s.column_encryption_key +} + +func (s *Create_column_encryption_keyContext) GetColumn_master_key_name() IId_Context { + return s.column_master_key_name +} + +func (s *Create_column_encryption_keyContext) SetColumn_encryption_key(v IId_Context) { + s.column_encryption_key = v +} + +func (s *Create_column_encryption_keyContext) SetColumn_master_key_name(v IId_Context) { + s.column_master_key_name = v +} + +func (s *Create_column_encryption_keyContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_column_encryption_keyContext) COLUMN() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMN, 0) +} + +func (s *Create_column_encryption_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Create_column_encryption_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Create_column_encryption_keyContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_column_encryption_keyContext) VALUES() antlr.TerminalNode { + return s.GetToken(TSqlParserVALUES, 0) +} + +func (s *Create_column_encryption_keyContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_column_encryption_keyContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_column_encryption_keyContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Create_column_encryption_keyContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Create_column_encryption_keyContext) AllCOLUMN_MASTER_KEY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOLUMN_MASTER_KEY) +} + +func (s *Create_column_encryption_keyContext) COLUMN_MASTER_KEY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMN_MASTER_KEY, i) +} + +func (s *Create_column_encryption_keyContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_column_encryption_keyContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_column_encryption_keyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_column_encryption_keyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_column_encryption_keyContext) AllALGORITHM() []antlr.TerminalNode { + return s.GetTokens(TSqlParserALGORITHM) +} + +func (s *Create_column_encryption_keyContext) ALGORITHM(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserALGORITHM, i) +} + +func (s *Create_column_encryption_keyContext) AllENCRYPTED_VALUE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserENCRYPTED_VALUE) +} + +func (s *Create_column_encryption_keyContext) ENCRYPTED_VALUE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTED_VALUE, i) +} + +func (s *Create_column_encryption_keyContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Create_column_encryption_keyContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Create_column_encryption_keyContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Create_column_encryption_keyContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Create_column_encryption_keyContext) AllBINARY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBINARY) +} + +func (s *Create_column_encryption_keyContext) BINARY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY, i) +} + +func (s *Create_column_encryption_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_column_encryption_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_column_encryption_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_column_encryption_key(s) + } +} + +func (s *Create_column_encryption_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_column_encryption_key(s) + } +} + +func (s *Create_column_encryption_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_column_encryption_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_column_encryption_key() (localctx ICreate_column_encryption_keyContext) { + localctx = NewCreate_column_encryption_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 178, TSqlParserRULE_create_column_encryption_key) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2748) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2749) + p.Match(TSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2750) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2751) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2752) + + var _x = p.Id_() + + localctx.(*Create_column_encryption_keyContext).column_encryption_key = _x + } + { + p.SetState(2753) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2754) + p.Match(TSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2774) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(2755) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2756) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2759) + p.Match(TSqlParserCOLUMN_MASTER_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2760) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2761) + + var _x = p.Id_() + + localctx.(*Create_column_encryption_keyContext).column_master_key_name = _x + } + { + p.SetState(2762) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2763) + p.Match(TSqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2764) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2765) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_column_encryption_keyContext).algorithm_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2766) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2767) + p.Match(TSqlParserENCRYPTED_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2768) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2769) + + var _m = p.Match(TSqlParserBINARY) + + localctx.(*Create_column_encryption_keyContext).encrypted_value = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2770) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2772) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2771) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(2776) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 179, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_certificateContext is an interface to support dynamic dispatch. +type IDrop_certificateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCertificate_name returns the certificate_name rule contexts. + GetCertificate_name() IId_Context + + // SetCertificate_name sets the certificate_name rule contexts. + SetCertificate_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_certificateContext differentiates from other interfaces. + IsDrop_certificateContext() +} + +type Drop_certificateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + certificate_name IId_Context +} + +func NewEmptyDrop_certificateContext() *Drop_certificateContext { + var p = new(Drop_certificateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_certificate + return p +} + +func InitEmptyDrop_certificateContext(p *Drop_certificateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_certificate +} + +func (*Drop_certificateContext) IsDrop_certificateContext() {} + +func NewDrop_certificateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_certificateContext { + var p = new(Drop_certificateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_certificate + + return p +} + +func (s *Drop_certificateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_certificateContext) GetCertificate_name() IId_Context { return s.certificate_name } + +func (s *Drop_certificateContext) SetCertificate_name(v IId_Context) { s.certificate_name = v } + +func (s *Drop_certificateContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_certificateContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Drop_certificateContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_certificateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_certificateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_certificateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_certificate(s) + } +} + +func (s *Drop_certificateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_certificate(s) + } +} + +func (s *Drop_certificateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_certificate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_certificate() (localctx IDrop_certificateContext) { + localctx = NewDrop_certificateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 180, TSqlParserRULE_drop_certificate) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2778) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2779) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2780) + + var _x = p.Id_() + + localctx.(*Drop_certificateContext).certificate_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_column_encryption_keyContext is an interface to support dynamic dispatch. +type IDrop_column_encryption_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKey_name returns the key_name rule contexts. + GetKey_name() IId_Context + + // SetKey_name sets the key_name rule contexts. + SetKey_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + COLUMN() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + KEY() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_column_encryption_keyContext differentiates from other interfaces. + IsDrop_column_encryption_keyContext() +} + +type Drop_column_encryption_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + key_name IId_Context +} + +func NewEmptyDrop_column_encryption_keyContext() *Drop_column_encryption_keyContext { + var p = new(Drop_column_encryption_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_column_encryption_key + return p +} + +func InitEmptyDrop_column_encryption_keyContext(p *Drop_column_encryption_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_column_encryption_key +} + +func (*Drop_column_encryption_keyContext) IsDrop_column_encryption_keyContext() {} + +func NewDrop_column_encryption_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_column_encryption_keyContext { + var p = new(Drop_column_encryption_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_column_encryption_key + + return p +} + +func (s *Drop_column_encryption_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_column_encryption_keyContext) GetKey_name() IId_Context { return s.key_name } + +func (s *Drop_column_encryption_keyContext) SetKey_name(v IId_Context) { s.key_name = v } + +func (s *Drop_column_encryption_keyContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_column_encryption_keyContext) COLUMN() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMN, 0) +} + +func (s *Drop_column_encryption_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Drop_column_encryption_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Drop_column_encryption_keyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_column_encryption_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_column_encryption_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_column_encryption_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_column_encryption_key(s) + } +} + +func (s *Drop_column_encryption_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_column_encryption_key(s) + } +} + +func (s *Drop_column_encryption_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_column_encryption_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_column_encryption_key() (localctx IDrop_column_encryption_keyContext) { + localctx = NewDrop_column_encryption_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 182, TSqlParserRULE_drop_column_encryption_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2782) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2783) + p.Match(TSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2784) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2785) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2786) + + var _x = p.Id_() + + localctx.(*Drop_column_encryption_keyContext).key_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_column_master_keyContext is an interface to support dynamic dispatch. +type IDrop_column_master_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKey_name returns the key_name rule contexts. + GetKey_name() IId_Context + + // SetKey_name sets the key_name rule contexts. + SetKey_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + COLUMN() antlr.TerminalNode + MASTER() antlr.TerminalNode + KEY() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_column_master_keyContext differentiates from other interfaces. + IsDrop_column_master_keyContext() +} + +type Drop_column_master_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + key_name IId_Context +} + +func NewEmptyDrop_column_master_keyContext() *Drop_column_master_keyContext { + var p = new(Drop_column_master_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_column_master_key + return p +} + +func InitEmptyDrop_column_master_keyContext(p *Drop_column_master_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_column_master_key +} + +func (*Drop_column_master_keyContext) IsDrop_column_master_keyContext() {} + +func NewDrop_column_master_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_column_master_keyContext { + var p = new(Drop_column_master_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_column_master_key + + return p +} + +func (s *Drop_column_master_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_column_master_keyContext) GetKey_name() IId_Context { return s.key_name } + +func (s *Drop_column_master_keyContext) SetKey_name(v IId_Context) { s.key_name = v } + +func (s *Drop_column_master_keyContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_column_master_keyContext) COLUMN() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMN, 0) +} + +func (s *Drop_column_master_keyContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *Drop_column_master_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Drop_column_master_keyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_column_master_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_column_master_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_column_master_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_column_master_key(s) + } +} + +func (s *Drop_column_master_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_column_master_key(s) + } +} + +func (s *Drop_column_master_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_column_master_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_column_master_key() (localctx IDrop_column_master_keyContext) { + localctx = NewDrop_column_master_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 184, TSqlParserRULE_drop_column_master_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2788) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2789) + p.Match(TSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2790) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2791) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2792) + + var _x = p.Id_() + + localctx.(*Drop_column_master_keyContext).key_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_contractContext is an interface to support dynamic dispatch. +type IDrop_contractContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDropped_contract_name returns the dropped_contract_name rule contexts. + GetDropped_contract_name() IId_Context + + // SetDropped_contract_name sets the dropped_contract_name rule contexts. + SetDropped_contract_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + CONTRACT() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_contractContext differentiates from other interfaces. + IsDrop_contractContext() +} + +type Drop_contractContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dropped_contract_name IId_Context +} + +func NewEmptyDrop_contractContext() *Drop_contractContext { + var p = new(Drop_contractContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_contract + return p +} + +func InitEmptyDrop_contractContext(p *Drop_contractContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_contract +} + +func (*Drop_contractContext) IsDrop_contractContext() {} + +func NewDrop_contractContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_contractContext { + var p = new(Drop_contractContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_contract + + return p +} + +func (s *Drop_contractContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_contractContext) GetDropped_contract_name() IId_Context { return s.dropped_contract_name } + +func (s *Drop_contractContext) SetDropped_contract_name(v IId_Context) { s.dropped_contract_name = v } + +func (s *Drop_contractContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_contractContext) CONTRACT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTRACT, 0) +} + +func (s *Drop_contractContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_contractContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_contractContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_contractContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_contract(s) + } +} + +func (s *Drop_contractContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_contract(s) + } +} + +func (s *Drop_contractContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_contract(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_contract() (localctx IDrop_contractContext) { + localctx = NewDrop_contractContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 186, TSqlParserRULE_drop_contract) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2794) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2795) + p.Match(TSqlParserCONTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2796) + + var _x = p.Id_() + + localctx.(*Drop_contractContext).dropped_contract_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_credentialContext is an interface to support dynamic dispatch. +type IDrop_credentialContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCredential_name returns the credential_name rule contexts. + GetCredential_name() IId_Context + + // SetCredential_name sets the credential_name rule contexts. + SetCredential_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + CREDENTIAL() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_credentialContext differentiates from other interfaces. + IsDrop_credentialContext() +} + +type Drop_credentialContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + credential_name IId_Context +} + +func NewEmptyDrop_credentialContext() *Drop_credentialContext { + var p = new(Drop_credentialContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_credential + return p +} + +func InitEmptyDrop_credentialContext(p *Drop_credentialContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_credential +} + +func (*Drop_credentialContext) IsDrop_credentialContext() {} + +func NewDrop_credentialContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_credentialContext { + var p = new(Drop_credentialContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_credential + + return p +} + +func (s *Drop_credentialContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_credentialContext) GetCredential_name() IId_Context { return s.credential_name } + +func (s *Drop_credentialContext) SetCredential_name(v IId_Context) { s.credential_name = v } + +func (s *Drop_credentialContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_credentialContext) CREDENTIAL() antlr.TerminalNode { + return s.GetToken(TSqlParserCREDENTIAL, 0) +} + +func (s *Drop_credentialContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_credentialContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_credentialContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_credentialContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_credential(s) + } +} + +func (s *Drop_credentialContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_credential(s) + } +} + +func (s *Drop_credentialContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_credential(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_credential() (localctx IDrop_credentialContext) { + localctx = NewDrop_credentialContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 188, TSqlParserRULE_drop_credential) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2798) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2799) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2800) + + var _x = p.Id_() + + localctx.(*Drop_credentialContext).credential_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_cryptograhic_providerContext is an interface to support dynamic dispatch. +type IDrop_cryptograhic_providerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetProvider_name returns the provider_name rule contexts. + GetProvider_name() IId_Context + + // SetProvider_name sets the provider_name rule contexts. + SetProvider_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + CRYPTOGRAPHIC() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_cryptograhic_providerContext differentiates from other interfaces. + IsDrop_cryptograhic_providerContext() +} + +type Drop_cryptograhic_providerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + provider_name IId_Context +} + +func NewEmptyDrop_cryptograhic_providerContext() *Drop_cryptograhic_providerContext { + var p = new(Drop_cryptograhic_providerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_cryptograhic_provider + return p +} + +func InitEmptyDrop_cryptograhic_providerContext(p *Drop_cryptograhic_providerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_cryptograhic_provider +} + +func (*Drop_cryptograhic_providerContext) IsDrop_cryptograhic_providerContext() {} + +func NewDrop_cryptograhic_providerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_cryptograhic_providerContext { + var p = new(Drop_cryptograhic_providerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_cryptograhic_provider + + return p +} + +func (s *Drop_cryptograhic_providerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_cryptograhic_providerContext) GetProvider_name() IId_Context { return s.provider_name } + +func (s *Drop_cryptograhic_providerContext) SetProvider_name(v IId_Context) { s.provider_name = v } + +func (s *Drop_cryptograhic_providerContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_cryptograhic_providerContext) CRYPTOGRAPHIC() antlr.TerminalNode { + return s.GetToken(TSqlParserCRYPTOGRAPHIC, 0) +} + +func (s *Drop_cryptograhic_providerContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER, 0) +} + +func (s *Drop_cryptograhic_providerContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_cryptograhic_providerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_cryptograhic_providerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_cryptograhic_providerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_cryptograhic_provider(s) + } +} + +func (s *Drop_cryptograhic_providerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_cryptograhic_provider(s) + } +} + +func (s *Drop_cryptograhic_providerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_cryptograhic_provider(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_cryptograhic_provider() (localctx IDrop_cryptograhic_providerContext) { + localctx = NewDrop_cryptograhic_providerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 190, TSqlParserRULE_drop_cryptograhic_provider) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2802) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2803) + p.Match(TSqlParserCRYPTOGRAPHIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2804) + p.Match(TSqlParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2805) + + var _x = p.Id_() + + localctx.(*Drop_cryptograhic_providerContext).provider_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_databaseContext is an interface to support dynamic dispatch. +type IDrop_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatabase_name_or_database_snapshot_name returns the database_name_or_database_snapshot_name rule contexts. + GetDatabase_name_or_database_snapshot_name() IId_Context + + // SetDatabase_name_or_database_snapshot_name sets the database_name_or_database_snapshot_name rule contexts. + SetDatabase_name_or_database_snapshot_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + DATABASE() antlr.TerminalNode + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDrop_databaseContext differentiates from other interfaces. + IsDrop_databaseContext() +} + +type Drop_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database_name_or_database_snapshot_name IId_Context +} + +func NewEmptyDrop_databaseContext() *Drop_databaseContext { + var p = new(Drop_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_database + return p +} + +func InitEmptyDrop_databaseContext(p *Drop_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_database +} + +func (*Drop_databaseContext) IsDrop_databaseContext() {} + +func NewDrop_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_databaseContext { + var p = new(Drop_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_database + + return p +} + +func (s *Drop_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_databaseContext) GetDatabase_name_or_database_snapshot_name() IId_Context { + return s.database_name_or_database_snapshot_name +} + +func (s *Drop_databaseContext) SetDatabase_name_or_database_snapshot_name(v IId_Context) { + s.database_name_or_database_snapshot_name = v +} + +func (s *Drop_databaseContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Drop_databaseContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_databaseContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_databaseContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_databaseContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_databaseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Drop_databaseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Drop_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_database(s) + } +} + +func (s *Drop_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_database(s) + } +} + +func (s *Drop_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_database() (localctx IDrop_databaseContext) { + localctx = NewDrop_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 192, TSqlParserRULE_drop_database) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2807) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2808) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(2809) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2810) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(2814) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2813) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2816) + + var _x = p.Id_() + + localctx.(*Drop_databaseContext).database_name_or_database_snapshot_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(2819) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 182, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_database_audit_specificationContext is an interface to support dynamic dispatch. +type IDrop_database_audit_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAudit_specification_name returns the audit_specification_name rule contexts. + GetAudit_specification_name() IId_Context + + // SetAudit_specification_name sets the audit_specification_name rule contexts. + SetAudit_specification_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + DATABASE() antlr.TerminalNode + AUDIT() antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_database_audit_specificationContext differentiates from other interfaces. + IsDrop_database_audit_specificationContext() +} + +type Drop_database_audit_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + audit_specification_name IId_Context +} + +func NewEmptyDrop_database_audit_specificationContext() *Drop_database_audit_specificationContext { + var p = new(Drop_database_audit_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_database_audit_specification + return p +} + +func InitEmptyDrop_database_audit_specificationContext(p *Drop_database_audit_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_database_audit_specification +} + +func (*Drop_database_audit_specificationContext) IsDrop_database_audit_specificationContext() {} + +func NewDrop_database_audit_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_database_audit_specificationContext { + var p = new(Drop_database_audit_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_database_audit_specification + + return p +} + +func (s *Drop_database_audit_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_database_audit_specificationContext) GetAudit_specification_name() IId_Context { + return s.audit_specification_name +} + +func (s *Drop_database_audit_specificationContext) SetAudit_specification_name(v IId_Context) { + s.audit_specification_name = v +} + +func (s *Drop_database_audit_specificationContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_database_audit_specificationContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Drop_database_audit_specificationContext) AUDIT() antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT, 0) +} + +func (s *Drop_database_audit_specificationContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserSPECIFICATION, 0) +} + +func (s *Drop_database_audit_specificationContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_database_audit_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_database_audit_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_database_audit_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_database_audit_specification(s) + } +} + +func (s *Drop_database_audit_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_database_audit_specification(s) + } +} + +func (s *Drop_database_audit_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_database_audit_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_database_audit_specification() (localctx IDrop_database_audit_specificationContext) { + localctx = NewDrop_database_audit_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 194, TSqlParserRULE_drop_database_audit_specification) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2821) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2822) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2823) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2824) + p.Match(TSqlParserSPECIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2825) + + var _x = p.Id_() + + localctx.(*Drop_database_audit_specificationContext).audit_specification_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_database_encryption_keyContext is an interface to support dynamic dispatch. +type IDrop_database_encryption_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + DATABASE() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + KEY() antlr.TerminalNode + + // IsDrop_database_encryption_keyContext differentiates from other interfaces. + IsDrop_database_encryption_keyContext() +} + +type Drop_database_encryption_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_database_encryption_keyContext() *Drop_database_encryption_keyContext { + var p = new(Drop_database_encryption_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_database_encryption_key + return p +} + +func InitEmptyDrop_database_encryption_keyContext(p *Drop_database_encryption_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_database_encryption_key +} + +func (*Drop_database_encryption_keyContext) IsDrop_database_encryption_keyContext() {} + +func NewDrop_database_encryption_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_database_encryption_keyContext { + var p = new(Drop_database_encryption_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_database_encryption_key + + return p +} + +func (s *Drop_database_encryption_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_database_encryption_keyContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_database_encryption_keyContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Drop_database_encryption_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Drop_database_encryption_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Drop_database_encryption_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_database_encryption_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_database_encryption_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_database_encryption_key(s) + } +} + +func (s *Drop_database_encryption_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_database_encryption_key(s) + } +} + +func (s *Drop_database_encryption_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_database_encryption_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_database_encryption_key() (localctx IDrop_database_encryption_keyContext) { + localctx = NewDrop_database_encryption_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 196, TSqlParserRULE_drop_database_encryption_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2827) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2828) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2829) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2830) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_database_scoped_credentialContext is an interface to support dynamic dispatch. +type IDrop_database_scoped_credentialContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCredential_name returns the credential_name rule contexts. + GetCredential_name() IId_Context + + // SetCredential_name sets the credential_name rule contexts. + SetCredential_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SCOPED() antlr.TerminalNode + CREDENTIAL() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_database_scoped_credentialContext differentiates from other interfaces. + IsDrop_database_scoped_credentialContext() +} + +type Drop_database_scoped_credentialContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + credential_name IId_Context +} + +func NewEmptyDrop_database_scoped_credentialContext() *Drop_database_scoped_credentialContext { + var p = new(Drop_database_scoped_credentialContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_database_scoped_credential + return p +} + +func InitEmptyDrop_database_scoped_credentialContext(p *Drop_database_scoped_credentialContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_database_scoped_credential +} + +func (*Drop_database_scoped_credentialContext) IsDrop_database_scoped_credentialContext() {} + +func NewDrop_database_scoped_credentialContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_database_scoped_credentialContext { + var p = new(Drop_database_scoped_credentialContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_database_scoped_credential + + return p +} + +func (s *Drop_database_scoped_credentialContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_database_scoped_credentialContext) GetCredential_name() IId_Context { + return s.credential_name +} + +func (s *Drop_database_scoped_credentialContext) SetCredential_name(v IId_Context) { + s.credential_name = v +} + +func (s *Drop_database_scoped_credentialContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_database_scoped_credentialContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Drop_database_scoped_credentialContext) SCOPED() antlr.TerminalNode { + return s.GetToken(TSqlParserSCOPED, 0) +} + +func (s *Drop_database_scoped_credentialContext) CREDENTIAL() antlr.TerminalNode { + return s.GetToken(TSqlParserCREDENTIAL, 0) +} + +func (s *Drop_database_scoped_credentialContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_database_scoped_credentialContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_database_scoped_credentialContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_database_scoped_credentialContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_database_scoped_credential(s) + } +} + +func (s *Drop_database_scoped_credentialContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_database_scoped_credential(s) + } +} + +func (s *Drop_database_scoped_credentialContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_database_scoped_credential(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_database_scoped_credential() (localctx IDrop_database_scoped_credentialContext) { + localctx = NewDrop_database_scoped_credentialContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 198, TSqlParserRULE_drop_database_scoped_credential) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2832) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2833) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2834) + p.Match(TSqlParserSCOPED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2835) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2836) + + var _x = p.Id_() + + localctx.(*Drop_database_scoped_credentialContext).credential_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_defaultContext is an interface to support dynamic dispatch. +type IDrop_defaultContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetDefault_name returns the default_name rule contexts. + GetDefault_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetDefault_name sets the default_name rule contexts. + SetDefault_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + COMMA() antlr.TerminalNode + DOT() antlr.TerminalNode + + // IsDrop_defaultContext differentiates from other interfaces. + IsDrop_defaultContext() +} + +type Drop_defaultContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + default_name IId_Context +} + +func NewEmptyDrop_defaultContext() *Drop_defaultContext { + var p = new(Drop_defaultContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_default + return p +} + +func InitEmptyDrop_defaultContext(p *Drop_defaultContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_default +} + +func (*Drop_defaultContext) IsDrop_defaultContext() {} + +func NewDrop_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_defaultContext { + var p = new(Drop_defaultContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_default + + return p +} + +func (s *Drop_defaultContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_defaultContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Drop_defaultContext) GetDefault_name() IId_Context { return s.default_name } + +func (s *Drop_defaultContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Drop_defaultContext) SetDefault_name(v IId_Context) { s.default_name = v } + +func (s *Drop_defaultContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_defaultContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Drop_defaultContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_defaultContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_defaultContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_defaultContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_defaultContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Drop_defaultContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Drop_defaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_defaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_default(s) + } +} + +func (s *Drop_defaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_default(s) + } +} + +func (s *Drop_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_default(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_default() (localctx IDrop_defaultContext) { + localctx = NewDrop_defaultContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 200, TSqlParserRULE_drop_default) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2838) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2839) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2842) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(2840) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2841) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(2845) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2844) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2850) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 185, p.GetParserRuleContext()) == 1 { + { + p.SetState(2847) + + var _x = p.Id_() + + localctx.(*Drop_defaultContext).schema_name = _x + } + { + p.SetState(2848) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2852) + + var _x = p.Id_() + + localctx.(*Drop_defaultContext).default_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_endpointContext is an interface to support dynamic dispatch. +type IDrop_endpointContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEndPointName returns the endPointName rule contexts. + GetEndPointName() IId_Context + + // SetEndPointName sets the endPointName rule contexts. + SetEndPointName(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + ENDPOINT() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_endpointContext differentiates from other interfaces. + IsDrop_endpointContext() +} + +type Drop_endpointContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + endPointName IId_Context +} + +func NewEmptyDrop_endpointContext() *Drop_endpointContext { + var p = new(Drop_endpointContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_endpoint + return p +} + +func InitEmptyDrop_endpointContext(p *Drop_endpointContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_endpoint +} + +func (*Drop_endpointContext) IsDrop_endpointContext() {} + +func NewDrop_endpointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_endpointContext { + var p = new(Drop_endpointContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_endpoint + + return p +} + +func (s *Drop_endpointContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_endpointContext) GetEndPointName() IId_Context { return s.endPointName } + +func (s *Drop_endpointContext) SetEndPointName(v IId_Context) { s.endPointName = v } + +func (s *Drop_endpointContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_endpointContext) ENDPOINT() antlr.TerminalNode { + return s.GetToken(TSqlParserENDPOINT, 0) +} + +func (s *Drop_endpointContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_endpointContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_endpointContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_endpointContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_endpoint(s) + } +} + +func (s *Drop_endpointContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_endpoint(s) + } +} + +func (s *Drop_endpointContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_endpoint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_endpoint() (localctx IDrop_endpointContext) { + localctx = NewDrop_endpointContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 202, TSqlParserRULE_drop_endpoint) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2854) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2855) + p.Match(TSqlParserENDPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2856) + + var _x = p.Id_() + + localctx.(*Drop_endpointContext).endPointName = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_external_data_sourceContext is an interface to support dynamic dispatch. +type IDrop_external_data_sourceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetExternal_data_source_name returns the external_data_source_name rule contexts. + GetExternal_data_source_name() IId_Context + + // SetExternal_data_source_name sets the external_data_source_name rule contexts. + SetExternal_data_source_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + DATA() antlr.TerminalNode + SOURCE() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_external_data_sourceContext differentiates from other interfaces. + IsDrop_external_data_sourceContext() +} + +type Drop_external_data_sourceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + external_data_source_name IId_Context +} + +func NewEmptyDrop_external_data_sourceContext() *Drop_external_data_sourceContext { + var p = new(Drop_external_data_sourceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_external_data_source + return p +} + +func InitEmptyDrop_external_data_sourceContext(p *Drop_external_data_sourceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_external_data_source +} + +func (*Drop_external_data_sourceContext) IsDrop_external_data_sourceContext() {} + +func NewDrop_external_data_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_external_data_sourceContext { + var p = new(Drop_external_data_sourceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_external_data_source + + return p +} + +func (s *Drop_external_data_sourceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_external_data_sourceContext) GetExternal_data_source_name() IId_Context { + return s.external_data_source_name +} + +func (s *Drop_external_data_sourceContext) SetExternal_data_source_name(v IId_Context) { + s.external_data_source_name = v +} + +func (s *Drop_external_data_sourceContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_external_data_sourceContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Drop_external_data_sourceContext) DATA() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA, 0) +} + +func (s *Drop_external_data_sourceContext) SOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserSOURCE, 0) +} + +func (s *Drop_external_data_sourceContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_external_data_sourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_external_data_sourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_external_data_sourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_external_data_source(s) + } +} + +func (s *Drop_external_data_sourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_external_data_source(s) + } +} + +func (s *Drop_external_data_sourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_external_data_source(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_external_data_source() (localctx IDrop_external_data_sourceContext) { + localctx = NewDrop_external_data_sourceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 204, TSqlParserRULE_drop_external_data_source) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2858) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2859) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2860) + p.Match(TSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2861) + p.Match(TSqlParserSOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2862) + + var _x = p.Id_() + + localctx.(*Drop_external_data_sourceContext).external_data_source_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_external_file_formatContext is an interface to support dynamic dispatch. +type IDrop_external_file_formatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetExternal_file_format_name returns the external_file_format_name rule contexts. + GetExternal_file_format_name() IId_Context + + // SetExternal_file_format_name sets the external_file_format_name rule contexts. + SetExternal_file_format_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + FILE() antlr.TerminalNode + FORMAT() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_external_file_formatContext differentiates from other interfaces. + IsDrop_external_file_formatContext() +} + +type Drop_external_file_formatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + external_file_format_name IId_Context +} + +func NewEmptyDrop_external_file_formatContext() *Drop_external_file_formatContext { + var p = new(Drop_external_file_formatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_external_file_format + return p +} + +func InitEmptyDrop_external_file_formatContext(p *Drop_external_file_formatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_external_file_format +} + +func (*Drop_external_file_formatContext) IsDrop_external_file_formatContext() {} + +func NewDrop_external_file_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_external_file_formatContext { + var p = new(Drop_external_file_formatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_external_file_format + + return p +} + +func (s *Drop_external_file_formatContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_external_file_formatContext) GetExternal_file_format_name() IId_Context { + return s.external_file_format_name +} + +func (s *Drop_external_file_formatContext) SetExternal_file_format_name(v IId_Context) { + s.external_file_format_name = v +} + +func (s *Drop_external_file_formatContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_external_file_formatContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Drop_external_file_formatContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Drop_external_file_formatContext) FORMAT() antlr.TerminalNode { + return s.GetToken(TSqlParserFORMAT, 0) +} + +func (s *Drop_external_file_formatContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_external_file_formatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_external_file_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_external_file_formatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_external_file_format(s) + } +} + +func (s *Drop_external_file_formatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_external_file_format(s) + } +} + +func (s *Drop_external_file_formatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_external_file_format(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_external_file_format() (localctx IDrop_external_file_formatContext) { + localctx = NewDrop_external_file_formatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 206, TSqlParserRULE_drop_external_file_format) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2864) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2865) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2866) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2867) + p.Match(TSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2868) + + var _x = p.Id_() + + localctx.(*Drop_external_file_formatContext).external_file_format_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_external_libraryContext is an interface to support dynamic dispatch. +type IDrop_external_libraryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLibrary_name returns the library_name rule contexts. + GetLibrary_name() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // SetLibrary_name sets the library_name rule contexts. + SetLibrary_name(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AUTHORIZATION() antlr.TerminalNode + + // IsDrop_external_libraryContext differentiates from other interfaces. + IsDrop_external_libraryContext() +} + +type Drop_external_libraryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + library_name IId_Context + owner_name IId_Context +} + +func NewEmptyDrop_external_libraryContext() *Drop_external_libraryContext { + var p = new(Drop_external_libraryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_external_library + return p +} + +func InitEmptyDrop_external_libraryContext(p *Drop_external_libraryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_external_library +} + +func (*Drop_external_libraryContext) IsDrop_external_libraryContext() {} + +func NewDrop_external_libraryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_external_libraryContext { + var p = new(Drop_external_libraryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_external_library + + return p +} + +func (s *Drop_external_libraryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_external_libraryContext) GetLibrary_name() IId_Context { return s.library_name } + +func (s *Drop_external_libraryContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Drop_external_libraryContext) SetLibrary_name(v IId_Context) { s.library_name = v } + +func (s *Drop_external_libraryContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Drop_external_libraryContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_external_libraryContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Drop_external_libraryContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(TSqlParserLIBRARY, 0) +} + +func (s *Drop_external_libraryContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_external_libraryContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_external_libraryContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Drop_external_libraryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_external_libraryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_external_libraryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_external_library(s) + } +} + +func (s *Drop_external_libraryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_external_library(s) + } +} + +func (s *Drop_external_libraryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_external_library(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_external_library() (localctx IDrop_external_libraryContext) { + localctx = NewDrop_external_libraryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 208, TSqlParserRULE_drop_external_library) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2870) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2871) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2872) + p.Match(TSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2873) + + var _x = p.Id_() + + localctx.(*Drop_external_libraryContext).library_name = _x + } + p.SetState(2876) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(2874) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2875) + + var _x = p.Id_() + + localctx.(*Drop_external_libraryContext).owner_name = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_external_resource_poolContext is an interface to support dynamic dispatch. +type IDrop_external_resource_poolContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPool_name returns the pool_name rule contexts. + GetPool_name() IId_Context + + // SetPool_name sets the pool_name rule contexts. + SetPool_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + POOL() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_external_resource_poolContext differentiates from other interfaces. + IsDrop_external_resource_poolContext() +} + +type Drop_external_resource_poolContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + pool_name IId_Context +} + +func NewEmptyDrop_external_resource_poolContext() *Drop_external_resource_poolContext { + var p = new(Drop_external_resource_poolContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_external_resource_pool + return p +} + +func InitEmptyDrop_external_resource_poolContext(p *Drop_external_resource_poolContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_external_resource_pool +} + +func (*Drop_external_resource_poolContext) IsDrop_external_resource_poolContext() {} + +func NewDrop_external_resource_poolContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_external_resource_poolContext { + var p = new(Drop_external_resource_poolContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_external_resource_pool + + return p +} + +func (s *Drop_external_resource_poolContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_external_resource_poolContext) GetPool_name() IId_Context { return s.pool_name } + +func (s *Drop_external_resource_poolContext) SetPool_name(v IId_Context) { s.pool_name = v } + +func (s *Drop_external_resource_poolContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_external_resource_poolContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Drop_external_resource_poolContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESOURCE, 0) +} + +func (s *Drop_external_resource_poolContext) POOL() antlr.TerminalNode { + return s.GetToken(TSqlParserPOOL, 0) +} + +func (s *Drop_external_resource_poolContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_external_resource_poolContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_external_resource_poolContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_external_resource_poolContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_external_resource_pool(s) + } +} + +func (s *Drop_external_resource_poolContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_external_resource_pool(s) + } +} + +func (s *Drop_external_resource_poolContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_external_resource_pool(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_external_resource_pool() (localctx IDrop_external_resource_poolContext) { + localctx = NewDrop_external_resource_poolContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 210, TSqlParserRULE_drop_external_resource_pool) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2878) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2879) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2880) + p.Match(TSqlParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2881) + p.Match(TSqlParserPOOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2882) + + var _x = p.Id_() + + localctx.(*Drop_external_resource_poolContext).pool_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_external_tableContext is an interface to support dynamic dispatch. +type IDrop_external_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatabase_name returns the database_name rule contexts. + GetDatabase_name() IId_Context + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetTable returns the table rule contexts. + GetTable() IId_Context + + // SetDatabase_name sets the database_name rule contexts. + SetDatabase_name(IId_Context) + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetTable sets the table rule contexts. + SetTable(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsDrop_external_tableContext differentiates from other interfaces. + IsDrop_external_tableContext() +} + +type Drop_external_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database_name IId_Context + schema_name IId_Context + table IId_Context +} + +func NewEmptyDrop_external_tableContext() *Drop_external_tableContext { + var p = new(Drop_external_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_external_table + return p +} + +func InitEmptyDrop_external_tableContext(p *Drop_external_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_external_table +} + +func (*Drop_external_tableContext) IsDrop_external_tableContext() {} + +func NewDrop_external_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_external_tableContext { + var p = new(Drop_external_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_external_table + + return p +} + +func (s *Drop_external_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_external_tableContext) GetDatabase_name() IId_Context { return s.database_name } + +func (s *Drop_external_tableContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Drop_external_tableContext) GetTable() IId_Context { return s.table } + +func (s *Drop_external_tableContext) SetDatabase_name(v IId_Context) { s.database_name = v } + +func (s *Drop_external_tableContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Drop_external_tableContext) SetTable(v IId_Context) { s.table = v } + +func (s *Drop_external_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_external_tableContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Drop_external_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLE, 0) +} + +func (s *Drop_external_tableContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_external_tableContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_external_tableContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Drop_external_tableContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Drop_external_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_external_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_external_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_external_table(s) + } +} + +func (s *Drop_external_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_external_table(s) + } +} + +func (s *Drop_external_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_external_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_external_table() (localctx IDrop_external_tableContext) { + localctx = NewDrop_external_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 212, TSqlParserRULE_drop_external_table) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2884) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2885) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2886) + p.Match(TSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2890) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 187, p.GetParserRuleContext()) == 1 { + { + p.SetState(2887) + + var _x = p.Id_() + + localctx.(*Drop_external_tableContext).database_name = _x + } + { + p.SetState(2888) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2895) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 188, p.GetParserRuleContext()) == 1 { + { + p.SetState(2892) + + var _x = p.Id_() + + localctx.(*Drop_external_tableContext).schema_name = _x + } + { + p.SetState(2893) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2897) + + var _x = p.Id_() + + localctx.(*Drop_external_tableContext).table = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_event_notificationsContext is an interface to support dynamic dispatch. +type IDrop_event_notificationsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNotification_name returns the notification_name rule contexts. + GetNotification_name() IId_Context + + // GetQueue_name returns the queue_name rule contexts. + GetQueue_name() IId_Context + + // SetNotification_name sets the notification_name rule contexts. + SetNotification_name(IId_Context) + + // SetQueue_name sets the queue_name rule contexts. + SetQueue_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + EVENT() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + ON() antlr.TerminalNode + SERVER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + QUEUE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDrop_event_notificationsContext differentiates from other interfaces. + IsDrop_event_notificationsContext() +} + +type Drop_event_notificationsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + notification_name IId_Context + queue_name IId_Context +} + +func NewEmptyDrop_event_notificationsContext() *Drop_event_notificationsContext { + var p = new(Drop_event_notificationsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_event_notifications + return p +} + +func InitEmptyDrop_event_notificationsContext(p *Drop_event_notificationsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_event_notifications +} + +func (*Drop_event_notificationsContext) IsDrop_event_notificationsContext() {} + +func NewDrop_event_notificationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_event_notificationsContext { + var p = new(Drop_event_notificationsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_event_notifications + + return p +} + +func (s *Drop_event_notificationsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_event_notificationsContext) GetNotification_name() IId_Context { + return s.notification_name +} + +func (s *Drop_event_notificationsContext) GetQueue_name() IId_Context { return s.queue_name } + +func (s *Drop_event_notificationsContext) SetNotification_name(v IId_Context) { + s.notification_name = v +} + +func (s *Drop_event_notificationsContext) SetQueue_name(v IId_Context) { s.queue_name = v } + +func (s *Drop_event_notificationsContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_event_notificationsContext) EVENT() antlr.TerminalNode { + return s.GetToken(TSqlParserEVENT, 0) +} + +func (s *Drop_event_notificationsContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserNOTIFICATION, 0) +} + +func (s *Drop_event_notificationsContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Drop_event_notificationsContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Drop_event_notificationsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Drop_event_notificationsContext) QUEUE() antlr.TerminalNode { + return s.GetToken(TSqlParserQUEUE, 0) +} + +func (s *Drop_event_notificationsContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_event_notificationsContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_event_notificationsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Drop_event_notificationsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Drop_event_notificationsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_event_notificationsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_event_notificationsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_event_notifications(s) + } +} + +func (s *Drop_event_notificationsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_event_notifications(s) + } +} + +func (s *Drop_event_notificationsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_event_notifications(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_event_notifications() (localctx IDrop_event_notificationsContext) { + localctx = NewDrop_event_notificationsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 214, TSqlParserRULE_drop_event_notifications) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2899) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2900) + p.Match(TSqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2901) + p.Match(TSqlParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&562949975835135) != 0) { + p.SetState(2903) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(2902) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2905) + + var _x = p.Id_() + + localctx.(*Drop_event_notificationsContext).notification_name = _x + } + + p.SetState(2908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2910) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSERVER: + { + p.SetState(2911) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDATABASE: + { + p.SetState(2912) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserQUEUE: + { + p.SetState(2913) + p.Match(TSqlParserQUEUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2914) + + var _x = p.Id_() + + localctx.(*Drop_event_notificationsContext).queue_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_event_sessionContext is an interface to support dynamic dispatch. +type IDrop_event_sessionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEvent_session_name returns the event_session_name rule contexts. + GetEvent_session_name() IId_Context + + // SetEvent_session_name sets the event_session_name rule contexts. + SetEvent_session_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + EVENT() antlr.TerminalNode + SESSION() antlr.TerminalNode + ON() antlr.TerminalNode + SERVER() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_event_sessionContext differentiates from other interfaces. + IsDrop_event_sessionContext() +} + +type Drop_event_sessionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + event_session_name IId_Context +} + +func NewEmptyDrop_event_sessionContext() *Drop_event_sessionContext { + var p = new(Drop_event_sessionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_event_session + return p +} + +func InitEmptyDrop_event_sessionContext(p *Drop_event_sessionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_event_session +} + +func (*Drop_event_sessionContext) IsDrop_event_sessionContext() {} + +func NewDrop_event_sessionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_event_sessionContext { + var p = new(Drop_event_sessionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_event_session + + return p +} + +func (s *Drop_event_sessionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_event_sessionContext) GetEvent_session_name() IId_Context { return s.event_session_name } + +func (s *Drop_event_sessionContext) SetEvent_session_name(v IId_Context) { s.event_session_name = v } + +func (s *Drop_event_sessionContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_event_sessionContext) EVENT() antlr.TerminalNode { + return s.GetToken(TSqlParserEVENT, 0) +} + +func (s *Drop_event_sessionContext) SESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserSESSION, 0) +} + +func (s *Drop_event_sessionContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Drop_event_sessionContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Drop_event_sessionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_event_sessionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_event_sessionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_event_sessionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_event_session(s) + } +} + +func (s *Drop_event_sessionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_event_session(s) + } +} + +func (s *Drop_event_sessionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_event_session(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_event_session() (localctx IDrop_event_sessionContext) { + localctx = NewDrop_event_sessionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 216, TSqlParserRULE_drop_event_session) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2917) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2918) + p.Match(TSqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2919) + p.Match(TSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2920) + + var _x = p.Id_() + + localctx.(*Drop_event_sessionContext).event_session_name = _x + } + { + p.SetState(2921) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2922) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_fulltext_catalogContext is an interface to support dynamic dispatch. +type IDrop_fulltext_catalogContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCatalog_name returns the catalog_name rule contexts. + GetCatalog_name() IId_Context + + // SetCatalog_name sets the catalog_name rule contexts. + SetCatalog_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + FULLTEXT() antlr.TerminalNode + CATALOG() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_fulltext_catalogContext differentiates from other interfaces. + IsDrop_fulltext_catalogContext() +} + +type Drop_fulltext_catalogContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + catalog_name IId_Context +} + +func NewEmptyDrop_fulltext_catalogContext() *Drop_fulltext_catalogContext { + var p = new(Drop_fulltext_catalogContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_fulltext_catalog + return p +} + +func InitEmptyDrop_fulltext_catalogContext(p *Drop_fulltext_catalogContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_fulltext_catalog +} + +func (*Drop_fulltext_catalogContext) IsDrop_fulltext_catalogContext() {} + +func NewDrop_fulltext_catalogContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_fulltext_catalogContext { + var p = new(Drop_fulltext_catalogContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_fulltext_catalog + + return p +} + +func (s *Drop_fulltext_catalogContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_fulltext_catalogContext) GetCatalog_name() IId_Context { return s.catalog_name } + +func (s *Drop_fulltext_catalogContext) SetCatalog_name(v IId_Context) { s.catalog_name = v } + +func (s *Drop_fulltext_catalogContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_fulltext_catalogContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXT, 0) +} + +func (s *Drop_fulltext_catalogContext) CATALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserCATALOG, 0) +} + +func (s *Drop_fulltext_catalogContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_fulltext_catalogContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_fulltext_catalogContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_fulltext_catalogContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_fulltext_catalog(s) + } +} + +func (s *Drop_fulltext_catalogContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_fulltext_catalog(s) + } +} + +func (s *Drop_fulltext_catalogContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_fulltext_catalog(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_fulltext_catalog() (localctx IDrop_fulltext_catalogContext) { + localctx = NewDrop_fulltext_catalogContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 218, TSqlParserRULE_drop_fulltext_catalog) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2924) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2925) + p.Match(TSqlParserFULLTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2926) + p.Match(TSqlParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2927) + + var _x = p.Id_() + + localctx.(*Drop_fulltext_catalogContext).catalog_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_fulltext_indexContext is an interface to support dynamic dispatch. +type IDrop_fulltext_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema returns the schema rule contexts. + GetSchema() IId_Context + + // GetTable returns the table rule contexts. + GetTable() IId_Context + + // SetSchema sets the schema rule contexts. + SetSchema(IId_Context) + + // SetTable sets the table rule contexts. + SetTable(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + FULLTEXT() antlr.TerminalNode + INDEX() antlr.TerminalNode + ON() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + DOT() antlr.TerminalNode + + // IsDrop_fulltext_indexContext differentiates from other interfaces. + IsDrop_fulltext_indexContext() +} + +type Drop_fulltext_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema IId_Context + table IId_Context +} + +func NewEmptyDrop_fulltext_indexContext() *Drop_fulltext_indexContext { + var p = new(Drop_fulltext_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_fulltext_index + return p +} + +func InitEmptyDrop_fulltext_indexContext(p *Drop_fulltext_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_fulltext_index +} + +func (*Drop_fulltext_indexContext) IsDrop_fulltext_indexContext() {} + +func NewDrop_fulltext_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_fulltext_indexContext { + var p = new(Drop_fulltext_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_fulltext_index + + return p +} + +func (s *Drop_fulltext_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_fulltext_indexContext) GetSchema() IId_Context { return s.schema } + +func (s *Drop_fulltext_indexContext) GetTable() IId_Context { return s.table } + +func (s *Drop_fulltext_indexContext) SetSchema(v IId_Context) { s.schema = v } + +func (s *Drop_fulltext_indexContext) SetTable(v IId_Context) { s.table = v } + +func (s *Drop_fulltext_indexContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_fulltext_indexContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXT, 0) +} + +func (s *Drop_fulltext_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Drop_fulltext_indexContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Drop_fulltext_indexContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_fulltext_indexContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_fulltext_indexContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Drop_fulltext_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_fulltext_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_fulltext_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_fulltext_index(s) + } +} + +func (s *Drop_fulltext_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_fulltext_index(s) + } +} + +func (s *Drop_fulltext_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_fulltext_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_fulltext_index() (localctx IDrop_fulltext_indexContext) { + localctx = NewDrop_fulltext_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 220, TSqlParserRULE_drop_fulltext_index) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2929) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2930) + p.Match(TSqlParserFULLTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2931) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2932) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2936) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 192, p.GetParserRuleContext()) == 1 { + { + p.SetState(2933) + + var _x = p.Id_() + + localctx.(*Drop_fulltext_indexContext).schema = _x + } + { + p.SetState(2934) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2938) + + var _x = p.Id_() + + localctx.(*Drop_fulltext_indexContext).table = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_fulltext_stoplistContext is an interface to support dynamic dispatch. +type IDrop_fulltext_stoplistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetStoplist_name returns the stoplist_name rule contexts. + GetStoplist_name() IId_Context + + // SetStoplist_name sets the stoplist_name rule contexts. + SetStoplist_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + FULLTEXT() antlr.TerminalNode + STOPLIST() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_fulltext_stoplistContext differentiates from other interfaces. + IsDrop_fulltext_stoplistContext() +} + +type Drop_fulltext_stoplistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + stoplist_name IId_Context +} + +func NewEmptyDrop_fulltext_stoplistContext() *Drop_fulltext_stoplistContext { + var p = new(Drop_fulltext_stoplistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_fulltext_stoplist + return p +} + +func InitEmptyDrop_fulltext_stoplistContext(p *Drop_fulltext_stoplistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_fulltext_stoplist +} + +func (*Drop_fulltext_stoplistContext) IsDrop_fulltext_stoplistContext() {} + +func NewDrop_fulltext_stoplistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_fulltext_stoplistContext { + var p = new(Drop_fulltext_stoplistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_fulltext_stoplist + + return p +} + +func (s *Drop_fulltext_stoplistContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_fulltext_stoplistContext) GetStoplist_name() IId_Context { return s.stoplist_name } + +func (s *Drop_fulltext_stoplistContext) SetStoplist_name(v IId_Context) { s.stoplist_name = v } + +func (s *Drop_fulltext_stoplistContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_fulltext_stoplistContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXT, 0) +} + +func (s *Drop_fulltext_stoplistContext) STOPLIST() antlr.TerminalNode { + return s.GetToken(TSqlParserSTOPLIST, 0) +} + +func (s *Drop_fulltext_stoplistContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_fulltext_stoplistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_fulltext_stoplistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_fulltext_stoplistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_fulltext_stoplist(s) + } +} + +func (s *Drop_fulltext_stoplistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_fulltext_stoplist(s) + } +} + +func (s *Drop_fulltext_stoplistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_fulltext_stoplist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_fulltext_stoplist() (localctx IDrop_fulltext_stoplistContext) { + localctx = NewDrop_fulltext_stoplistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 222, TSqlParserRULE_drop_fulltext_stoplist) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2940) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2941) + p.Match(TSqlParserFULLTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2942) + p.Match(TSqlParserSTOPLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2943) + + var _x = p.Id_() + + localctx.(*Drop_fulltext_stoplistContext).stoplist_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_loginContext is an interface to support dynamic dispatch. +type IDrop_loginContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLogin_name returns the login_name rule contexts. + GetLogin_name() IId_Context + + // SetLogin_name sets the login_name rule contexts. + SetLogin_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + LOGIN() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_loginContext differentiates from other interfaces. + IsDrop_loginContext() +} + +type Drop_loginContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + login_name IId_Context +} + +func NewEmptyDrop_loginContext() *Drop_loginContext { + var p = new(Drop_loginContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_login + return p +} + +func InitEmptyDrop_loginContext(p *Drop_loginContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_login +} + +func (*Drop_loginContext) IsDrop_loginContext() {} + +func NewDrop_loginContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_loginContext { + var p = new(Drop_loginContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_login + + return p +} + +func (s *Drop_loginContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_loginContext) GetLogin_name() IId_Context { return s.login_name } + +func (s *Drop_loginContext) SetLogin_name(v IId_Context) { s.login_name = v } + +func (s *Drop_loginContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_loginContext) LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, 0) +} + +func (s *Drop_loginContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_loginContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_loginContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_loginContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_login(s) + } +} + +func (s *Drop_loginContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_login(s) + } +} + +func (s *Drop_loginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_login(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_login() (localctx IDrop_loginContext) { + localctx = NewDrop_loginContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 224, TSqlParserRULE_drop_login) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2945) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2946) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2947) + + var _x = p.Id_() + + localctx.(*Drop_loginContext).login_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_master_keyContext is an interface to support dynamic dispatch. +type IDrop_master_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + MASTER() antlr.TerminalNode + KEY() antlr.TerminalNode + + // IsDrop_master_keyContext differentiates from other interfaces. + IsDrop_master_keyContext() +} + +type Drop_master_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_master_keyContext() *Drop_master_keyContext { + var p = new(Drop_master_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_master_key + return p +} + +func InitEmptyDrop_master_keyContext(p *Drop_master_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_master_key +} + +func (*Drop_master_keyContext) IsDrop_master_keyContext() {} + +func NewDrop_master_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_master_keyContext { + var p = new(Drop_master_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_master_key + + return p +} + +func (s *Drop_master_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_master_keyContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_master_keyContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *Drop_master_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Drop_master_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_master_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_master_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_master_key(s) + } +} + +func (s *Drop_master_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_master_key(s) + } +} + +func (s *Drop_master_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_master_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_master_key() (localctx IDrop_master_keyContext) { + localctx = NewDrop_master_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 226, TSqlParserRULE_drop_master_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2949) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2950) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2951) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_message_typeContext is an interface to support dynamic dispatch. +type IDrop_message_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMessage_type_name returns the message_type_name rule contexts. + GetMessage_type_name() IId_Context + + // SetMessage_type_name sets the message_type_name rule contexts. + SetMessage_type_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + MESSAGE() antlr.TerminalNode + TYPE() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_message_typeContext differentiates from other interfaces. + IsDrop_message_typeContext() +} + +type Drop_message_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + message_type_name IId_Context +} + +func NewEmptyDrop_message_typeContext() *Drop_message_typeContext { + var p = new(Drop_message_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_message_type + return p +} + +func InitEmptyDrop_message_typeContext(p *Drop_message_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_message_type +} + +func (*Drop_message_typeContext) IsDrop_message_typeContext() {} + +func NewDrop_message_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_message_typeContext { + var p = new(Drop_message_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_message_type + + return p +} + +func (s *Drop_message_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_message_typeContext) GetMessage_type_name() IId_Context { return s.message_type_name } + +func (s *Drop_message_typeContext) SetMessage_type_name(v IId_Context) { s.message_type_name = v } + +func (s *Drop_message_typeContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_message_typeContext) MESSAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE, 0) +} + +func (s *Drop_message_typeContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *Drop_message_typeContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_message_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_message_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_message_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_message_type(s) + } +} + +func (s *Drop_message_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_message_type(s) + } +} + +func (s *Drop_message_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_message_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_message_type() (localctx IDrop_message_typeContext) { + localctx = NewDrop_message_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 228, TSqlParserRULE_drop_message_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2953) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2954) + p.Match(TSqlParserMESSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2955) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2956) + + var _x = p.Id_() + + localctx.(*Drop_message_typeContext).message_type_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_partition_functionContext is an interface to support dynamic dispatch. +type IDrop_partition_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartition_function_name returns the partition_function_name rule contexts. + GetPartition_function_name() IId_Context + + // SetPartition_function_name sets the partition_function_name rule contexts. + SetPartition_function_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + PARTITION() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_partition_functionContext differentiates from other interfaces. + IsDrop_partition_functionContext() +} + +type Drop_partition_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partition_function_name IId_Context +} + +func NewEmptyDrop_partition_functionContext() *Drop_partition_functionContext { + var p = new(Drop_partition_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_partition_function + return p +} + +func InitEmptyDrop_partition_functionContext(p *Drop_partition_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_partition_function +} + +func (*Drop_partition_functionContext) IsDrop_partition_functionContext() {} + +func NewDrop_partition_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_partition_functionContext { + var p = new(Drop_partition_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_partition_function + + return p +} + +func (s *Drop_partition_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_partition_functionContext) GetPartition_function_name() IId_Context { + return s.partition_function_name +} + +func (s *Drop_partition_functionContext) SetPartition_function_name(v IId_Context) { + s.partition_function_name = v +} + +func (s *Drop_partition_functionContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_partition_functionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITION, 0) +} + +func (s *Drop_partition_functionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(TSqlParserFUNCTION, 0) +} + +func (s *Drop_partition_functionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_partition_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_partition_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_partition_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_partition_function(s) + } +} + +func (s *Drop_partition_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_partition_function(s) + } +} + +func (s *Drop_partition_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_partition_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_partition_function() (localctx IDrop_partition_functionContext) { + localctx = NewDrop_partition_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 230, TSqlParserRULE_drop_partition_function) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2958) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2959) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2960) + p.Match(TSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2961) + + var _x = p.Id_() + + localctx.(*Drop_partition_functionContext).partition_function_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_partition_schemeContext is an interface to support dynamic dispatch. +type IDrop_partition_schemeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartition_scheme_name returns the partition_scheme_name rule contexts. + GetPartition_scheme_name() IId_Context + + // SetPartition_scheme_name sets the partition_scheme_name rule contexts. + SetPartition_scheme_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + PARTITION() antlr.TerminalNode + SCHEME() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_partition_schemeContext differentiates from other interfaces. + IsDrop_partition_schemeContext() +} + +type Drop_partition_schemeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partition_scheme_name IId_Context +} + +func NewEmptyDrop_partition_schemeContext() *Drop_partition_schemeContext { + var p = new(Drop_partition_schemeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_partition_scheme + return p +} + +func InitEmptyDrop_partition_schemeContext(p *Drop_partition_schemeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_partition_scheme +} + +func (*Drop_partition_schemeContext) IsDrop_partition_schemeContext() {} + +func NewDrop_partition_schemeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_partition_schemeContext { + var p = new(Drop_partition_schemeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_partition_scheme + + return p +} + +func (s *Drop_partition_schemeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_partition_schemeContext) GetPartition_scheme_name() IId_Context { + return s.partition_scheme_name +} + +func (s *Drop_partition_schemeContext) SetPartition_scheme_name(v IId_Context) { + s.partition_scheme_name = v +} + +func (s *Drop_partition_schemeContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_partition_schemeContext) PARTITION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITION, 0) +} + +func (s *Drop_partition_schemeContext) SCHEME() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEME, 0) +} + +func (s *Drop_partition_schemeContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_partition_schemeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_partition_schemeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_partition_schemeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_partition_scheme(s) + } +} + +func (s *Drop_partition_schemeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_partition_scheme(s) + } +} + +func (s *Drop_partition_schemeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_partition_scheme(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_partition_scheme() (localctx IDrop_partition_schemeContext) { + localctx = NewDrop_partition_schemeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 232, TSqlParserRULE_drop_partition_scheme) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2963) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2964) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2965) + p.Match(TSqlParserSCHEME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2966) + + var _x = p.Id_() + + localctx.(*Drop_partition_schemeContext).partition_scheme_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_queueContext is an interface to support dynamic dispatch. +type IDrop_queueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatabase_name returns the database_name rule contexts. + GetDatabase_name() IId_Context + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetQueue_name returns the queue_name rule contexts. + GetQueue_name() IId_Context + + // SetDatabase_name sets the database_name rule contexts. + SetDatabase_name(IId_Context) + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetQueue_name sets the queue_name rule contexts. + SetQueue_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + QUEUE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsDrop_queueContext differentiates from other interfaces. + IsDrop_queueContext() +} + +type Drop_queueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database_name IId_Context + schema_name IId_Context + queue_name IId_Context +} + +func NewEmptyDrop_queueContext() *Drop_queueContext { + var p = new(Drop_queueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_queue + return p +} + +func InitEmptyDrop_queueContext(p *Drop_queueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_queue +} + +func (*Drop_queueContext) IsDrop_queueContext() {} + +func NewDrop_queueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_queueContext { + var p = new(Drop_queueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_queue + + return p +} + +func (s *Drop_queueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_queueContext) GetDatabase_name() IId_Context { return s.database_name } + +func (s *Drop_queueContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Drop_queueContext) GetQueue_name() IId_Context { return s.queue_name } + +func (s *Drop_queueContext) SetDatabase_name(v IId_Context) { s.database_name = v } + +func (s *Drop_queueContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Drop_queueContext) SetQueue_name(v IId_Context) { s.queue_name = v } + +func (s *Drop_queueContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_queueContext) QUEUE() antlr.TerminalNode { + return s.GetToken(TSqlParserQUEUE, 0) +} + +func (s *Drop_queueContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_queueContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_queueContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Drop_queueContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Drop_queueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_queueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_queueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_queue(s) + } +} + +func (s *Drop_queueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_queue(s) + } +} + +func (s *Drop_queueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_queue(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_queue() (localctx IDrop_queueContext) { + localctx = NewDrop_queueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 234, TSqlParserRULE_drop_queue) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2968) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2969) + p.Match(TSqlParserQUEUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2973) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 193, p.GetParserRuleContext()) == 1 { + { + p.SetState(2970) + + var _x = p.Id_() + + localctx.(*Drop_queueContext).database_name = _x + } + { + p.SetState(2971) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2978) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 194, p.GetParserRuleContext()) == 1 { + { + p.SetState(2975) + + var _x = p.Id_() + + localctx.(*Drop_queueContext).schema_name = _x + } + { + p.SetState(2976) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2980) + + var _x = p.Id_() + + localctx.(*Drop_queueContext).queue_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_remote_service_bindingContext is an interface to support dynamic dispatch. +type IDrop_remote_service_bindingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBinding_name returns the binding_name rule contexts. + GetBinding_name() IId_Context + + // SetBinding_name sets the binding_name rule contexts. + SetBinding_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + REMOTE() antlr.TerminalNode + SERVICE() antlr.TerminalNode + BINDING() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_remote_service_bindingContext differentiates from other interfaces. + IsDrop_remote_service_bindingContext() +} + +type Drop_remote_service_bindingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + binding_name IId_Context +} + +func NewEmptyDrop_remote_service_bindingContext() *Drop_remote_service_bindingContext { + var p = new(Drop_remote_service_bindingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_remote_service_binding + return p +} + +func InitEmptyDrop_remote_service_bindingContext(p *Drop_remote_service_bindingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_remote_service_binding +} + +func (*Drop_remote_service_bindingContext) IsDrop_remote_service_bindingContext() {} + +func NewDrop_remote_service_bindingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_remote_service_bindingContext { + var p = new(Drop_remote_service_bindingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_remote_service_binding + + return p +} + +func (s *Drop_remote_service_bindingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_remote_service_bindingContext) GetBinding_name() IId_Context { return s.binding_name } + +func (s *Drop_remote_service_bindingContext) SetBinding_name(v IId_Context) { s.binding_name = v } + +func (s *Drop_remote_service_bindingContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_remote_service_bindingContext) REMOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOTE, 0) +} + +func (s *Drop_remote_service_bindingContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *Drop_remote_service_bindingContext) BINDING() antlr.TerminalNode { + return s.GetToken(TSqlParserBINDING, 0) +} + +func (s *Drop_remote_service_bindingContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_remote_service_bindingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_remote_service_bindingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_remote_service_bindingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_remote_service_binding(s) + } +} + +func (s *Drop_remote_service_bindingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_remote_service_binding(s) + } +} + +func (s *Drop_remote_service_bindingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_remote_service_binding(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_remote_service_binding() (localctx IDrop_remote_service_bindingContext) { + localctx = NewDrop_remote_service_bindingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 236, TSqlParserRULE_drop_remote_service_binding) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2982) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2983) + p.Match(TSqlParserREMOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2984) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2985) + p.Match(TSqlParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2986) + + var _x = p.Id_() + + localctx.(*Drop_remote_service_bindingContext).binding_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_resource_poolContext is an interface to support dynamic dispatch. +type IDrop_resource_poolContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPool_name returns the pool_name rule contexts. + GetPool_name() IId_Context + + // SetPool_name sets the pool_name rule contexts. + SetPool_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + POOL() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_resource_poolContext differentiates from other interfaces. + IsDrop_resource_poolContext() +} + +type Drop_resource_poolContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + pool_name IId_Context +} + +func NewEmptyDrop_resource_poolContext() *Drop_resource_poolContext { + var p = new(Drop_resource_poolContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_resource_pool + return p +} + +func InitEmptyDrop_resource_poolContext(p *Drop_resource_poolContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_resource_pool +} + +func (*Drop_resource_poolContext) IsDrop_resource_poolContext() {} + +func NewDrop_resource_poolContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_resource_poolContext { + var p = new(Drop_resource_poolContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_resource_pool + + return p +} + +func (s *Drop_resource_poolContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_resource_poolContext) GetPool_name() IId_Context { return s.pool_name } + +func (s *Drop_resource_poolContext) SetPool_name(v IId_Context) { s.pool_name = v } + +func (s *Drop_resource_poolContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_resource_poolContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESOURCE, 0) +} + +func (s *Drop_resource_poolContext) POOL() antlr.TerminalNode { + return s.GetToken(TSqlParserPOOL, 0) +} + +func (s *Drop_resource_poolContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_resource_poolContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_resource_poolContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_resource_poolContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_resource_pool(s) + } +} + +func (s *Drop_resource_poolContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_resource_pool(s) + } +} + +func (s *Drop_resource_poolContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_resource_pool(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_resource_pool() (localctx IDrop_resource_poolContext) { + localctx = NewDrop_resource_poolContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 238, TSqlParserRULE_drop_resource_pool) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2988) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2989) + p.Match(TSqlParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2990) + p.Match(TSqlParserPOOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2991) + + var _x = p.Id_() + + localctx.(*Drop_resource_poolContext).pool_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_db_roleContext is an interface to support dynamic dispatch. +type IDrop_db_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRole_name returns the role_name rule contexts. + GetRole_name() IId_Context + + // SetRole_name sets the role_name rule contexts. + SetRole_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + ROLE() antlr.TerminalNode + Id_() IId_Context + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsDrop_db_roleContext differentiates from other interfaces. + IsDrop_db_roleContext() +} + +type Drop_db_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + role_name IId_Context +} + +func NewEmptyDrop_db_roleContext() *Drop_db_roleContext { + var p = new(Drop_db_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_db_role + return p +} + +func InitEmptyDrop_db_roleContext(p *Drop_db_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_db_role +} + +func (*Drop_db_roleContext) IsDrop_db_roleContext() {} + +func NewDrop_db_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_db_roleContext { + var p = new(Drop_db_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_db_role + + return p +} + +func (s *Drop_db_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_db_roleContext) GetRole_name() IId_Context { return s.role_name } + +func (s *Drop_db_roleContext) SetRole_name(v IId_Context) { s.role_name = v } + +func (s *Drop_db_roleContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_db_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Drop_db_roleContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_db_roleContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_db_roleContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_db_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_db_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_db_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_db_role(s) + } +} + +func (s *Drop_db_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_db_role(s) + } +} + +func (s *Drop_db_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_db_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_db_role() (localctx IDrop_db_roleContext) { + localctx = NewDrop_db_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 240, TSqlParserRULE_drop_db_role) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2993) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2994) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(2995) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2996) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2999) + + var _x = p.Id_() + + localctx.(*Drop_db_roleContext).role_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_routeContext is an interface to support dynamic dispatch. +type IDrop_routeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRoute_name returns the route_name rule contexts. + GetRoute_name() IId_Context + + // SetRoute_name sets the route_name rule contexts. + SetRoute_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + ROUTE() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_routeContext differentiates from other interfaces. + IsDrop_routeContext() +} + +type Drop_routeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + route_name IId_Context +} + +func NewEmptyDrop_routeContext() *Drop_routeContext { + var p = new(Drop_routeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_route + return p +} + +func InitEmptyDrop_routeContext(p *Drop_routeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_route +} + +func (*Drop_routeContext) IsDrop_routeContext() {} + +func NewDrop_routeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_routeContext { + var p = new(Drop_routeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_route + + return p +} + +func (s *Drop_routeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_routeContext) GetRoute_name() IId_Context { return s.route_name } + +func (s *Drop_routeContext) SetRoute_name(v IId_Context) { s.route_name = v } + +func (s *Drop_routeContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_routeContext) ROUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserROUTE, 0) +} + +func (s *Drop_routeContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_routeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_routeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_routeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_route(s) + } +} + +func (s *Drop_routeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_route(s) + } +} + +func (s *Drop_routeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_route(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_route() (localctx IDrop_routeContext) { + localctx = NewDrop_routeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 242, TSqlParserRULE_drop_route) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3001) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3002) + p.Match(TSqlParserROUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3003) + + var _x = p.Id_() + + localctx.(*Drop_routeContext).route_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_ruleContext is an interface to support dynamic dispatch. +type IDrop_ruleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetRule_name returns the rule_name rule contexts. + GetRule_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetRule_name sets the rule_name rule contexts. + SetRule_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + RULE() antlr.TerminalNode + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + COMMA() antlr.TerminalNode + DOT() antlr.TerminalNode + + // IsDrop_ruleContext differentiates from other interfaces. + IsDrop_ruleContext() +} + +type Drop_ruleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + rule_name IId_Context +} + +func NewEmptyDrop_ruleContext() *Drop_ruleContext { + var p = new(Drop_ruleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_rule + return p +} + +func InitEmptyDrop_ruleContext(p *Drop_ruleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_rule +} + +func (*Drop_ruleContext) IsDrop_ruleContext() {} + +func NewDrop_ruleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_ruleContext { + var p = new(Drop_ruleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_rule + + return p +} + +func (s *Drop_ruleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_ruleContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Drop_ruleContext) GetRule_name() IId_Context { return s.rule_name } + +func (s *Drop_ruleContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Drop_ruleContext) SetRule_name(v IId_Context) { s.rule_name = v } + +func (s *Drop_ruleContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_ruleContext) RULE() antlr.TerminalNode { + return s.GetToken(TSqlParserRULE, 0) +} + +func (s *Drop_ruleContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_ruleContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_ruleContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_ruleContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_ruleContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Drop_ruleContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Drop_ruleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_ruleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_ruleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_rule(s) + } +} + +func (s *Drop_ruleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_rule(s) + } +} + +func (s *Drop_ruleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_rule(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_rule() (localctx IDrop_ruleContext) { + localctx = NewDrop_ruleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 244, TSqlParserRULE_drop_rule) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3005) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3006) + p.Match(TSqlParserRULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3009) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 196, p.GetParserRuleContext()) == 1 { + { + p.SetState(3007) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3008) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3020) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 199, p.GetParserRuleContext()) == 1 { + p.SetState(3012) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3011) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3017) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 198, p.GetParserRuleContext()) == 1 { + { + p.SetState(3014) + + var _x = p.Id_() + + localctx.(*Drop_ruleContext).schema_name = _x + } + { + p.SetState(3015) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3019) + + var _x = p.Id_() + + localctx.(*Drop_ruleContext).rule_name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_schemaContext is an interface to support dynamic dispatch. +type IDrop_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Id_() IId_Context + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsDrop_schemaContext differentiates from other interfaces. + IsDrop_schemaContext() +} + +type Drop_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context +} + +func NewEmptyDrop_schemaContext() *Drop_schemaContext { + var p = new(Drop_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_schema + return p +} + +func InitEmptyDrop_schemaContext(p *Drop_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_schema +} + +func (*Drop_schemaContext) IsDrop_schemaContext() {} + +func NewDrop_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_schemaContext { + var p = new(Drop_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_schema + + return p +} + +func (s *Drop_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_schemaContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Drop_schemaContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Drop_schemaContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_schemaContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Drop_schemaContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_schemaContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_schemaContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_schema(s) + } +} + +func (s *Drop_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_schema(s) + } +} + +func (s *Drop_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_schema() (localctx IDrop_schemaContext) { + localctx = NewDrop_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 246, TSqlParserRULE_drop_schema) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3022) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3023) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(3024) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3025) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3028) + + var _x = p.Id_() + + localctx.(*Drop_schemaContext).schema_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_search_property_listContext is an interface to support dynamic dispatch. +type IDrop_search_property_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetProperty_list_name returns the property_list_name rule contexts. + GetProperty_list_name() IId_Context + + // SetProperty_list_name sets the property_list_name rule contexts. + SetProperty_list_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + SEARCH() antlr.TerminalNode + PROPERTY() antlr.TerminalNode + LIST() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_search_property_listContext differentiates from other interfaces. + IsDrop_search_property_listContext() +} + +type Drop_search_property_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + property_list_name IId_Context +} + +func NewEmptyDrop_search_property_listContext() *Drop_search_property_listContext { + var p = new(Drop_search_property_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_search_property_list + return p +} + +func InitEmptyDrop_search_property_listContext(p *Drop_search_property_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_search_property_list +} + +func (*Drop_search_property_listContext) IsDrop_search_property_listContext() {} + +func NewDrop_search_property_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_search_property_listContext { + var p = new(Drop_search_property_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_search_property_list + + return p +} + +func (s *Drop_search_property_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_search_property_listContext) GetProperty_list_name() IId_Context { + return s.property_list_name +} + +func (s *Drop_search_property_listContext) SetProperty_list_name(v IId_Context) { + s.property_list_name = v +} + +func (s *Drop_search_property_listContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_search_property_listContext) SEARCH() antlr.TerminalNode { + return s.GetToken(TSqlParserSEARCH, 0) +} + +func (s *Drop_search_property_listContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserPROPERTY, 0) +} + +func (s *Drop_search_property_listContext) LIST() antlr.TerminalNode { + return s.GetToken(TSqlParserLIST, 0) +} + +func (s *Drop_search_property_listContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_search_property_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_search_property_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_search_property_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_search_property_list(s) + } +} + +func (s *Drop_search_property_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_search_property_list(s) + } +} + +func (s *Drop_search_property_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_search_property_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_search_property_list() (localctx IDrop_search_property_listContext) { + localctx = NewDrop_search_property_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 248, TSqlParserRULE_drop_search_property_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3030) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3031) + p.Match(TSqlParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3032) + p.Match(TSqlParserPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3033) + p.Match(TSqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3034) + + var _x = p.Id_() + + localctx.(*Drop_search_property_listContext).property_list_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_security_policyContext is an interface to support dynamic dispatch. +type IDrop_security_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetSecurity_policy_name returns the security_policy_name rule contexts. + GetSecurity_policy_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetSecurity_policy_name sets the security_policy_name rule contexts. + SetSecurity_policy_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + SECURITY() antlr.TerminalNode + POLICY() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + DOT() antlr.TerminalNode + + // IsDrop_security_policyContext differentiates from other interfaces. + IsDrop_security_policyContext() +} + +type Drop_security_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + security_policy_name IId_Context +} + +func NewEmptyDrop_security_policyContext() *Drop_security_policyContext { + var p = new(Drop_security_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_security_policy + return p +} + +func InitEmptyDrop_security_policyContext(p *Drop_security_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_security_policy +} + +func (*Drop_security_policyContext) IsDrop_security_policyContext() {} + +func NewDrop_security_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_security_policyContext { + var p = new(Drop_security_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_security_policy + + return p +} + +func (s *Drop_security_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_security_policyContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Drop_security_policyContext) GetSecurity_policy_name() IId_Context { + return s.security_policy_name +} + +func (s *Drop_security_policyContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Drop_security_policyContext) SetSecurity_policy_name(v IId_Context) { + s.security_policy_name = v +} + +func (s *Drop_security_policyContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_security_policyContext) SECURITY() antlr.TerminalNode { + return s.GetToken(TSqlParserSECURITY, 0) +} + +func (s *Drop_security_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(TSqlParserPOLICY, 0) +} + +func (s *Drop_security_policyContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_security_policyContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_security_policyContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_security_policyContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_security_policyContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Drop_security_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_security_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_security_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_security_policy(s) + } +} + +func (s *Drop_security_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_security_policy(s) + } +} + +func (s *Drop_security_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_security_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_security_policy() (localctx IDrop_security_policyContext) { + localctx = NewDrop_security_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 250, TSqlParserRULE_drop_security_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3036) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3037) + p.Match(TSqlParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3038) + p.Match(TSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3041) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(3039) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3040) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3046) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 202, p.GetParserRuleContext()) == 1 { + { + p.SetState(3043) + + var _x = p.Id_() + + localctx.(*Drop_security_policyContext).schema_name = _x + } + { + p.SetState(3044) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3048) + + var _x = p.Id_() + + localctx.(*Drop_security_policyContext).security_policy_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_sequenceContext is an interface to support dynamic dispatch. +type IDrop_sequenceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatabase_name returns the database_name rule contexts. + GetDatabase_name() IId_Context + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetSequence_name returns the sequence_name rule contexts. + GetSequence_name() IId_Context + + // SetDatabase_name sets the database_name rule contexts. + SetDatabase_name(IId_Context) + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetSequence_name sets the sequence_name rule contexts. + SetSequence_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + COMMA() antlr.TerminalNode + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsDrop_sequenceContext differentiates from other interfaces. + IsDrop_sequenceContext() +} + +type Drop_sequenceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database_name IId_Context + schema_name IId_Context + sequence_name IId_Context +} + +func NewEmptyDrop_sequenceContext() *Drop_sequenceContext { + var p = new(Drop_sequenceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_sequence + return p +} + +func InitEmptyDrop_sequenceContext(p *Drop_sequenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_sequence +} + +func (*Drop_sequenceContext) IsDrop_sequenceContext() {} + +func NewDrop_sequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_sequenceContext { + var p = new(Drop_sequenceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_sequence + + return p +} + +func (s *Drop_sequenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_sequenceContext) GetDatabase_name() IId_Context { return s.database_name } + +func (s *Drop_sequenceContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Drop_sequenceContext) GetSequence_name() IId_Context { return s.sequence_name } + +func (s *Drop_sequenceContext) SetDatabase_name(v IId_Context) { s.database_name = v } + +func (s *Drop_sequenceContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Drop_sequenceContext) SetSequence_name(v IId_Context) { s.sequence_name = v } + +func (s *Drop_sequenceContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_sequenceContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(TSqlParserSEQUENCE, 0) +} + +func (s *Drop_sequenceContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_sequenceContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_sequenceContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_sequenceContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_sequenceContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Drop_sequenceContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Drop_sequenceContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Drop_sequenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_sequenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_sequenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_sequence(s) + } +} + +func (s *Drop_sequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_sequence(s) + } +} + +func (s *Drop_sequenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_sequence(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_sequence() (localctx IDrop_sequenceContext) { + localctx = NewDrop_sequenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 252, TSqlParserRULE_drop_sequence) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3050) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3051) + p.Match(TSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3054) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 203, p.GetParserRuleContext()) == 1 { + { + p.SetState(3052) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3053) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3070) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 207, p.GetParserRuleContext()) == 1 { + p.SetState(3057) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3056) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3062) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 205, p.GetParserRuleContext()) == 1 { + { + p.SetState(3059) + + var _x = p.Id_() + + localctx.(*Drop_sequenceContext).database_name = _x + } + { + p.SetState(3060) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3067) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 206, p.GetParserRuleContext()) == 1 { + { + p.SetState(3064) + + var _x = p.Id_() + + localctx.(*Drop_sequenceContext).schema_name = _x + } + { + p.SetState(3065) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3069) + + var _x = p.Id_() + + localctx.(*Drop_sequenceContext).sequence_name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_server_auditContext is an interface to support dynamic dispatch. +type IDrop_server_auditContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAudit_name returns the audit_name rule contexts. + GetAudit_name() IId_Context + + // SetAudit_name sets the audit_name rule contexts. + SetAudit_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + SERVER() antlr.TerminalNode + AUDIT() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_server_auditContext differentiates from other interfaces. + IsDrop_server_auditContext() +} + +type Drop_server_auditContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + audit_name IId_Context +} + +func NewEmptyDrop_server_auditContext() *Drop_server_auditContext { + var p = new(Drop_server_auditContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_server_audit + return p +} + +func InitEmptyDrop_server_auditContext(p *Drop_server_auditContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_server_audit +} + +func (*Drop_server_auditContext) IsDrop_server_auditContext() {} + +func NewDrop_server_auditContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_server_auditContext { + var p = new(Drop_server_auditContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_server_audit + + return p +} + +func (s *Drop_server_auditContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_server_auditContext) GetAudit_name() IId_Context { return s.audit_name } + +func (s *Drop_server_auditContext) SetAudit_name(v IId_Context) { s.audit_name = v } + +func (s *Drop_server_auditContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_server_auditContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Drop_server_auditContext) AUDIT() antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT, 0) +} + +func (s *Drop_server_auditContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_server_auditContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_server_auditContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_server_auditContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_server_audit(s) + } +} + +func (s *Drop_server_auditContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_server_audit(s) + } +} + +func (s *Drop_server_auditContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_server_audit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_server_audit() (localctx IDrop_server_auditContext) { + localctx = NewDrop_server_auditContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 254, TSqlParserRULE_drop_server_audit) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3072) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3073) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3074) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3075) + + var _x = p.Id_() + + localctx.(*Drop_server_auditContext).audit_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_server_audit_specificationContext is an interface to support dynamic dispatch. +type IDrop_server_audit_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAudit_specification_name returns the audit_specification_name rule contexts. + GetAudit_specification_name() IId_Context + + // SetAudit_specification_name sets the audit_specification_name rule contexts. + SetAudit_specification_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + SERVER() antlr.TerminalNode + AUDIT() antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_server_audit_specificationContext differentiates from other interfaces. + IsDrop_server_audit_specificationContext() +} + +type Drop_server_audit_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + audit_specification_name IId_Context +} + +func NewEmptyDrop_server_audit_specificationContext() *Drop_server_audit_specificationContext { + var p = new(Drop_server_audit_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_server_audit_specification + return p +} + +func InitEmptyDrop_server_audit_specificationContext(p *Drop_server_audit_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_server_audit_specification +} + +func (*Drop_server_audit_specificationContext) IsDrop_server_audit_specificationContext() {} + +func NewDrop_server_audit_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_server_audit_specificationContext { + var p = new(Drop_server_audit_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_server_audit_specification + + return p +} + +func (s *Drop_server_audit_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_server_audit_specificationContext) GetAudit_specification_name() IId_Context { + return s.audit_specification_name +} + +func (s *Drop_server_audit_specificationContext) SetAudit_specification_name(v IId_Context) { + s.audit_specification_name = v +} + +func (s *Drop_server_audit_specificationContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_server_audit_specificationContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Drop_server_audit_specificationContext) AUDIT() antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT, 0) +} + +func (s *Drop_server_audit_specificationContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserSPECIFICATION, 0) +} + +func (s *Drop_server_audit_specificationContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_server_audit_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_server_audit_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_server_audit_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_server_audit_specification(s) + } +} + +func (s *Drop_server_audit_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_server_audit_specification(s) + } +} + +func (s *Drop_server_audit_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_server_audit_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_server_audit_specification() (localctx IDrop_server_audit_specificationContext) { + localctx = NewDrop_server_audit_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 256, TSqlParserRULE_drop_server_audit_specification) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3077) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3078) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3079) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3080) + p.Match(TSqlParserSPECIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3081) + + var _x = p.Id_() + + localctx.(*Drop_server_audit_specificationContext).audit_specification_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_server_roleContext is an interface to support dynamic dispatch. +type IDrop_server_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRole_name returns the role_name rule contexts. + GetRole_name() IId_Context + + // SetRole_name sets the role_name rule contexts. + SetRole_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + SERVER() antlr.TerminalNode + ROLE() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_server_roleContext differentiates from other interfaces. + IsDrop_server_roleContext() +} + +type Drop_server_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + role_name IId_Context +} + +func NewEmptyDrop_server_roleContext() *Drop_server_roleContext { + var p = new(Drop_server_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_server_role + return p +} + +func InitEmptyDrop_server_roleContext(p *Drop_server_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_server_role +} + +func (*Drop_server_roleContext) IsDrop_server_roleContext() {} + +func NewDrop_server_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_server_roleContext { + var p = new(Drop_server_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_server_role + + return p +} + +func (s *Drop_server_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_server_roleContext) GetRole_name() IId_Context { return s.role_name } + +func (s *Drop_server_roleContext) SetRole_name(v IId_Context) { s.role_name = v } + +func (s *Drop_server_roleContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_server_roleContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Drop_server_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Drop_server_roleContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_server_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_server_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_server_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_server_role(s) + } +} + +func (s *Drop_server_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_server_role(s) + } +} + +func (s *Drop_server_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_server_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_server_role() (localctx IDrop_server_roleContext) { + localctx = NewDrop_server_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 258, TSqlParserRULE_drop_server_role) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3083) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3084) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3085) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3086) + + var _x = p.Id_() + + localctx.(*Drop_server_roleContext).role_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_serviceContext is an interface to support dynamic dispatch. +type IDrop_serviceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDropped_service_name returns the dropped_service_name rule contexts. + GetDropped_service_name() IId_Context + + // SetDropped_service_name sets the dropped_service_name rule contexts. + SetDropped_service_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + SERVICE() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_serviceContext differentiates from other interfaces. + IsDrop_serviceContext() +} + +type Drop_serviceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dropped_service_name IId_Context +} + +func NewEmptyDrop_serviceContext() *Drop_serviceContext { + var p = new(Drop_serviceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_service + return p +} + +func InitEmptyDrop_serviceContext(p *Drop_serviceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_service +} + +func (*Drop_serviceContext) IsDrop_serviceContext() {} + +func NewDrop_serviceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_serviceContext { + var p = new(Drop_serviceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_service + + return p +} + +func (s *Drop_serviceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_serviceContext) GetDropped_service_name() IId_Context { return s.dropped_service_name } + +func (s *Drop_serviceContext) SetDropped_service_name(v IId_Context) { s.dropped_service_name = v } + +func (s *Drop_serviceContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_serviceContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *Drop_serviceContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_serviceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_serviceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_serviceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_service(s) + } +} + +func (s *Drop_serviceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_service(s) + } +} + +func (s *Drop_serviceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_service(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_service() (localctx IDrop_serviceContext) { + localctx = NewDrop_serviceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 260, TSqlParserRULE_drop_service) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3088) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3089) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3090) + + var _x = p.Id_() + + localctx.(*Drop_serviceContext).dropped_service_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_signatureContext is an interface to support dynamic dispatch. +type IDrop_signatureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetModule_name returns the module_name rule contexts. + GetModule_name() IId_Context + + // GetCert_name returns the cert_name rule contexts. + GetCert_name() IId_Context + + // GetAsym_key_name returns the Asym_key_name rule contexts. + GetAsym_key_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetModule_name sets the module_name rule contexts. + SetModule_name(IId_Context) + + // SetCert_name sets the cert_name rule contexts. + SetCert_name(IId_Context) + + // SetAsym_key_name sets the Asym_key_name rule contexts. + SetAsym_key_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + SIGNATURE() antlr.TerminalNode + FROM() antlr.TerminalNode + BY() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + COUNTER() antlr.TerminalNode + DOT() antlr.TerminalNode + AllCERTIFICATE() []antlr.TerminalNode + CERTIFICATE(i int) antlr.TerminalNode + AllASYMMETRIC() []antlr.TerminalNode + ASYMMETRIC(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDrop_signatureContext differentiates from other interfaces. + IsDrop_signatureContext() +} + +type Drop_signatureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + module_name IId_Context + cert_name IId_Context + Asym_key_name IId_Context +} + +func NewEmptyDrop_signatureContext() *Drop_signatureContext { + var p = new(Drop_signatureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_signature + return p +} + +func InitEmptyDrop_signatureContext(p *Drop_signatureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_signature +} + +func (*Drop_signatureContext) IsDrop_signatureContext() {} + +func NewDrop_signatureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_signatureContext { + var p = new(Drop_signatureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_signature + + return p +} + +func (s *Drop_signatureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_signatureContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Drop_signatureContext) GetModule_name() IId_Context { return s.module_name } + +func (s *Drop_signatureContext) GetCert_name() IId_Context { return s.cert_name } + +func (s *Drop_signatureContext) GetAsym_key_name() IId_Context { return s.Asym_key_name } + +func (s *Drop_signatureContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Drop_signatureContext) SetModule_name(v IId_Context) { s.module_name = v } + +func (s *Drop_signatureContext) SetCert_name(v IId_Context) { s.cert_name = v } + +func (s *Drop_signatureContext) SetAsym_key_name(v IId_Context) { s.Asym_key_name = v } + +func (s *Drop_signatureContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_signatureContext) SIGNATURE() antlr.TerminalNode { + return s.GetToken(TSqlParserSIGNATURE, 0) +} + +func (s *Drop_signatureContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Drop_signatureContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Drop_signatureContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_signatureContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_signatureContext) COUNTER() antlr.TerminalNode { + return s.GetToken(TSqlParserCOUNTER, 0) +} + +func (s *Drop_signatureContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Drop_signatureContext) AllCERTIFICATE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCERTIFICATE) +} + +func (s *Drop_signatureContext) CERTIFICATE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, i) +} + +func (s *Drop_signatureContext) AllASYMMETRIC() []antlr.TerminalNode { + return s.GetTokens(TSqlParserASYMMETRIC) +} + +func (s *Drop_signatureContext) ASYMMETRIC(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, i) +} + +func (s *Drop_signatureContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserKEY) +} + +func (s *Drop_signatureContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, i) +} + +func (s *Drop_signatureContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Drop_signatureContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Drop_signatureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_signatureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_signatureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_signature(s) + } +} + +func (s *Drop_signatureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_signature(s) + } +} + +func (s *Drop_signatureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_signature(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_signature() (localctx IDrop_signatureContext) { + localctx = NewDrop_signatureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 262, TSqlParserRULE_drop_signature) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3092) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOUNTER { + { + p.SetState(3093) + p.Match(TSqlParserCOUNTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3096) + p.Match(TSqlParserSIGNATURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3097) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3101) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 209, p.GetParserRuleContext()) == 1 { + { + p.SetState(3098) + + var _x = p.Id_() + + localctx.(*Drop_signatureContext).schema_name = _x + } + { + p.SetState(3099) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3103) + + var _x = p.Id_() + + localctx.(*Drop_signatureContext).module_name = _x + } + { + p.SetState(3104) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3116) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(3116) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 212, p.GetParserRuleContext()) { + case 1: + p.SetState(3106) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3105) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3108) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3109) + + var _x = p.Id_() + + localctx.(*Drop_signatureContext).cert_name = _x + } + + case 2: + p.SetState(3111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3110) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3113) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3114) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3115) + + var _x = p.Id_() + + localctx.(*Drop_signatureContext).Asym_key_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3118) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 213, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_statistics_name_azure_dw_and_pdwContext is an interface to support dynamic dispatch. +type IDrop_statistics_name_azure_dw_and_pdwContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetObject_name returns the object_name rule contexts. + GetObject_name() IId_Context + + // GetStatistics_name returns the statistics_name rule contexts. + GetStatistics_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetObject_name sets the object_name rule contexts. + SetObject_name(IId_Context) + + // SetStatistics_name sets the statistics_name rule contexts. + SetStatistics_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + + // IsDrop_statistics_name_azure_dw_and_pdwContext differentiates from other interfaces. + IsDrop_statistics_name_azure_dw_and_pdwContext() +} + +type Drop_statistics_name_azure_dw_and_pdwContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + object_name IId_Context + statistics_name IId_Context +} + +func NewEmptyDrop_statistics_name_azure_dw_and_pdwContext() *Drop_statistics_name_azure_dw_and_pdwContext { + var p = new(Drop_statistics_name_azure_dw_and_pdwContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_statistics_name_azure_dw_and_pdw + return p +} + +func InitEmptyDrop_statistics_name_azure_dw_and_pdwContext(p *Drop_statistics_name_azure_dw_and_pdwContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_statistics_name_azure_dw_and_pdw +} + +func (*Drop_statistics_name_azure_dw_and_pdwContext) IsDrop_statistics_name_azure_dw_and_pdwContext() { +} + +func NewDrop_statistics_name_azure_dw_and_pdwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_statistics_name_azure_dw_and_pdwContext { + var p = new(Drop_statistics_name_azure_dw_and_pdwContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_statistics_name_azure_dw_and_pdw + + return p +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) GetSchema_name() IId_Context { + return s.schema_name +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) GetObject_name() IId_Context { + return s.object_name +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) GetStatistics_name() IId_Context { + return s.statistics_name +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) SetSchema_name(v IId_Context) { + s.schema_name = v +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) SetObject_name(v IId_Context) { + s.object_name = v +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) SetStatistics_name(v IId_Context) { + s.statistics_name = v +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS, 0) +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_statistics_name_azure_dw_and_pdw(s) + } +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_statistics_name_azure_dw_and_pdw(s) + } +} + +func (s *Drop_statistics_name_azure_dw_and_pdwContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_statistics_name_azure_dw_and_pdw(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_statistics_name_azure_dw_and_pdw() (localctx IDrop_statistics_name_azure_dw_and_pdwContext) { + localctx = NewDrop_statistics_name_azure_dw_and_pdwContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 264, TSqlParserRULE_drop_statistics_name_azure_dw_and_pdw) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3120) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3121) + p.Match(TSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3125) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 214, p.GetParserRuleContext()) == 1 { + { + p.SetState(3122) + + var _x = p.Id_() + + localctx.(*Drop_statistics_name_azure_dw_and_pdwContext).schema_name = _x + } + { + p.SetState(3123) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3127) + + var _x = p.Id_() + + localctx.(*Drop_statistics_name_azure_dw_and_pdwContext).object_name = _x + } + { + p.SetState(3128) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3129) + + var _x = p.Id_() + + localctx.(*Drop_statistics_name_azure_dw_and_pdwContext).statistics_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_symmetric_keyContext is an interface to support dynamic dispatch. +type IDrop_symmetric_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSymmetric_key_name returns the symmetric_key_name rule contexts. + GetSymmetric_key_name() IId_Context + + // SetSymmetric_key_name sets the symmetric_key_name rule contexts. + SetSymmetric_key_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + SYMMETRIC() antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + Id_() IId_Context + REMOVE() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + + // IsDrop_symmetric_keyContext differentiates from other interfaces. + IsDrop_symmetric_keyContext() +} + +type Drop_symmetric_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + symmetric_key_name IId_Context +} + +func NewEmptyDrop_symmetric_keyContext() *Drop_symmetric_keyContext { + var p = new(Drop_symmetric_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_symmetric_key + return p +} + +func InitEmptyDrop_symmetric_keyContext(p *Drop_symmetric_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_symmetric_key +} + +func (*Drop_symmetric_keyContext) IsDrop_symmetric_keyContext() {} + +func NewDrop_symmetric_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_symmetric_keyContext { + var p = new(Drop_symmetric_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_symmetric_key + + return p +} + +func (s *Drop_symmetric_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_symmetric_keyContext) GetSymmetric_key_name() IId_Context { return s.symmetric_key_name } + +func (s *Drop_symmetric_keyContext) SetSymmetric_key_name(v IId_Context) { s.symmetric_key_name = v } + +func (s *Drop_symmetric_keyContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_symmetric_keyContext) SYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserSYMMETRIC, 0) +} + +func (s *Drop_symmetric_keyContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserKEY) +} + +func (s *Drop_symmetric_keyContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, i) +} + +func (s *Drop_symmetric_keyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_symmetric_keyContext) REMOVE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOVE, 0) +} + +func (s *Drop_symmetric_keyContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER, 0) +} + +func (s *Drop_symmetric_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_symmetric_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_symmetric_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_symmetric_key(s) + } +} + +func (s *Drop_symmetric_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_symmetric_key(s) + } +} + +func (s *Drop_symmetric_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_symmetric_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_symmetric_key() (localctx IDrop_symmetric_keyContext) { + localctx = NewDrop_symmetric_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 266, TSqlParserRULE_drop_symmetric_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3131) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3132) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3133) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3134) + + var _x = p.Id_() + + localctx.(*Drop_symmetric_keyContext).symmetric_key_name = _x + } + p.SetState(3138) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 215, p.GetParserRuleContext()) == 1 { + { + p.SetState(3135) + p.Match(TSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3136) + p.Match(TSqlParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3137) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_synonymContext is an interface to support dynamic dispatch. +type IDrop_synonymContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema returns the schema rule contexts. + GetSchema() IId_Context + + // GetSynonym_name returns the synonym_name rule contexts. + GetSynonym_name() IId_Context + + // SetSchema sets the schema rule contexts. + SetSchema(IId_Context) + + // SetSynonym_name sets the synonym_name rule contexts. + SetSynonym_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + DOT() antlr.TerminalNode + + // IsDrop_synonymContext differentiates from other interfaces. + IsDrop_synonymContext() +} + +type Drop_synonymContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema IId_Context + synonym_name IId_Context +} + +func NewEmptyDrop_synonymContext() *Drop_synonymContext { + var p = new(Drop_synonymContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_synonym + return p +} + +func InitEmptyDrop_synonymContext(p *Drop_synonymContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_synonym +} + +func (*Drop_synonymContext) IsDrop_synonymContext() {} + +func NewDrop_synonymContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_synonymContext { + var p = new(Drop_synonymContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_synonym + + return p +} + +func (s *Drop_synonymContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_synonymContext) GetSchema() IId_Context { return s.schema } + +func (s *Drop_synonymContext) GetSynonym_name() IId_Context { return s.synonym_name } + +func (s *Drop_synonymContext) SetSchema(v IId_Context) { s.schema = v } + +func (s *Drop_synonymContext) SetSynonym_name(v IId_Context) { s.synonym_name = v } + +func (s *Drop_synonymContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_synonymContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(TSqlParserSYNONYM, 0) +} + +func (s *Drop_synonymContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_synonymContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_synonymContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_synonymContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_synonymContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Drop_synonymContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_synonymContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_synonymContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_synonym(s) + } +} + +func (s *Drop_synonymContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_synonym(s) + } +} + +func (s *Drop_synonymContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_synonym(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_synonym() (localctx IDrop_synonymContext) { + localctx = NewDrop_synonymContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 268, TSqlParserRULE_drop_synonym) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3140) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3141) + p.Match(TSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3144) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(3142) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3143) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3149) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 217, p.GetParserRuleContext()) == 1 { + { + p.SetState(3146) + + var _x = p.Id_() + + localctx.(*Drop_synonymContext).schema = _x + } + { + p.SetState(3147) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3151) + + var _x = p.Id_() + + localctx.(*Drop_synonymContext).synonym_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_userContext is an interface to support dynamic dispatch. +type IDrop_userContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUser_name returns the user_name rule contexts. + GetUser_name() IId_Context + + // SetUser_name sets the user_name rule contexts. + SetUser_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + USER() antlr.TerminalNode + Id_() IId_Context + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsDrop_userContext differentiates from other interfaces. + IsDrop_userContext() +} + +type Drop_userContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + user_name IId_Context +} + +func NewEmptyDrop_userContext() *Drop_userContext { + var p = new(Drop_userContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_user + return p +} + +func InitEmptyDrop_userContext(p *Drop_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_user +} + +func (*Drop_userContext) IsDrop_userContext() {} + +func NewDrop_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_userContext { + var p = new(Drop_userContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_user + + return p +} + +func (s *Drop_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_userContext) GetUser_name() IId_Context { return s.user_name } + +func (s *Drop_userContext) SetUser_name(v IId_Context) { s.user_name = v } + +func (s *Drop_userContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_userContext) USER() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER, 0) +} + +func (s *Drop_userContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_userContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_userContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_userContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_userContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_userContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_user(s) + } +} + +func (s *Drop_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_user(s) + } +} + +func (s *Drop_userContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_user(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_user() (localctx IDrop_userContext) { + localctx = NewDrop_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 270, TSqlParserRULE_drop_user) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3153) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3154) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3157) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(3155) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3156) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3159) + + var _x = p.Id_() + + localctx.(*Drop_userContext).user_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_workload_groupContext is an interface to support dynamic dispatch. +type IDrop_workload_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetGroup_name returns the group_name rule contexts. + GetGroup_name() IId_Context + + // SetGroup_name sets the group_name rule contexts. + SetGroup_name(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + WORKLOAD() antlr.TerminalNode + GROUP() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_workload_groupContext differentiates from other interfaces. + IsDrop_workload_groupContext() +} + +type Drop_workload_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + group_name IId_Context +} + +func NewEmptyDrop_workload_groupContext() *Drop_workload_groupContext { + var p = new(Drop_workload_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_workload_group + return p +} + +func InitEmptyDrop_workload_groupContext(p *Drop_workload_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_workload_group +} + +func (*Drop_workload_groupContext) IsDrop_workload_groupContext() {} + +func NewDrop_workload_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_workload_groupContext { + var p = new(Drop_workload_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_workload_group + + return p +} + +func (s *Drop_workload_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_workload_groupContext) GetGroup_name() IId_Context { return s.group_name } + +func (s *Drop_workload_groupContext) SetGroup_name(v IId_Context) { s.group_name = v } + +func (s *Drop_workload_groupContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_workload_groupContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(TSqlParserWORKLOAD, 0) +} + +func (s *Drop_workload_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *Drop_workload_groupContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_workload_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_workload_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_workload_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_workload_group(s) + } +} + +func (s *Drop_workload_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_workload_group(s) + } +} + +func (s *Drop_workload_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_workload_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_workload_group() (localctx IDrop_workload_groupContext) { + localctx = NewDrop_workload_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 272, TSqlParserRULE_drop_workload_group) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3161) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3162) + p.Match(TSqlParserWORKLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3163) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3164) + + var _x = p.Id_() + + localctx.(*Drop_workload_groupContext).group_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_xml_schema_collectionContext is an interface to support dynamic dispatch. +type IDrop_xml_schema_collectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRelational_schema returns the relational_schema rule contexts. + GetRelational_schema() IId_Context + + // GetSql_identifier returns the sql_identifier rule contexts. + GetSql_identifier() IId_Context + + // SetRelational_schema sets the relational_schema rule contexts. + SetRelational_schema(IId_Context) + + // SetSql_identifier sets the sql_identifier rule contexts. + SetSql_identifier(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + XML() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + COLLECTION() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + DOT() antlr.TerminalNode + + // IsDrop_xml_schema_collectionContext differentiates from other interfaces. + IsDrop_xml_schema_collectionContext() +} + +type Drop_xml_schema_collectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + relational_schema IId_Context + sql_identifier IId_Context +} + +func NewEmptyDrop_xml_schema_collectionContext() *Drop_xml_schema_collectionContext { + var p = new(Drop_xml_schema_collectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_xml_schema_collection + return p +} + +func InitEmptyDrop_xml_schema_collectionContext(p *Drop_xml_schema_collectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_xml_schema_collection +} + +func (*Drop_xml_schema_collectionContext) IsDrop_xml_schema_collectionContext() {} + +func NewDrop_xml_schema_collectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_xml_schema_collectionContext { + var p = new(Drop_xml_schema_collectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_xml_schema_collection + + return p +} + +func (s *Drop_xml_schema_collectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_xml_schema_collectionContext) GetRelational_schema() IId_Context { + return s.relational_schema +} + +func (s *Drop_xml_schema_collectionContext) GetSql_identifier() IId_Context { return s.sql_identifier } + +func (s *Drop_xml_schema_collectionContext) SetRelational_schema(v IId_Context) { + s.relational_schema = v +} + +func (s *Drop_xml_schema_collectionContext) SetSql_identifier(v IId_Context) { s.sql_identifier = v } + +func (s *Drop_xml_schema_collectionContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_xml_schema_collectionContext) XML() antlr.TerminalNode { + return s.GetToken(TSqlParserXML, 0) +} + +func (s *Drop_xml_schema_collectionContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Drop_xml_schema_collectionContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLECTION, 0) +} + +func (s *Drop_xml_schema_collectionContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_xml_schema_collectionContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_xml_schema_collectionContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Drop_xml_schema_collectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_xml_schema_collectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_xml_schema_collectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_xml_schema_collection(s) + } +} + +func (s *Drop_xml_schema_collectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_xml_schema_collection(s) + } +} + +func (s *Drop_xml_schema_collectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_xml_schema_collection(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_xml_schema_collection() (localctx IDrop_xml_schema_collectionContext) { + localctx = NewDrop_xml_schema_collectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 274, TSqlParserRULE_drop_xml_schema_collection) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3166) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3167) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3168) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3169) + p.Match(TSqlParserCOLLECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3173) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 219, p.GetParserRuleContext()) == 1 { + { + p.SetState(3170) + + var _x = p.Id_() + + localctx.(*Drop_xml_schema_collectionContext).relational_schema = _x + } + { + p.SetState(3171) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3175) + + var _x = p.Id_() + + localctx.(*Drop_xml_schema_collectionContext).sql_identifier = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDisable_triggerContext is an interface to support dynamic dispatch. +type IDisable_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetTrigger_name returns the trigger_name rule contexts. + GetTrigger_name() IId_Context + + // GetSchema_id returns the schema_id rule contexts. + GetSchema_id() IId_Context + + // GetObject_name returns the object_name rule contexts. + GetObject_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetTrigger_name sets the trigger_name rule contexts. + SetTrigger_name(IId_Context) + + // SetSchema_id sets the schema_id rule contexts. + SetSchema_id(IId_Context) + + // SetObject_name sets the object_name rule contexts. + SetObject_name(IId_Context) + + // Getter signatures + DISABLE() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + ON() antlr.TerminalNode + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + DATABASE() antlr.TerminalNode + SERVER() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDisable_triggerContext differentiates from other interfaces. + IsDisable_triggerContext() +} + +type Disable_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + trigger_name IId_Context + schema_id IId_Context + object_name IId_Context +} + +func NewEmptyDisable_triggerContext() *Disable_triggerContext { + var p = new(Disable_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_disable_trigger + return p +} + +func InitEmptyDisable_triggerContext(p *Disable_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_disable_trigger +} + +func (*Disable_triggerContext) IsDisable_triggerContext() {} + +func NewDisable_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Disable_triggerContext { + var p = new(Disable_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_disable_trigger + + return p +} + +func (s *Disable_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Disable_triggerContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Disable_triggerContext) GetTrigger_name() IId_Context { return s.trigger_name } + +func (s *Disable_triggerContext) GetSchema_id() IId_Context { return s.schema_id } + +func (s *Disable_triggerContext) GetObject_name() IId_Context { return s.object_name } + +func (s *Disable_triggerContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Disable_triggerContext) SetTrigger_name(v IId_Context) { s.trigger_name = v } + +func (s *Disable_triggerContext) SetSchema_id(v IId_Context) { s.schema_id = v } + +func (s *Disable_triggerContext) SetObject_name(v IId_Context) { s.object_name = v } + +func (s *Disable_triggerContext) DISABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLE, 0) +} + +func (s *Disable_triggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIGGER, 0) +} + +func (s *Disable_triggerContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Disable_triggerContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserALL) +} + +func (s *Disable_triggerContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserALL, i) +} + +func (s *Disable_triggerContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Disable_triggerContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Disable_triggerContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Disable_triggerContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Disable_triggerContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Disable_triggerContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Disable_triggerContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Disable_triggerContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Disable_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Disable_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Disable_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDisable_trigger(s) + } +} + +func (s *Disable_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDisable_trigger(s) + } +} + +func (s *Disable_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDisable_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Disable_trigger() (localctx IDisable_triggerContext) { + localctx = NewDisable_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 276, TSqlParserRULE_disable_trigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3177) + p.Match(TSqlParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3178) + p.Match(TSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3193) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserCOMMA: + p.SetState(3188) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&562949975835135) != 0) { + p.SetState(3180) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3179) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3185) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 221, p.GetParserRuleContext()) == 1 { + { + p.SetState(3182) + + var _x = p.Id_() + + localctx.(*Disable_triggerContext).schema_name = _x + } + { + p.SetState(3183) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3187) + + var _x = p.Id_() + + localctx.(*Disable_triggerContext).trigger_name = _x + } + + p.SetState(3190) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case TSqlParserALL: + { + p.SetState(3192) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(3195) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3205) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + p.SetState(3199) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 224, p.GetParserRuleContext()) == 1 { + { + p.SetState(3196) + + var _x = p.Id_() + + localctx.(*Disable_triggerContext).schema_id = _x + } + { + p.SetState(3197) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3201) + + var _x = p.Id_() + + localctx.(*Disable_triggerContext).object_name = _x + } + + case TSqlParserDATABASE: + { + p.SetState(3202) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserALL: + { + p.SetState(3203) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3204) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEnable_triggerContext is an interface to support dynamic dispatch. +type IEnable_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetTrigger_name returns the trigger_name rule contexts. + GetTrigger_name() IId_Context + + // GetSchema_id returns the schema_id rule contexts. + GetSchema_id() IId_Context + + // GetObject_name returns the object_name rule contexts. + GetObject_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetTrigger_name sets the trigger_name rule contexts. + SetTrigger_name(IId_Context) + + // SetSchema_id sets the schema_id rule contexts. + SetSchema_id(IId_Context) + + // SetObject_name sets the object_name rule contexts. + SetObject_name(IId_Context) + + // Getter signatures + ENABLE() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + ON() antlr.TerminalNode + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + DATABASE() antlr.TerminalNode + SERVER() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsEnable_triggerContext differentiates from other interfaces. + IsEnable_triggerContext() +} + +type Enable_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + trigger_name IId_Context + schema_id IId_Context + object_name IId_Context +} + +func NewEmptyEnable_triggerContext() *Enable_triggerContext { + var p = new(Enable_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_enable_trigger + return p +} + +func InitEmptyEnable_triggerContext(p *Enable_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_enable_trigger +} + +func (*Enable_triggerContext) IsEnable_triggerContext() {} + +func NewEnable_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_triggerContext { + var p = new(Enable_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_enable_trigger + + return p +} + +func (s *Enable_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Enable_triggerContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Enable_triggerContext) GetTrigger_name() IId_Context { return s.trigger_name } + +func (s *Enable_triggerContext) GetSchema_id() IId_Context { return s.schema_id } + +func (s *Enable_triggerContext) GetObject_name() IId_Context { return s.object_name } + +func (s *Enable_triggerContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Enable_triggerContext) SetTrigger_name(v IId_Context) { s.trigger_name = v } + +func (s *Enable_triggerContext) SetSchema_id(v IId_Context) { s.schema_id = v } + +func (s *Enable_triggerContext) SetObject_name(v IId_Context) { s.object_name = v } + +func (s *Enable_triggerContext) ENABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserENABLE, 0) +} + +func (s *Enable_triggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIGGER, 0) +} + +func (s *Enable_triggerContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Enable_triggerContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserALL) +} + +func (s *Enable_triggerContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserALL, i) +} + +func (s *Enable_triggerContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Enable_triggerContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Enable_triggerContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Enable_triggerContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Enable_triggerContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Enable_triggerContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Enable_triggerContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Enable_triggerContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Enable_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Enable_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Enable_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEnable_trigger(s) + } +} + +func (s *Enable_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEnable_trigger(s) + } +} + +func (s *Enable_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEnable_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Enable_trigger() (localctx IEnable_triggerContext) { + localctx = NewEnable_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 278, TSqlParserRULE_enable_trigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3207) + p.Match(TSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3208) + p.Match(TSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3223) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserCOMMA: + p.SetState(3218) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&562949975835135) != 0) { + p.SetState(3210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3209) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3215) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 227, p.GetParserRuleContext()) == 1 { + { + p.SetState(3212) + + var _x = p.Id_() + + localctx.(*Enable_triggerContext).schema_name = _x + } + { + p.SetState(3213) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3217) + + var _x = p.Id_() + + localctx.(*Enable_triggerContext).trigger_name = _x + } + + p.SetState(3220) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case TSqlParserALL: + { + p.SetState(3222) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(3225) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3235) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + p.SetState(3229) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 230, p.GetParserRuleContext()) == 1 { + { + p.SetState(3226) + + var _x = p.Id_() + + localctx.(*Enable_triggerContext).schema_id = _x + } + { + p.SetState(3227) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3231) + + var _x = p.Id_() + + localctx.(*Enable_triggerContext).object_name = _x + } + + case TSqlParserDATABASE: + { + p.SetState(3232) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserALL: + { + p.SetState(3233) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3234) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILock_tableContext is an interface to support dynamic dispatch. +type ILock_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSeconds returns the seconds token. + GetSeconds() antlr.Token + + // SetSeconds sets the seconds token. + SetSeconds(antlr.Token) + + // Getter signatures + LOCK() antlr.TerminalNode + TABLE() antlr.TerminalNode + Table_name() ITable_nameContext + IN() antlr.TerminalNode + MODE() antlr.TerminalNode + SHARE() antlr.TerminalNode + EXCLUSIVE() antlr.TerminalNode + WAIT() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + SEMI() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + + // IsLock_tableContext differentiates from other interfaces. + IsLock_tableContext() +} + +type Lock_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + seconds antlr.Token +} + +func NewEmptyLock_tableContext() *Lock_tableContext { + var p = new(Lock_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_lock_table + return p +} + +func InitEmptyLock_tableContext(p *Lock_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_lock_table +} + +func (*Lock_tableContext) IsLock_tableContext() {} + +func NewLock_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lock_tableContext { + var p = new(Lock_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_lock_table + + return p +} + +func (s *Lock_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lock_tableContext) GetSeconds() antlr.Token { return s.seconds } + +func (s *Lock_tableContext) SetSeconds(v antlr.Token) { s.seconds = v } + +func (s *Lock_tableContext) LOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCK, 0) +} + +func (s *Lock_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLE, 0) +} + +func (s *Lock_tableContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Lock_tableContext) IN() antlr.TerminalNode { + return s.GetToken(TSqlParserIN, 0) +} + +func (s *Lock_tableContext) MODE() antlr.TerminalNode { + return s.GetToken(TSqlParserMODE, 0) +} + +func (s *Lock_tableContext) SHARE() antlr.TerminalNode { + return s.GetToken(TSqlParserSHARE, 0) +} + +func (s *Lock_tableContext) EXCLUSIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXCLUSIVE, 0) +} + +func (s *Lock_tableContext) WAIT() antlr.TerminalNode { + return s.GetToken(TSqlParserWAIT, 0) +} + +func (s *Lock_tableContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOWAIT, 0) +} + +func (s *Lock_tableContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Lock_tableContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Lock_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lock_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lock_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterLock_table(s) + } +} + +func (s *Lock_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitLock_table(s) + } +} + +func (s *Lock_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitLock_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Lock_table() (localctx ILock_tableContext) { + localctx = NewLock_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 280, TSqlParserRULE_lock_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3237) + p.Match(TSqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3238) + p.Match(TSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3239) + p.Table_name() + } + { + p.SetState(3240) + p.Match(TSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3241) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserEXCLUSIVE || _la == TSqlParserSHARE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3242) + p.Match(TSqlParserMODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3246) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 232, p.GetParserRuleContext()) == 1 { + { + p.SetState(3243) + p.Match(TSqlParserWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3244) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Lock_tableContext).seconds = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 232, p.GetParserRuleContext()) == 2 { + { + p.SetState(3245) + p.Match(TSqlParserNOWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3249) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 233, p.GetParserRuleContext()) == 1 { + { + p.SetState(3248) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITruncate_tableContext is an interface to support dynamic dispatch. +type ITruncate_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUNCATE() antlr.TerminalNode + TABLE() antlr.TerminalNode + Table_name() ITable_nameContext + WITH() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTruncate_tableContext differentiates from other interfaces. + IsTruncate_tableContext() +} + +type Truncate_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTruncate_tableContext() *Truncate_tableContext { + var p = new(Truncate_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_truncate_table + return p +} + +func InitEmptyTruncate_tableContext(p *Truncate_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_truncate_table +} + +func (*Truncate_tableContext) IsTruncate_tableContext() {} + +func NewTruncate_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Truncate_tableContext { + var p = new(Truncate_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_truncate_table + + return p +} + +func (s *Truncate_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Truncate_tableContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(TSqlParserTRUNCATE, 0) +} + +func (s *Truncate_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLE, 0) +} + +func (s *Truncate_tableContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Truncate_tableContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Truncate_tableContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Truncate_tableContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Truncate_tableContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITIONS, 0) +} + +func (s *Truncate_tableContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Truncate_tableContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Truncate_tableContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Truncate_tableContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Truncate_tableContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTO) +} + +func (s *Truncate_tableContext) TO(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTO, i) +} + +func (s *Truncate_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Truncate_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Truncate_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Truncate_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Truncate_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTruncate_table(s) + } +} + +func (s *Truncate_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTruncate_table(s) + } +} + +func (s *Truncate_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTruncate_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Truncate_table() (localctx ITruncate_tableContext) { + localctx = NewTruncate_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 282, TSqlParserRULE_truncate_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3251) + p.Match(TSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3252) + p.Match(TSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3253) + p.Table_name() + } + p.SetState(3273) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 237, p.GetParserRuleContext()) == 1 { + { + p.SetState(3254) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3255) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3256) + p.Match(TSqlParserPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3257) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserDECIMAL || _la == TSqlParserCOMMA { + p.SetState(3259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3258) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3265) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 235, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3261) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(3262) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3263) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3264) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(3269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3271) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3272) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_column_master_keyContext is an interface to support dynamic dispatch. +type ICreate_column_master_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKey_store_provider_name returns the key_store_provider_name token. + GetKey_store_provider_name() antlr.Token + + // GetKey_path returns the key_path token. + GetKey_path() antlr.Token + + // SetKey_store_provider_name sets the key_store_provider_name token. + SetKey_store_provider_name(antlr.Token) + + // SetKey_path sets the key_path token. + SetKey_path(antlr.Token) + + // GetKey_name returns the key_name rule contexts. + GetKey_name() IId_Context + + // SetKey_name sets the key_name rule contexts. + SetKey_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + COLUMN() antlr.TerminalNode + MASTER() antlr.TerminalNode + KEY() antlr.TerminalNode + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + KEY_STORE_PROVIDER_NAME() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + KEY_PATH() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Id_() IId_Context + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + + // IsCreate_column_master_keyContext differentiates from other interfaces. + IsCreate_column_master_keyContext() +} + +type Create_column_master_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + key_name IId_Context + key_store_provider_name antlr.Token + key_path antlr.Token +} + +func NewEmptyCreate_column_master_keyContext() *Create_column_master_keyContext { + var p = new(Create_column_master_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_column_master_key + return p +} + +func InitEmptyCreate_column_master_keyContext(p *Create_column_master_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_column_master_key +} + +func (*Create_column_master_keyContext) IsCreate_column_master_keyContext() {} + +func NewCreate_column_master_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_column_master_keyContext { + var p = new(Create_column_master_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_column_master_key + + return p +} + +func (s *Create_column_master_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_column_master_keyContext) GetKey_store_provider_name() antlr.Token { + return s.key_store_provider_name +} + +func (s *Create_column_master_keyContext) GetKey_path() antlr.Token { return s.key_path } + +func (s *Create_column_master_keyContext) SetKey_store_provider_name(v antlr.Token) { + s.key_store_provider_name = v +} + +func (s *Create_column_master_keyContext) SetKey_path(v antlr.Token) { s.key_path = v } + +func (s *Create_column_master_keyContext) GetKey_name() IId_Context { return s.key_name } + +func (s *Create_column_master_keyContext) SetKey_name(v IId_Context) { s.key_name = v } + +func (s *Create_column_master_keyContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_column_master_keyContext) COLUMN() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMN, 0) +} + +func (s *Create_column_master_keyContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *Create_column_master_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Create_column_master_keyContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_column_master_keyContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_column_master_keyContext) KEY_STORE_PROVIDER_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY_STORE_PROVIDER_NAME, 0) +} + +func (s *Create_column_master_keyContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_column_master_keyContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_column_master_keyContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Create_column_master_keyContext) KEY_PATH() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY_PATH, 0) +} + +func (s *Create_column_master_keyContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_column_master_keyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_column_master_keyContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Create_column_master_keyContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Create_column_master_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_column_master_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_column_master_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_column_master_key(s) + } +} + +func (s *Create_column_master_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_column_master_key(s) + } +} + +func (s *Create_column_master_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_column_master_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_column_master_key() (localctx ICreate_column_master_keyContext) { + localctx = NewCreate_column_master_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 284, TSqlParserRULE_create_column_master_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3275) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3276) + p.Match(TSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3277) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3278) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3279) + + var _x = p.Id_() + + localctx.(*Create_column_master_keyContext).key_name = _x + } + { + p.SetState(3280) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3281) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3282) + p.Match(TSqlParserKEY_STORE_PROVIDER_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3283) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3284) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_column_master_keyContext).key_store_provider_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3285) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3286) + p.Match(TSqlParserKEY_PATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3287) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3288) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_column_master_keyContext).key_path = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3289) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_credentialContext is an interface to support dynamic dispatch. +type IAlter_credentialContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIdentity_name returns the identity_name token. + GetIdentity_name() antlr.Token + + // GetSecret returns the secret token. + GetSecret() antlr.Token + + // SetIdentity_name sets the identity_name token. + SetIdentity_name(antlr.Token) + + // SetSecret sets the secret token. + SetSecret(antlr.Token) + + // GetCredential_name returns the credential_name rule contexts. + GetCredential_name() IId_Context + + // SetCredential_name sets the credential_name rule contexts. + SetCredential_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + CREDENTIAL() antlr.TerminalNode + WITH() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + Id_() IId_Context + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + SECRET() antlr.TerminalNode + + // IsAlter_credentialContext differentiates from other interfaces. + IsAlter_credentialContext() +} + +type Alter_credentialContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + credential_name IId_Context + identity_name antlr.Token + secret antlr.Token +} + +func NewEmptyAlter_credentialContext() *Alter_credentialContext { + var p = new(Alter_credentialContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_credential + return p +} + +func InitEmptyAlter_credentialContext(p *Alter_credentialContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_credential +} + +func (*Alter_credentialContext) IsAlter_credentialContext() {} + +func NewAlter_credentialContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_credentialContext { + var p = new(Alter_credentialContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_credential + + return p +} + +func (s *Alter_credentialContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_credentialContext) GetIdentity_name() antlr.Token { return s.identity_name } + +func (s *Alter_credentialContext) GetSecret() antlr.Token { return s.secret } + +func (s *Alter_credentialContext) SetIdentity_name(v antlr.Token) { s.identity_name = v } + +func (s *Alter_credentialContext) SetSecret(v antlr.Token) { s.secret = v } + +func (s *Alter_credentialContext) GetCredential_name() IId_Context { return s.credential_name } + +func (s *Alter_credentialContext) SetCredential_name(v IId_Context) { s.credential_name = v } + +func (s *Alter_credentialContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_credentialContext) CREDENTIAL() antlr.TerminalNode { + return s.GetToken(TSqlParserCREDENTIAL, 0) +} + +func (s *Alter_credentialContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_credentialContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENTITY, 0) +} + +func (s *Alter_credentialContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_credentialContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_credentialContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_credentialContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Alter_credentialContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Alter_credentialContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Alter_credentialContext) SECRET() antlr.TerminalNode { + return s.GetToken(TSqlParserSECRET, 0) +} + +func (s *Alter_credentialContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_credentialContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_credentialContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_credential(s) + } +} + +func (s *Alter_credentialContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_credential(s) + } +} + +func (s *Alter_credentialContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_credential(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_credential() (localctx IAlter_credentialContext) { + localctx = NewAlter_credentialContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 286, TSqlParserRULE_alter_credential) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3291) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3292) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3293) + + var _x = p.Id_() + + localctx.(*Alter_credentialContext).credential_name = _x + } + { + p.SetState(3294) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3295) + p.Match(TSqlParserIDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3296) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3297) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_credentialContext).identity_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3302) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3298) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3299) + p.Match(TSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3300) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3301) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_credentialContext).secret = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_credentialContext is an interface to support dynamic dispatch. +type ICreate_credentialContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIdentity_name returns the identity_name token. + GetIdentity_name() antlr.Token + + // GetSecret returns the secret token. + GetSecret() antlr.Token + + // SetIdentity_name sets the identity_name token. + SetIdentity_name(antlr.Token) + + // SetSecret sets the secret token. + SetSecret(antlr.Token) + + // GetCredential_name returns the credential_name rule contexts. + GetCredential_name() IId_Context + + // GetCryptographic_provider_name returns the cryptographic_provider_name rule contexts. + GetCryptographic_provider_name() IId_Context + + // SetCredential_name sets the credential_name rule contexts. + SetCredential_name(IId_Context) + + // SetCryptographic_provider_name sets the cryptographic_provider_name rule contexts. + SetCryptographic_provider_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + CREDENTIAL() antlr.TerminalNode + WITH() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + SECRET() antlr.TerminalNode + FOR() antlr.TerminalNode + CRYPTOGRAPHIC() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + + // IsCreate_credentialContext differentiates from other interfaces. + IsCreate_credentialContext() +} + +type Create_credentialContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + credential_name IId_Context + identity_name antlr.Token + secret antlr.Token + cryptographic_provider_name IId_Context +} + +func NewEmptyCreate_credentialContext() *Create_credentialContext { + var p = new(Create_credentialContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_credential + return p +} + +func InitEmptyCreate_credentialContext(p *Create_credentialContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_credential +} + +func (*Create_credentialContext) IsCreate_credentialContext() {} + +func NewCreate_credentialContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_credentialContext { + var p = new(Create_credentialContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_credential + + return p +} + +func (s *Create_credentialContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_credentialContext) GetIdentity_name() antlr.Token { return s.identity_name } + +func (s *Create_credentialContext) GetSecret() antlr.Token { return s.secret } + +func (s *Create_credentialContext) SetIdentity_name(v antlr.Token) { s.identity_name = v } + +func (s *Create_credentialContext) SetSecret(v antlr.Token) { s.secret = v } + +func (s *Create_credentialContext) GetCredential_name() IId_Context { return s.credential_name } + +func (s *Create_credentialContext) GetCryptographic_provider_name() IId_Context { + return s.cryptographic_provider_name +} + +func (s *Create_credentialContext) SetCredential_name(v IId_Context) { s.credential_name = v } + +func (s *Create_credentialContext) SetCryptographic_provider_name(v IId_Context) { + s.cryptographic_provider_name = v +} + +func (s *Create_credentialContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_credentialContext) CREDENTIAL() antlr.TerminalNode { + return s.GetToken(TSqlParserCREDENTIAL, 0) +} + +func (s *Create_credentialContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_credentialContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENTITY, 0) +} + +func (s *Create_credentialContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_credentialContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_credentialContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_credentialContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_credentialContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Create_credentialContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Create_credentialContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Create_credentialContext) SECRET() antlr.TerminalNode { + return s.GetToken(TSqlParserSECRET, 0) +} + +func (s *Create_credentialContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_credentialContext) CRYPTOGRAPHIC() antlr.TerminalNode { + return s.GetToken(TSqlParserCRYPTOGRAPHIC, 0) +} + +func (s *Create_credentialContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER, 0) +} + +func (s *Create_credentialContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_credentialContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_credentialContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_credential(s) + } +} + +func (s *Create_credentialContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_credential(s) + } +} + +func (s *Create_credentialContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_credential(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_credential() (localctx ICreate_credentialContext) { + localctx = NewCreate_credentialContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 288, TSqlParserRULE_create_credential) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3304) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3305) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3306) + + var _x = p.Id_() + + localctx.(*Create_credentialContext).credential_name = _x + } + { + p.SetState(3307) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3308) + p.Match(TSqlParserIDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3309) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3310) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_credentialContext).identity_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3315) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3311) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3312) + p.Match(TSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3313) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3314) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_credentialContext).secret = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR { + { + p.SetState(3317) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3318) + p.Match(TSqlParserCRYPTOGRAPHIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3319) + p.Match(TSqlParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3320) + + var _x = p.Id_() + + localctx.(*Create_credentialContext).cryptographic_provider_name = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_cryptographic_providerContext is an interface to support dynamic dispatch. +type IAlter_cryptographic_providerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCrypto_provider_ddl_file returns the crypto_provider_ddl_file token. + GetCrypto_provider_ddl_file() antlr.Token + + // SetCrypto_provider_ddl_file sets the crypto_provider_ddl_file token. + SetCrypto_provider_ddl_file(antlr.Token) + + // GetProvider_name returns the provider_name rule contexts. + GetProvider_name() IId_Context + + // SetProvider_name sets the provider_name rule contexts. + SetProvider_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + CRYPTOGRAPHIC() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + Id_() IId_Context + FROM() antlr.TerminalNode + FILE() antlr.TerminalNode + EQUAL() antlr.TerminalNode + STRING() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsAlter_cryptographic_providerContext differentiates from other interfaces. + IsAlter_cryptographic_providerContext() +} + +type Alter_cryptographic_providerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + provider_name IId_Context + crypto_provider_ddl_file antlr.Token +} + +func NewEmptyAlter_cryptographic_providerContext() *Alter_cryptographic_providerContext { + var p = new(Alter_cryptographic_providerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_cryptographic_provider + return p +} + +func InitEmptyAlter_cryptographic_providerContext(p *Alter_cryptographic_providerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_cryptographic_provider +} + +func (*Alter_cryptographic_providerContext) IsAlter_cryptographic_providerContext() {} + +func NewAlter_cryptographic_providerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_cryptographic_providerContext { + var p = new(Alter_cryptographic_providerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_cryptographic_provider + + return p +} + +func (s *Alter_cryptographic_providerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_cryptographic_providerContext) GetCrypto_provider_ddl_file() antlr.Token { + return s.crypto_provider_ddl_file +} + +func (s *Alter_cryptographic_providerContext) SetCrypto_provider_ddl_file(v antlr.Token) { + s.crypto_provider_ddl_file = v +} + +func (s *Alter_cryptographic_providerContext) GetProvider_name() IId_Context { return s.provider_name } + +func (s *Alter_cryptographic_providerContext) SetProvider_name(v IId_Context) { s.provider_name = v } + +func (s *Alter_cryptographic_providerContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_cryptographic_providerContext) CRYPTOGRAPHIC() antlr.TerminalNode { + return s.GetToken(TSqlParserCRYPTOGRAPHIC, 0) +} + +func (s *Alter_cryptographic_providerContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER, 0) +} + +func (s *Alter_cryptographic_providerContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_cryptographic_providerContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Alter_cryptographic_providerContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Alter_cryptographic_providerContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_cryptographic_providerContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Alter_cryptographic_providerContext) ENABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserENABLE, 0) +} + +func (s *Alter_cryptographic_providerContext) DISABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLE, 0) +} + +func (s *Alter_cryptographic_providerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_cryptographic_providerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_cryptographic_providerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_cryptographic_provider(s) + } +} + +func (s *Alter_cryptographic_providerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_cryptographic_provider(s) + } +} + +func (s *Alter_cryptographic_providerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_cryptographic_provider(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_cryptographic_provider() (localctx IAlter_cryptographic_providerContext) { + localctx = NewAlter_cryptographic_providerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 290, TSqlParserRULE_alter_cryptographic_provider) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3323) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3324) + p.Match(TSqlParserCRYPTOGRAPHIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3325) + p.Match(TSqlParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3326) + + var _x = p.Id_() + + localctx.(*Alter_cryptographic_providerContext).provider_name = _x + } + p.SetState(3331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFROM { + { + p.SetState(3327) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3328) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3329) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3330) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_cryptographic_providerContext).crypto_provider_ddl_file = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3334) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 242, p.GetParserRuleContext()) == 1 { + { + p.SetState(3333) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISABLE || _la == TSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_cryptographic_providerContext is an interface to support dynamic dispatch. +type ICreate_cryptographic_providerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPath_of_DLL returns the path_of_DLL token. + GetPath_of_DLL() antlr.Token + + // SetPath_of_DLL sets the path_of_DLL token. + SetPath_of_DLL(antlr.Token) + + // GetProvider_name returns the provider_name rule contexts. + GetProvider_name() IId_Context + + // SetProvider_name sets the provider_name rule contexts. + SetProvider_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + CRYPTOGRAPHIC() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + FROM() antlr.TerminalNode + FILE() antlr.TerminalNode + EQUAL() antlr.TerminalNode + Id_() IId_Context + STRING() antlr.TerminalNode + + // IsCreate_cryptographic_providerContext differentiates from other interfaces. + IsCreate_cryptographic_providerContext() +} + +type Create_cryptographic_providerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + provider_name IId_Context + path_of_DLL antlr.Token +} + +func NewEmptyCreate_cryptographic_providerContext() *Create_cryptographic_providerContext { + var p = new(Create_cryptographic_providerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_cryptographic_provider + return p +} + +func InitEmptyCreate_cryptographic_providerContext(p *Create_cryptographic_providerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_cryptographic_provider +} + +func (*Create_cryptographic_providerContext) IsCreate_cryptographic_providerContext() {} + +func NewCreate_cryptographic_providerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_cryptographic_providerContext { + var p = new(Create_cryptographic_providerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_cryptographic_provider + + return p +} + +func (s *Create_cryptographic_providerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_cryptographic_providerContext) GetPath_of_DLL() antlr.Token { return s.path_of_DLL } + +func (s *Create_cryptographic_providerContext) SetPath_of_DLL(v antlr.Token) { s.path_of_DLL = v } + +func (s *Create_cryptographic_providerContext) GetProvider_name() IId_Context { return s.provider_name } + +func (s *Create_cryptographic_providerContext) SetProvider_name(v IId_Context) { s.provider_name = v } + +func (s *Create_cryptographic_providerContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_cryptographic_providerContext) CRYPTOGRAPHIC() antlr.TerminalNode { + return s.GetToken(TSqlParserCRYPTOGRAPHIC, 0) +} + +func (s *Create_cryptographic_providerContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER, 0) +} + +func (s *Create_cryptographic_providerContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Create_cryptographic_providerContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Create_cryptographic_providerContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_cryptographic_providerContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_cryptographic_providerContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_cryptographic_providerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_cryptographic_providerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_cryptographic_providerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_cryptographic_provider(s) + } +} + +func (s *Create_cryptographic_providerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_cryptographic_provider(s) + } +} + +func (s *Create_cryptographic_providerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_cryptographic_provider(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_cryptographic_provider() (localctx ICreate_cryptographic_providerContext) { + localctx = NewCreate_cryptographic_providerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 292, TSqlParserRULE_create_cryptographic_provider) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3336) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3337) + p.Match(TSqlParserCRYPTOGRAPHIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3338) + p.Match(TSqlParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3339) + + var _x = p.Id_() + + localctx.(*Create_cryptographic_providerContext).provider_name = _x + } + { + p.SetState(3340) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3341) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3342) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3343) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_cryptographic_providerContext).path_of_DLL = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_endpointContext is an interface to support dynamic dispatch. +type ICreate_endpointContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetState returns the state token. + GetState() antlr.Token + + // SetState sets the state token. + SetState(antlr.Token) + + // GetEndpointname returns the endpointname rule contexts. + GetEndpointname() IId_Context + + // GetLogin returns the login rule contexts. + GetLogin() IId_Context + + // SetEndpointname sets the endpointname rule contexts. + SetEndpointname(IId_Context) + + // SetLogin sets the login rule contexts. + SetLogin(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + ENDPOINT() antlr.TerminalNode + AS() antlr.TerminalNode + TCP() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + Endpoint_listener_clause() IEndpoint_listener_clauseContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + FOR() antlr.TerminalNode + TSQL() antlr.TerminalNode + SERVICE_BROKER() antlr.TerminalNode + Endpoint_authentication_clause() IEndpoint_authentication_clauseContext + DATABASE_MIRRORING() antlr.TerminalNode + ROLE() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + STATE() antlr.TerminalNode + WITNESS() antlr.TerminalNode + PARTNER() antlr.TerminalNode + ALL() antlr.TerminalNode + STARTED() antlr.TerminalNode + STOPPED() antlr.TerminalNode + AllDISABLED() []antlr.TerminalNode + DISABLED(i int) antlr.TerminalNode + Endpoint_encryption_alogorithm_clause() IEndpoint_encryption_alogorithm_clauseContext + MESSAGE_FORWARDING() antlr.TerminalNode + MESSAGE_FORWARD_SIZE() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ENABLED() antlr.TerminalNode + + // IsCreate_endpointContext differentiates from other interfaces. + IsCreate_endpointContext() +} + +type Create_endpointContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + endpointname IId_Context + login IId_Context + state antlr.Token +} + +func NewEmptyCreate_endpointContext() *Create_endpointContext { + var p = new(Create_endpointContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_endpoint + return p +} + +func InitEmptyCreate_endpointContext(p *Create_endpointContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_endpoint +} + +func (*Create_endpointContext) IsCreate_endpointContext() {} + +func NewCreate_endpointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_endpointContext { + var p = new(Create_endpointContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_endpoint + + return p +} + +func (s *Create_endpointContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_endpointContext) GetState() antlr.Token { return s.state } + +func (s *Create_endpointContext) SetState(v antlr.Token) { s.state = v } + +func (s *Create_endpointContext) GetEndpointname() IId_Context { return s.endpointname } + +func (s *Create_endpointContext) GetLogin() IId_Context { return s.login } + +func (s *Create_endpointContext) SetEndpointname(v IId_Context) { s.endpointname = v } + +func (s *Create_endpointContext) SetLogin(v IId_Context) { s.login = v } + +func (s *Create_endpointContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_endpointContext) ENDPOINT() antlr.TerminalNode { + return s.GetToken(TSqlParserENDPOINT, 0) +} + +func (s *Create_endpointContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Create_endpointContext) TCP() antlr.TerminalNode { + return s.GetToken(TSqlParserTCP, 0) +} + +func (s *Create_endpointContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Create_endpointContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Create_endpointContext) Endpoint_listener_clause() IEndpoint_listener_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEndpoint_listener_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEndpoint_listener_clauseContext) +} + +func (s *Create_endpointContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Create_endpointContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Create_endpointContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_endpointContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_endpointContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_endpointContext) TSQL() antlr.TerminalNode { + return s.GetToken(TSqlParserTSQL, 0) +} + +func (s *Create_endpointContext) SERVICE_BROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE_BROKER, 0) +} + +func (s *Create_endpointContext) Endpoint_authentication_clause() IEndpoint_authentication_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEndpoint_authentication_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEndpoint_authentication_clauseContext) +} + +func (s *Create_endpointContext) DATABASE_MIRRORING() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE_MIRRORING, 0) +} + +func (s *Create_endpointContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Create_endpointContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_endpointContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_endpointContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_endpointContext) STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATE, 0) +} + +func (s *Create_endpointContext) WITNESS() antlr.TerminalNode { + return s.GetToken(TSqlParserWITNESS, 0) +} + +func (s *Create_endpointContext) PARTNER() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTNER, 0) +} + +func (s *Create_endpointContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Create_endpointContext) STARTED() antlr.TerminalNode { + return s.GetToken(TSqlParserSTARTED, 0) +} + +func (s *Create_endpointContext) STOPPED() antlr.TerminalNode { + return s.GetToken(TSqlParserSTOPPED, 0) +} + +func (s *Create_endpointContext) AllDISABLED() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDISABLED) +} + +func (s *Create_endpointContext) DISABLED(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLED, i) +} + +func (s *Create_endpointContext) Endpoint_encryption_alogorithm_clause() IEndpoint_encryption_alogorithm_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEndpoint_encryption_alogorithm_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEndpoint_encryption_alogorithm_clauseContext) +} + +func (s *Create_endpointContext) MESSAGE_FORWARDING() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE_FORWARDING, 0) +} + +func (s *Create_endpointContext) MESSAGE_FORWARD_SIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE_FORWARD_SIZE, 0) +} + +func (s *Create_endpointContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Create_endpointContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_endpointContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_endpointContext) ENABLED() antlr.TerminalNode { + return s.GetToken(TSqlParserENABLED, 0) +} + +func (s *Create_endpointContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_endpointContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_endpointContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_endpoint(s) + } +} + +func (s *Create_endpointContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_endpoint(s) + } +} + +func (s *Create_endpointContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_endpoint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_endpoint() (localctx ICreate_endpointContext) { + localctx = NewCreate_endpointContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 294, TSqlParserRULE_create_endpoint) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3345) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3346) + p.Match(TSqlParserENDPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3347) + + var _x = p.Id_() + + localctx.(*Create_endpointContext).endpointname = _x + } + p.SetState(3350) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(3348) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3349) + + var _x = p.Id_() + + localctx.(*Create_endpointContext).login = _x + } + + } + p.SetState(3355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSTATE { + { + p.SetState(3352) + p.Match(TSqlParserSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3353) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3354) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Create_endpointContext).state = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISABLED || _la == TSqlParserSTARTED || _la == TSqlParserSTOPPED) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Create_endpointContext).state = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(3357) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3358) + p.Match(TSqlParserTCP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3359) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3360) + p.Endpoint_listener_clause() + } + { + p.SetState(3361) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3412) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 254, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3362) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3363) + p.Match(TSqlParserTSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3364) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3365) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(3366) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3367) + p.Match(TSqlParserSERVICE_BROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3368) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3369) + p.Endpoint_authentication_clause() + } + p.SetState(3374) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 246, p.GetParserRuleContext()) == 1 { + p.SetState(3371) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3370) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3373) + p.Endpoint_encryption_alogorithm_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3382) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 248, p.GetParserRuleContext()) == 1 { + p.SetState(3377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3376) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3379) + p.Match(TSqlParserMESSAGE_FORWARDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3380) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3381) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISABLED || _la == TSqlParserENABLED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3390) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMESSAGE_FORWARD_SIZE || _la == TSqlParserCOMMA { + p.SetState(3385) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3384) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3387) + p.Match(TSqlParserMESSAGE_FORWARD_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3388) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3389) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3392) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(3394) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3395) + p.Match(TSqlParserDATABASE_MIRRORING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3396) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3397) + p.Endpoint_authentication_clause() + } + p.SetState(3402) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 252, p.GetParserRuleContext()) == 1 { + p.SetState(3399) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3398) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3401) + p.Endpoint_encryption_alogorithm_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3404) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3407) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3408) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3409) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALL || _la == TSqlParserPARTNER || _la == TSqlParserWITNESS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3410) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEndpoint_encryption_alogorithm_clauseContext is an interface to support dynamic dispatch. +type IEndpoint_encryption_alogorithm_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTION() antlr.TerminalNode + EQUAL() antlr.TerminalNode + DISABLED() antlr.TerminalNode + SUPPORTED() antlr.TerminalNode + REQUIRED() antlr.TerminalNode + ALGORITHM() antlr.TerminalNode + AES() antlr.TerminalNode + RC4() antlr.TerminalNode + + // IsEndpoint_encryption_alogorithm_clauseContext differentiates from other interfaces. + IsEndpoint_encryption_alogorithm_clauseContext() +} + +type Endpoint_encryption_alogorithm_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEndpoint_encryption_alogorithm_clauseContext() *Endpoint_encryption_alogorithm_clauseContext { + var p = new(Endpoint_encryption_alogorithm_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_endpoint_encryption_alogorithm_clause + return p +} + +func InitEmptyEndpoint_encryption_alogorithm_clauseContext(p *Endpoint_encryption_alogorithm_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_endpoint_encryption_alogorithm_clause +} + +func (*Endpoint_encryption_alogorithm_clauseContext) IsEndpoint_encryption_alogorithm_clauseContext() { +} + +func NewEndpoint_encryption_alogorithm_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Endpoint_encryption_alogorithm_clauseContext { + var p = new(Endpoint_encryption_alogorithm_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_endpoint_encryption_alogorithm_clause + + return p +} + +func (s *Endpoint_encryption_alogorithm_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Endpoint_encryption_alogorithm_clauseContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Endpoint_encryption_alogorithm_clauseContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Endpoint_encryption_alogorithm_clauseContext) DISABLED() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLED, 0) +} + +func (s *Endpoint_encryption_alogorithm_clauseContext) SUPPORTED() antlr.TerminalNode { + return s.GetToken(TSqlParserSUPPORTED, 0) +} + +func (s *Endpoint_encryption_alogorithm_clauseContext) REQUIRED() antlr.TerminalNode { + return s.GetToken(TSqlParserREQUIRED, 0) +} + +func (s *Endpoint_encryption_alogorithm_clauseContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(TSqlParserALGORITHM, 0) +} + +func (s *Endpoint_encryption_alogorithm_clauseContext) AES() antlr.TerminalNode { + return s.GetToken(TSqlParserAES, 0) +} + +func (s *Endpoint_encryption_alogorithm_clauseContext) RC4() antlr.TerminalNode { + return s.GetToken(TSqlParserRC4, 0) +} + +func (s *Endpoint_encryption_alogorithm_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Endpoint_encryption_alogorithm_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Endpoint_encryption_alogorithm_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEndpoint_encryption_alogorithm_clause(s) + } +} + +func (s *Endpoint_encryption_alogorithm_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEndpoint_encryption_alogorithm_clause(s) + } +} + +func (s *Endpoint_encryption_alogorithm_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEndpoint_encryption_alogorithm_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Endpoint_encryption_alogorithm_clause() (localctx IEndpoint_encryption_alogorithm_clauseContext) { + localctx = NewEndpoint_encryption_alogorithm_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 296, TSqlParserRULE_endpoint_encryption_alogorithm_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3414) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3415) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3416) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISABLED || _la == TSqlParserREQUIRED || _la == TSqlParserSUPPORTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserALGORITHM { + { + p.SetState(3417) + p.Match(TSqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAES: + { + p.SetState(3418) + p.Match(TSqlParserAES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserRC4 { + { + p.SetState(3419) + p.Match(TSqlParserRC4) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserRC4: + { + p.SetState(3422) + p.Match(TSqlParserRC4) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAES { + { + p.SetState(3423) + p.Match(TSqlParserAES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEndpoint_authentication_clauseContext is an interface to support dynamic dispatch. +type IEndpoint_authentication_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCert_name returns the cert_name rule contexts. + GetCert_name() IId_Context + + // SetCert_name sets the cert_name rule contexts. + SetCert_name(IId_Context) + + // Getter signatures + AUTHENTICATION() antlr.TerminalNode + EQUAL() antlr.TerminalNode + WINDOWS() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + Id_() IId_Context + NTLM() antlr.TerminalNode + KERBEROS() antlr.TerminalNode + NEGOTIATE() antlr.TerminalNode + + // IsEndpoint_authentication_clauseContext differentiates from other interfaces. + IsEndpoint_authentication_clauseContext() +} + +type Endpoint_authentication_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + cert_name IId_Context +} + +func NewEmptyEndpoint_authentication_clauseContext() *Endpoint_authentication_clauseContext { + var p = new(Endpoint_authentication_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_endpoint_authentication_clause + return p +} + +func InitEmptyEndpoint_authentication_clauseContext(p *Endpoint_authentication_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_endpoint_authentication_clause +} + +func (*Endpoint_authentication_clauseContext) IsEndpoint_authentication_clauseContext() {} + +func NewEndpoint_authentication_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Endpoint_authentication_clauseContext { + var p = new(Endpoint_authentication_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_endpoint_authentication_clause + + return p +} + +func (s *Endpoint_authentication_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Endpoint_authentication_clauseContext) GetCert_name() IId_Context { return s.cert_name } + +func (s *Endpoint_authentication_clauseContext) SetCert_name(v IId_Context) { s.cert_name = v } + +func (s *Endpoint_authentication_clauseContext) AUTHENTICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHENTICATION, 0) +} + +func (s *Endpoint_authentication_clauseContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Endpoint_authentication_clauseContext) WINDOWS() antlr.TerminalNode { + return s.GetToken(TSqlParserWINDOWS, 0) +} + +func (s *Endpoint_authentication_clauseContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Endpoint_authentication_clauseContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Endpoint_authentication_clauseContext) NTLM() antlr.TerminalNode { + return s.GetToken(TSqlParserNTLM, 0) +} + +func (s *Endpoint_authentication_clauseContext) KERBEROS() antlr.TerminalNode { + return s.GetToken(TSqlParserKERBEROS, 0) +} + +func (s *Endpoint_authentication_clauseContext) NEGOTIATE() antlr.TerminalNode { + return s.GetToken(TSqlParserNEGOTIATE, 0) +} + +func (s *Endpoint_authentication_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Endpoint_authentication_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Endpoint_authentication_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEndpoint_authentication_clause(s) + } +} + +func (s *Endpoint_authentication_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEndpoint_authentication_clause(s) + } +} + +func (s *Endpoint_authentication_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEndpoint_authentication_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Endpoint_authentication_clause() (localctx IEndpoint_authentication_clauseContext) { + localctx = NewEndpoint_authentication_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 298, TSqlParserRULE_endpoint_authentication_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3430) + p.Match(TSqlParserAUTHENTICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3431) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserWINDOWS: + { + p.SetState(3432) + p.Match(TSqlParserWINDOWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3434) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserKERBEROS || _la == TSqlParserNEGOTIATE || _la == TSqlParserNTLM { + { + p.SetState(3433) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserKERBEROS || _la == TSqlParserNEGOTIATE || _la == TSqlParserNTLM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3438) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCERTIFICATE { + { + p.SetState(3436) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3437) + + var _x = p.Id_() + + localctx.(*Endpoint_authentication_clauseContext).cert_name = _x + } + + } + + case TSqlParserCERTIFICATE: + { + p.SetState(3440) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3441) + + var _x = p.Id_() + + localctx.(*Endpoint_authentication_clauseContext).cert_name = _x + } + p.SetState(3443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWINDOWS { + { + p.SetState(3442) + p.Match(TSqlParserWINDOWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3446) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserKERBEROS || _la == TSqlParserNEGOTIATE || _la == TSqlParserNTLM { + { + p.SetState(3445) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserKERBEROS || _la == TSqlParserNEGOTIATE || _la == TSqlParserNTLM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEndpoint_listener_clauseContext is an interface to support dynamic dispatch. +type IEndpoint_listener_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPort returns the port token. + GetPort() antlr.Token + + // GetIpv4 returns the ipv4 token. + GetIpv4() antlr.Token + + // GetIpv6 returns the ipv6 token. + GetIpv6() antlr.Token + + // SetPort sets the port token. + SetPort(antlr.Token) + + // SetIpv4 sets the ipv4 token. + SetIpv4(antlr.Token) + + // SetIpv6 sets the ipv6 token. + SetIpv6(antlr.Token) + + // Getter signatures + LISTENER_PORT() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + DECIMAL() antlr.TerminalNode + COMMA() antlr.TerminalNode + LISTENER_IP() antlr.TerminalNode + ALL() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + IPV4_ADDR() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsEndpoint_listener_clauseContext differentiates from other interfaces. + IsEndpoint_listener_clauseContext() +} + +type Endpoint_listener_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + port antlr.Token + ipv4 antlr.Token + ipv6 antlr.Token +} + +func NewEmptyEndpoint_listener_clauseContext() *Endpoint_listener_clauseContext { + var p = new(Endpoint_listener_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_endpoint_listener_clause + return p +} + +func InitEmptyEndpoint_listener_clauseContext(p *Endpoint_listener_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_endpoint_listener_clause +} + +func (*Endpoint_listener_clauseContext) IsEndpoint_listener_clauseContext() {} + +func NewEndpoint_listener_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Endpoint_listener_clauseContext { + var p = new(Endpoint_listener_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_endpoint_listener_clause + + return p +} + +func (s *Endpoint_listener_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Endpoint_listener_clauseContext) GetPort() antlr.Token { return s.port } + +func (s *Endpoint_listener_clauseContext) GetIpv4() antlr.Token { return s.ipv4 } + +func (s *Endpoint_listener_clauseContext) GetIpv6() antlr.Token { return s.ipv6 } + +func (s *Endpoint_listener_clauseContext) SetPort(v antlr.Token) { s.port = v } + +func (s *Endpoint_listener_clauseContext) SetIpv4(v antlr.Token) { s.ipv4 = v } + +func (s *Endpoint_listener_clauseContext) SetIpv6(v antlr.Token) { s.ipv6 = v } + +func (s *Endpoint_listener_clauseContext) LISTENER_PORT() antlr.TerminalNode { + return s.GetToken(TSqlParserLISTENER_PORT, 0) +} + +func (s *Endpoint_listener_clauseContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Endpoint_listener_clauseContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Endpoint_listener_clauseContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Endpoint_listener_clauseContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Endpoint_listener_clauseContext) LISTENER_IP() antlr.TerminalNode { + return s.GetToken(TSqlParserLISTENER_IP, 0) +} + +func (s *Endpoint_listener_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Endpoint_listener_clauseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Endpoint_listener_clauseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Endpoint_listener_clauseContext) IPV4_ADDR() antlr.TerminalNode { + return s.GetToken(TSqlParserIPV4_ADDR, 0) +} + +func (s *Endpoint_listener_clauseContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Endpoint_listener_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Endpoint_listener_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Endpoint_listener_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEndpoint_listener_clause(s) + } +} + +func (s *Endpoint_listener_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEndpoint_listener_clause(s) + } +} + +func (s *Endpoint_listener_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEndpoint_listener_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Endpoint_listener_clause() (localctx IEndpoint_listener_clauseContext) { + localctx = NewEndpoint_listener_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 300, TSqlParserRULE_endpoint_listener_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3450) + p.Match(TSqlParserLISTENER_PORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3451) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3452) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Endpoint_listener_clauseContext).port = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3453) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3454) + p.Match(TSqlParserLISTENER_IP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3455) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALL: + { + p.SetState(3456) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserLR_BRACKET: + { + p.SetState(3457) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3460) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserIPV4_ADDR: + { + p.SetState(3458) + + var _m = p.Match(TSqlParserIPV4_ADDR) + + localctx.(*Endpoint_listener_clauseContext).ipv4 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSTRING: + { + p.SetState(3459) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Endpoint_listener_clauseContext).ipv6 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(3462) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_event_notificationContext is an interface to support dynamic dispatch. +type ICreate_event_notificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBroker_service returns the broker_service token. + GetBroker_service() antlr.Token + + // GetBroker_service_specifier_or_current_database returns the broker_service_specifier_or_current_database token. + GetBroker_service_specifier_or_current_database() antlr.Token + + // SetBroker_service sets the broker_service token. + SetBroker_service(antlr.Token) + + // SetBroker_service_specifier_or_current_database sets the broker_service_specifier_or_current_database token. + SetBroker_service_specifier_or_current_database(antlr.Token) + + // GetEvent_notification_name returns the event_notification_name rule contexts. + GetEvent_notification_name() IId_Context + + // GetQueue_name returns the queue_name rule contexts. + GetQueue_name() IId_Context + + // GetEvent_type_or_group returns the event_type_or_group rule contexts. + GetEvent_type_or_group() IId_Context + + // SetEvent_notification_name sets the event_notification_name rule contexts. + SetEvent_notification_name(IId_Context) + + // SetQueue_name sets the queue_name rule contexts. + SetQueue_name(IId_Context) + + // SetEvent_type_or_group sets the event_type_or_group rule contexts. + SetEvent_type_or_group(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + EVENT() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + ON() antlr.TerminalNode + FOR() antlr.TerminalNode + TO() antlr.TerminalNode + SERVICE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + SERVER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + QUEUE() antlr.TerminalNode + WITH() antlr.TerminalNode + FAN_IN() antlr.TerminalNode + + // IsCreate_event_notificationContext differentiates from other interfaces. + IsCreate_event_notificationContext() +} + +type Create_event_notificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + event_notification_name IId_Context + queue_name IId_Context + event_type_or_group IId_Context + broker_service antlr.Token + broker_service_specifier_or_current_database antlr.Token +} + +func NewEmptyCreate_event_notificationContext() *Create_event_notificationContext { + var p = new(Create_event_notificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_event_notification + return p +} + +func InitEmptyCreate_event_notificationContext(p *Create_event_notificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_event_notification +} + +func (*Create_event_notificationContext) IsCreate_event_notificationContext() {} + +func NewCreate_event_notificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_event_notificationContext { + var p = new(Create_event_notificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_event_notification + + return p +} + +func (s *Create_event_notificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_event_notificationContext) GetBroker_service() antlr.Token { return s.broker_service } + +func (s *Create_event_notificationContext) GetBroker_service_specifier_or_current_database() antlr.Token { + return s.broker_service_specifier_or_current_database +} + +func (s *Create_event_notificationContext) SetBroker_service(v antlr.Token) { s.broker_service = v } + +func (s *Create_event_notificationContext) SetBroker_service_specifier_or_current_database(v antlr.Token) { + s.broker_service_specifier_or_current_database = v +} + +func (s *Create_event_notificationContext) GetEvent_notification_name() IId_Context { + return s.event_notification_name +} + +func (s *Create_event_notificationContext) GetQueue_name() IId_Context { return s.queue_name } + +func (s *Create_event_notificationContext) GetEvent_type_or_group() IId_Context { + return s.event_type_or_group +} + +func (s *Create_event_notificationContext) SetEvent_notification_name(v IId_Context) { + s.event_notification_name = v +} + +func (s *Create_event_notificationContext) SetQueue_name(v IId_Context) { s.queue_name = v } + +func (s *Create_event_notificationContext) SetEvent_type_or_group(v IId_Context) { + s.event_type_or_group = v +} + +func (s *Create_event_notificationContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_event_notificationContext) EVENT() antlr.TerminalNode { + return s.GetToken(TSqlParserEVENT, 0) +} + +func (s *Create_event_notificationContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserNOTIFICATION, 0) +} + +func (s *Create_event_notificationContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Create_event_notificationContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_event_notificationContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Create_event_notificationContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *Create_event_notificationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_event_notificationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_event_notificationContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_event_notificationContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_event_notificationContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Create_event_notificationContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Create_event_notificationContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Create_event_notificationContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Create_event_notificationContext) QUEUE() antlr.TerminalNode { + return s.GetToken(TSqlParserQUEUE, 0) +} + +func (s *Create_event_notificationContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_event_notificationContext) FAN_IN() antlr.TerminalNode { + return s.GetToken(TSqlParserFAN_IN, 0) +} + +func (s *Create_event_notificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_event_notificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_event_notificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_event_notification(s) + } +} + +func (s *Create_event_notificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_event_notification(s) + } +} + +func (s *Create_event_notificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_event_notification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_event_notification() (localctx ICreate_event_notificationContext) { + localctx = NewCreate_event_notificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 302, TSqlParserRULE_create_event_notification) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3467) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3468) + p.Match(TSqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3469) + p.Match(TSqlParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3470) + + var _x = p.Id_() + + localctx.(*Create_event_notificationContext).event_notification_name = _x + } + { + p.SetState(3471) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSERVER: + { + p.SetState(3472) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDATABASE: + { + p.SetState(3473) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserQUEUE: + { + p.SetState(3474) + p.Match(TSqlParserQUEUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3475) + + var _x = p.Id_() + + localctx.(*Create_event_notificationContext).queue_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(3478) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3479) + p.Match(TSqlParserFAN_IN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3482) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3487) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&562949975835135) != 0) { + p.SetState(3484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3483) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3486) + + var _x = p.Id_() + + localctx.(*Create_event_notificationContext).event_type_or_group = _x + } + + p.SetState(3489) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3491) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3492) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3493) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_event_notificationContext).broker_service = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3494) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3495) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_event_notificationContext).broker_service_specifier_or_current_database = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_or_alter_event_sessionContext is an interface to support dynamic dispatch. +type ICreate_or_alter_event_sessionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMax_memory returns the max_memory token. + GetMax_memory() antlr.Token + + // GetMax_dispatch_latency_seconds returns the max_dispatch_latency_seconds token. + GetMax_dispatch_latency_seconds() antlr.Token + + // GetMax_event_size returns the max_event_size token. + GetMax_event_size() antlr.Token + + // SetMax_memory sets the max_memory token. + SetMax_memory(antlr.Token) + + // SetMax_dispatch_latency_seconds sets the max_dispatch_latency_seconds token. + SetMax_dispatch_latency_seconds(antlr.Token) + + // SetMax_event_size sets the max_event_size token. + SetMax_event_size(antlr.Token) + + // GetEvent_session_name returns the event_session_name rule contexts. + GetEvent_session_name() IId_Context + + // GetEvent_module_guid returns the event_module_guid rule contexts. + GetEvent_module_guid() IId_Context + + // GetEvent_package_name returns the event_package_name rule contexts. + GetEvent_package_name() IId_Context + + // GetEvent_name returns the event_name rule contexts. + GetEvent_name() IId_Context + + // GetEvent_customizable_attributue returns the event_customizable_attributue rule contexts. + GetEvent_customizable_attributue() IId_Context + + // GetAction_name returns the action_name rule contexts. + GetAction_name() IId_Context + + // GetTarget_name returns the target_name rule contexts. + GetTarget_name() IId_Context + + // GetTarget_parameter_name returns the target_parameter_name rule contexts. + GetTarget_parameter_name() IId_Context + + // SetEvent_session_name sets the event_session_name rule contexts. + SetEvent_session_name(IId_Context) + + // SetEvent_module_guid sets the event_module_guid rule contexts. + SetEvent_module_guid(IId_Context) + + // SetEvent_package_name sets the event_package_name rule contexts. + SetEvent_package_name(IId_Context) + + // SetEvent_name sets the event_name rule contexts. + SetEvent_name(IId_Context) + + // SetEvent_customizable_attributue sets the event_customizable_attributue rule contexts. + SetEvent_customizable_attributue(IId_Context) + + // SetAction_name sets the action_name rule contexts. + SetAction_name(IId_Context) + + // SetTarget_name sets the target_name rule contexts. + SetTarget_name(IId_Context) + + // SetTarget_parameter_name sets the target_parameter_name rule contexts. + SetTarget_parameter_name(IId_Context) + + // Getter signatures + AllEVENT() []antlr.TerminalNode + EVENT(i int) antlr.TerminalNode + SESSION() antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + SERVER() antlr.TerminalNode + CREATE() antlr.TerminalNode + ALTER() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllADD() []antlr.TerminalNode + ADD(i int) antlr.TerminalNode + AllDROP() []antlr.TerminalNode + DROP(i int) antlr.TerminalNode + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllTARGET() []antlr.TerminalNode + TARGET(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + STATE() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + START() antlr.TerminalNode + STOP() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllSET() []antlr.TerminalNode + SET(i int) antlr.TerminalNode + MAX_MEMORY() antlr.TerminalNode + EVENT_RETENTION_MODE() antlr.TerminalNode + MAX_DISPATCH_LATENCY() antlr.TerminalNode + MAX_EVENT_SIZE() antlr.TerminalNode + MEMORY_PARTITION_MODE() antlr.TerminalNode + TRACK_CAUSALITY() antlr.TerminalNode + STARTUP_STATE() antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + AllKB() []antlr.TerminalNode + KB(i int) antlr.TerminalNode + AllMB() []antlr.TerminalNode + MB(i int) antlr.TerminalNode + ALLOW_SINGLE_EVENT_LOSS() antlr.TerminalNode + ALLOW_MULTIPLE_EVENT_LOSS() antlr.TerminalNode + NO_EVENT_LOSS() antlr.TerminalNode + NONE() antlr.TerminalNode + PER_NODE() antlr.TerminalNode + PER_CPU() antlr.TerminalNode + AllOFF() []antlr.TerminalNode + OFF(i int) antlr.TerminalNode + SECONDS() antlr.TerminalNode + INFINITE() antlr.TerminalNode + AllACTION() []antlr.TerminalNode + ACTION(i int) antlr.TerminalNode + AllWHERE() []antlr.TerminalNode + WHERE(i int) antlr.TerminalNode + AllEvent_session_predicate_expression() []IEvent_session_predicate_expressionContext + Event_session_predicate_expression(i int) IEvent_session_predicate_expressionContext + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + + // IsCreate_or_alter_event_sessionContext differentiates from other interfaces. + IsCreate_or_alter_event_sessionContext() +} + +type Create_or_alter_event_sessionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + event_session_name IId_Context + event_module_guid IId_Context + event_package_name IId_Context + event_name IId_Context + event_customizable_attributue IId_Context + action_name IId_Context + target_name IId_Context + target_parameter_name IId_Context + max_memory antlr.Token + max_dispatch_latency_seconds antlr.Token + max_event_size antlr.Token +} + +func NewEmptyCreate_or_alter_event_sessionContext() *Create_or_alter_event_sessionContext { + var p = new(Create_or_alter_event_sessionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_event_session + return p +} + +func InitEmptyCreate_or_alter_event_sessionContext(p *Create_or_alter_event_sessionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_event_session +} + +func (*Create_or_alter_event_sessionContext) IsCreate_or_alter_event_sessionContext() {} + +func NewCreate_or_alter_event_sessionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_event_sessionContext { + var p = new(Create_or_alter_event_sessionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_or_alter_event_session + + return p +} + +func (s *Create_or_alter_event_sessionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_or_alter_event_sessionContext) GetMax_memory() antlr.Token { return s.max_memory } + +func (s *Create_or_alter_event_sessionContext) GetMax_dispatch_latency_seconds() antlr.Token { + return s.max_dispatch_latency_seconds +} + +func (s *Create_or_alter_event_sessionContext) GetMax_event_size() antlr.Token { + return s.max_event_size +} + +func (s *Create_or_alter_event_sessionContext) SetMax_memory(v antlr.Token) { s.max_memory = v } + +func (s *Create_or_alter_event_sessionContext) SetMax_dispatch_latency_seconds(v antlr.Token) { + s.max_dispatch_latency_seconds = v +} + +func (s *Create_or_alter_event_sessionContext) SetMax_event_size(v antlr.Token) { s.max_event_size = v } + +func (s *Create_or_alter_event_sessionContext) GetEvent_session_name() IId_Context { + return s.event_session_name +} + +func (s *Create_or_alter_event_sessionContext) GetEvent_module_guid() IId_Context { + return s.event_module_guid +} + +func (s *Create_or_alter_event_sessionContext) GetEvent_package_name() IId_Context { + return s.event_package_name +} + +func (s *Create_or_alter_event_sessionContext) GetEvent_name() IId_Context { return s.event_name } + +func (s *Create_or_alter_event_sessionContext) GetEvent_customizable_attributue() IId_Context { + return s.event_customizable_attributue +} + +func (s *Create_or_alter_event_sessionContext) GetAction_name() IId_Context { return s.action_name } + +func (s *Create_or_alter_event_sessionContext) GetTarget_name() IId_Context { return s.target_name } + +func (s *Create_or_alter_event_sessionContext) GetTarget_parameter_name() IId_Context { + return s.target_parameter_name +} + +func (s *Create_or_alter_event_sessionContext) SetEvent_session_name(v IId_Context) { + s.event_session_name = v +} + +func (s *Create_or_alter_event_sessionContext) SetEvent_module_guid(v IId_Context) { + s.event_module_guid = v +} + +func (s *Create_or_alter_event_sessionContext) SetEvent_package_name(v IId_Context) { + s.event_package_name = v +} + +func (s *Create_or_alter_event_sessionContext) SetEvent_name(v IId_Context) { s.event_name = v } + +func (s *Create_or_alter_event_sessionContext) SetEvent_customizable_attributue(v IId_Context) { + s.event_customizable_attributue = v +} + +func (s *Create_or_alter_event_sessionContext) SetAction_name(v IId_Context) { s.action_name = v } + +func (s *Create_or_alter_event_sessionContext) SetTarget_name(v IId_Context) { s.target_name = v } + +func (s *Create_or_alter_event_sessionContext) SetTarget_parameter_name(v IId_Context) { + s.target_parameter_name = v +} + +func (s *Create_or_alter_event_sessionContext) AllEVENT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEVENT) +} + +func (s *Create_or_alter_event_sessionContext) EVENT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEVENT, i) +} + +func (s *Create_or_alter_event_sessionContext) SESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserSESSION, 0) +} + +func (s *Create_or_alter_event_sessionContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Create_or_alter_event_sessionContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Create_or_alter_event_sessionContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Create_or_alter_event_sessionContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_or_alter_event_sessionContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Create_or_alter_event_sessionContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_or_alter_event_sessionContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_or_alter_event_sessionContext) AllADD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserADD) +} + +func (s *Create_or_alter_event_sessionContext) ADD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserADD, i) +} + +func (s *Create_or_alter_event_sessionContext) AllDROP() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDROP) +} + +func (s *Create_or_alter_event_sessionContext) DROP(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, i) +} + +func (s *Create_or_alter_event_sessionContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Create_or_alter_event_sessionContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Create_or_alter_event_sessionContext) AllTARGET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTARGET) +} + +func (s *Create_or_alter_event_sessionContext) TARGET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTARGET, i) +} + +func (s *Create_or_alter_event_sessionContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_or_alter_event_sessionContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Create_or_alter_event_sessionContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Create_or_alter_event_sessionContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Create_or_alter_event_sessionContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Create_or_alter_event_sessionContext) STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATE, 0) +} + +func (s *Create_or_alter_event_sessionContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_or_alter_event_sessionContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_or_alter_event_sessionContext) START() antlr.TerminalNode { + return s.GetToken(TSqlParserSTART, 0) +} + +func (s *Create_or_alter_event_sessionContext) STOP() antlr.TerminalNode { + return s.GetToken(TSqlParserSTOP, 0) +} + +func (s *Create_or_alter_event_sessionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_or_alter_event_sessionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_or_alter_event_sessionContext) AllSET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSET) +} + +func (s *Create_or_alter_event_sessionContext) SET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSET, i) +} + +func (s *Create_or_alter_event_sessionContext) MAX_MEMORY() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_MEMORY, 0) +} + +func (s *Create_or_alter_event_sessionContext) EVENT_RETENTION_MODE() antlr.TerminalNode { + return s.GetToken(TSqlParserEVENT_RETENTION_MODE, 0) +} + +func (s *Create_or_alter_event_sessionContext) MAX_DISPATCH_LATENCY() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_DISPATCH_LATENCY, 0) +} + +func (s *Create_or_alter_event_sessionContext) MAX_EVENT_SIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_EVENT_SIZE, 0) +} + +func (s *Create_or_alter_event_sessionContext) MEMORY_PARTITION_MODE() antlr.TerminalNode { + return s.GetToken(TSqlParserMEMORY_PARTITION_MODE, 0) +} + +func (s *Create_or_alter_event_sessionContext) TRACK_CAUSALITY() antlr.TerminalNode { + return s.GetToken(TSqlParserTRACK_CAUSALITY, 0) +} + +func (s *Create_or_alter_event_sessionContext) STARTUP_STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTARTUP_STATE, 0) +} + +func (s *Create_or_alter_event_sessionContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Create_or_alter_event_sessionContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Create_or_alter_event_sessionContext) AllKB() []antlr.TerminalNode { + return s.GetTokens(TSqlParserKB) +} + +func (s *Create_or_alter_event_sessionContext) KB(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserKB, i) +} + +func (s *Create_or_alter_event_sessionContext) AllMB() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMB) +} + +func (s *Create_or_alter_event_sessionContext) MB(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMB, i) +} + +func (s *Create_or_alter_event_sessionContext) ALLOW_SINGLE_EVENT_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_SINGLE_EVENT_LOSS, 0) +} + +func (s *Create_or_alter_event_sessionContext) ALLOW_MULTIPLE_EVENT_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_MULTIPLE_EVENT_LOSS, 0) +} + +func (s *Create_or_alter_event_sessionContext) NO_EVENT_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_EVENT_LOSS, 0) +} + +func (s *Create_or_alter_event_sessionContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Create_or_alter_event_sessionContext) PER_NODE() antlr.TerminalNode { + return s.GetToken(TSqlParserPER_NODE, 0) +} + +func (s *Create_or_alter_event_sessionContext) PER_CPU() antlr.TerminalNode { + return s.GetToken(TSqlParserPER_CPU, 0) +} + +func (s *Create_or_alter_event_sessionContext) AllOFF() []antlr.TerminalNode { + return s.GetTokens(TSqlParserOFF) +} + +func (s *Create_or_alter_event_sessionContext) OFF(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, i) +} + +func (s *Create_or_alter_event_sessionContext) SECONDS() antlr.TerminalNode { + return s.GetToken(TSqlParserSECONDS, 0) +} + +func (s *Create_or_alter_event_sessionContext) INFINITE() antlr.TerminalNode { + return s.GetToken(TSqlParserINFINITE, 0) +} + +func (s *Create_or_alter_event_sessionContext) AllACTION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserACTION) +} + +func (s *Create_or_alter_event_sessionContext) ACTION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserACTION, i) +} + +func (s *Create_or_alter_event_sessionContext) AllWHERE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserWHERE) +} + +func (s *Create_or_alter_event_sessionContext) WHERE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserWHERE, i) +} + +func (s *Create_or_alter_event_sessionContext) AllEvent_session_predicate_expression() []IEvent_session_predicate_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEvent_session_predicate_expressionContext); ok { + len++ + } + } + + tst := make([]IEvent_session_predicate_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEvent_session_predicate_expressionContext); ok { + tst[i] = t.(IEvent_session_predicate_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_or_alter_event_sessionContext) Event_session_predicate_expression(i int) IEvent_session_predicate_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEvent_session_predicate_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEvent_session_predicate_expressionContext) +} + +func (s *Create_or_alter_event_sessionContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Create_or_alter_event_sessionContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Create_or_alter_event_sessionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_or_alter_event_sessionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_or_alter_event_sessionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_or_alter_event_session(s) + } +} + +func (s *Create_or_alter_event_sessionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_or_alter_event_session(s) + } +} + +func (s *Create_or_alter_event_sessionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_or_alter_event_session(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_or_alter_event_session() (localctx ICreate_or_alter_event_sessionContext) { + localctx = NewCreate_or_alter_event_sessionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 304, TSqlParserRULE_create_or_alter_event_session) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3497) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALTER || _la == TSqlParserCREATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3498) + p.Match(TSqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3499) + p.Match(TSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3500) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_session_name = _x + } + { + p.SetState(3501) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3502) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3570) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 282, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(3504) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3503) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3506) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3507) + p.Match(TSqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3511) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 272, p.GetParserRuleContext()) == 1 { + { + p.SetState(3508) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_module_guid = _x + } + { + p.SetState(3509) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3513) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_package_name = _x + } + { + p.SetState(3514) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3515) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_name = _x + } + + p.SetState(3565) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 281, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3517) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSET { + { + p.SetState(3518) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3528) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 274, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(3520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3519) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3522) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_customizable_attributue = _x + } + { + p.SetState(3523) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3524) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDECIMAL || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 274, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } + p.SetState(3553) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserACTION { + { + p.SetState(3533) + p.Match(TSqlParserACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3534) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&562949975835135) != 0) { + p.SetState(3536) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3535) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3541) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 277, p.GetParserRuleContext()) == 1 { + { + p.SetState(3538) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_module_guid = _x + } + { + p.SetState(3539) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3543) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_package_name = _x + } + { + p.SetState(3544) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3545) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).action_name = _x + } + + p.SetState(3549) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3551) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(3559) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWHERE { + { + p.SetState(3557) + p.Match(TSqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3558) + p.Event_session_predicate_expression() + } + + } + { + p.SetState(3561) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 281, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } + p.SetState(3572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 282, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 285, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(3574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3573) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3576) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3577) + p.Match(TSqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3581) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 284, p.GetParserRuleContext()) == 1 { + { + p.SetState(3578) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_module_guid = _x + } + { + p.SetState(3579) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3583) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_package_name = _x + } + { + p.SetState(3584) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3585) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_name = _x + } + + } + p.SetState(3591) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 285, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3633) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 293, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3592) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3593) + p.Match(TSqlParserTARGET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3597) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 286, p.GetParserRuleContext()) == 1 { + { + p.SetState(3594) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_module_guid = _x + } + { + p.SetState(3595) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3599) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_package_name = _x + } + { + p.SetState(3600) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3601) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).target_name = _x + } + + p.SetState(3628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 292, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3603) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3604) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3620) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&562949975835135) != 0) { + p.SetState(3606) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3605) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3608) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).target_parameter_name = _x + } + { + p.SetState(3609) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL, TSqlParserLR_BRACKET: + p.SetState(3611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLR_BRACKET { + { + p.SetState(3610) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3613) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3615) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 289, p.GetParserRuleContext()) == 1 { + { + p.SetState(3614) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserSTRING: + { + p.SetState(3617) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3622) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3624) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 292, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } + p.SetState(3635) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 293, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 295, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3636) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3637) + p.Match(TSqlParserTARGET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3641) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 294, p.GetParserRuleContext()) == 1 { + { + p.SetState(3638) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_module_guid = _x + } + { + p.SetState(3639) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3643) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).event_package_name = _x + } + { + p.SetState(3644) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3645) + + var _x = p.Id_() + + localctx.(*Create_or_alter_event_sessionContext).target_name = _x + } + + } + p.SetState(3651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 295, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3717) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 311, p.GetParserRuleContext()) == 1 { + { + p.SetState(3652) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3653) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3661) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 297, p.GetParserRuleContext()) == 1 { + p.SetState(3655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3654) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3657) + p.Match(TSqlParserMAX_MEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3658) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3659) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_or_alter_event_sessionContext).max_memory = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3660) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserKB || _la == TSqlParserMB) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3669) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 299, p.GetParserRuleContext()) == 1 { + p.SetState(3664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3663) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3666) + p.Match(TSqlParserEVENT_RETENTION_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3667) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3668) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALLOW_MULTIPLE_EVENT_LOSS || _la == TSqlParserALLOW_SINGLE_EVENT_LOSS || _la == TSqlParserNO_EVENT_LOSS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3681) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 302, p.GetParserRuleContext()) == 1 { + p.SetState(3672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3671) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3674) + p.Match(TSqlParserMAX_DISPATCH_LATENCY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3675) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(3676) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_or_alter_event_sessionContext).max_dispatch_latency_seconds = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3677) + p.Match(TSqlParserSECONDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserINFINITE: + { + p.SetState(3678) + p.Match(TSqlParserINFINITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3690) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 304, p.GetParserRuleContext()) == 1 { + p.SetState(3684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3683) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3686) + p.Match(TSqlParserMAX_EVENT_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3687) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3688) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_or_alter_event_sessionContext).max_event_size = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3689) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserKB || _la == TSqlParserMB) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3698) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 306, p.GetParserRuleContext()) == 1 { + p.SetState(3693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3692) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3695) + p.Match(TSqlParserMEMORY_PARTITION_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3696) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3697) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNONE || _la == TSqlParserPER_CPU || _la == TSqlParserPER_NODE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3706) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 308, p.GetParserRuleContext()) == 1 { + p.SetState(3701) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3700) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3703) + p.Match(TSqlParserTRACK_CAUSALITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3704) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3705) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSTARTUP_STATE || _la == TSqlParserCOMMA { + p.SetState(3709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3708) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3711) + p.Match(TSqlParserSTARTUP_STATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3712) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3713) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(3716) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3722) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 312, p.GetParserRuleContext()) == 1 { + { + p.SetState(3719) + p.Match(TSqlParserSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3720) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3721) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserSTART || _la == TSqlParserSTOP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEvent_session_predicate_expressionContext is an interface to support dynamic dispatch. +type IEvent_session_predicate_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllEvent_session_predicate_factor() []IEvent_session_predicate_factorContext + Event_session_predicate_factor(i int) IEvent_session_predicate_factorContext + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllEvent_session_predicate_expression() []IEvent_session_predicate_expressionContext + Event_session_predicate_expression(i int) IEvent_session_predicate_expressionContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllNOT() []antlr.TerminalNode + NOT(i int) antlr.TerminalNode + AllAND() []antlr.TerminalNode + AND(i int) antlr.TerminalNode + AllOR() []antlr.TerminalNode + OR(i int) antlr.TerminalNode + + // IsEvent_session_predicate_expressionContext differentiates from other interfaces. + IsEvent_session_predicate_expressionContext() +} + +type Event_session_predicate_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEvent_session_predicate_expressionContext() *Event_session_predicate_expressionContext { + var p = new(Event_session_predicate_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_event_session_predicate_expression + return p +} + +func InitEmptyEvent_session_predicate_expressionContext(p *Event_session_predicate_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_event_session_predicate_expression +} + +func (*Event_session_predicate_expressionContext) IsEvent_session_predicate_expressionContext() {} + +func NewEvent_session_predicate_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_session_predicate_expressionContext { + var p = new(Event_session_predicate_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_event_session_predicate_expression + + return p +} + +func (s *Event_session_predicate_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Event_session_predicate_expressionContext) AllEvent_session_predicate_factor() []IEvent_session_predicate_factorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEvent_session_predicate_factorContext); ok { + len++ + } + } + + tst := make([]IEvent_session_predicate_factorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEvent_session_predicate_factorContext); ok { + tst[i] = t.(IEvent_session_predicate_factorContext) + i++ + } + } + + return tst +} + +func (s *Event_session_predicate_expressionContext) Event_session_predicate_factor(i int) IEvent_session_predicate_factorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEvent_session_predicate_factorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEvent_session_predicate_factorContext) +} + +func (s *Event_session_predicate_expressionContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Event_session_predicate_expressionContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Event_session_predicate_expressionContext) AllEvent_session_predicate_expression() []IEvent_session_predicate_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEvent_session_predicate_expressionContext); ok { + len++ + } + } + + tst := make([]IEvent_session_predicate_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEvent_session_predicate_expressionContext); ok { + tst[i] = t.(IEvent_session_predicate_expressionContext) + i++ + } + } + + return tst +} + +func (s *Event_session_predicate_expressionContext) Event_session_predicate_expression(i int) IEvent_session_predicate_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEvent_session_predicate_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEvent_session_predicate_expressionContext) +} + +func (s *Event_session_predicate_expressionContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Event_session_predicate_expressionContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Event_session_predicate_expressionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Event_session_predicate_expressionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Event_session_predicate_expressionContext) AllNOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOT) +} + +func (s *Event_session_predicate_expressionContext) NOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, i) +} + +func (s *Event_session_predicate_expressionContext) AllAND() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAND) +} + +func (s *Event_session_predicate_expressionContext) AND(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAND, i) +} + +func (s *Event_session_predicate_expressionContext) AllOR() []antlr.TerminalNode { + return s.GetTokens(TSqlParserOR) +} + +func (s *Event_session_predicate_expressionContext) OR(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserOR, i) +} + +func (s *Event_session_predicate_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Event_session_predicate_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Event_session_predicate_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEvent_session_predicate_expression(s) + } +} + +func (s *Event_session_predicate_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEvent_session_predicate_expression(s) + } +} + +func (s *Event_session_predicate_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEvent_session_predicate_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Event_session_predicate_expression() (localctx IEvent_session_predicate_expressionContext) { + localctx = NewEvent_session_predicate_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 306, TSqlParserRULE_event_session_predicate_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3740) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243185221894178) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458764806147080193) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812616328357377) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&703687464190463) != 0) { + p.SetState(3725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3724) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAND || _la == TSqlParserOR { + { + p.SetState(3727) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAND || _la == TSqlParserOR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserNOT { + { + p.SetState(3730) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 316, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3733) + p.Event_session_predicate_factor() + } + + case 2: + { + p.SetState(3734) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3735) + p.Event_session_predicate_expression() + } + { + p.SetState(3736) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(3742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEvent_session_predicate_factorContext is an interface to support dynamic dispatch. +type IEvent_session_predicate_factorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Event_session_predicate_leaf() IEvent_session_predicate_leafContext + LR_BRACKET() antlr.TerminalNode + Event_session_predicate_expression() IEvent_session_predicate_expressionContext + RR_BRACKET() antlr.TerminalNode + + // IsEvent_session_predicate_factorContext differentiates from other interfaces. + IsEvent_session_predicate_factorContext() +} + +type Event_session_predicate_factorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEvent_session_predicate_factorContext() *Event_session_predicate_factorContext { + var p = new(Event_session_predicate_factorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_event_session_predicate_factor + return p +} + +func InitEmptyEvent_session_predicate_factorContext(p *Event_session_predicate_factorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_event_session_predicate_factor +} + +func (*Event_session_predicate_factorContext) IsEvent_session_predicate_factorContext() {} + +func NewEvent_session_predicate_factorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_session_predicate_factorContext { + var p = new(Event_session_predicate_factorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_event_session_predicate_factor + + return p +} + +func (s *Event_session_predicate_factorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Event_session_predicate_factorContext) Event_session_predicate_leaf() IEvent_session_predicate_leafContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEvent_session_predicate_leafContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEvent_session_predicate_leafContext) +} + +func (s *Event_session_predicate_factorContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Event_session_predicate_factorContext) Event_session_predicate_expression() IEvent_session_predicate_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEvent_session_predicate_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEvent_session_predicate_expressionContext) +} + +func (s *Event_session_predicate_factorContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Event_session_predicate_factorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Event_session_predicate_factorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Event_session_predicate_factorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEvent_session_predicate_factor(s) + } +} + +func (s *Event_session_predicate_factorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEvent_session_predicate_factor(s) + } +} + +func (s *Event_session_predicate_factorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEvent_session_predicate_factor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Event_session_predicate_factor() (localctx IEvent_session_predicate_factorContext) { + localctx = NewEvent_session_predicate_factorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 308, TSqlParserRULE_event_session_predicate_factor) + p.SetState(3749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3744) + p.Event_session_predicate_leaf() + } + + case TSqlParserLR_BRACKET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3745) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3746) + p.Event_session_predicate_expression() + } + { + p.SetState(3747) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEvent_session_predicate_leafContext is an interface to support dynamic dispatch. +type IEvent_session_predicate_leafContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEvent_field_name returns the event_field_name rule contexts. + GetEvent_field_name() IId_Context + + // GetEvent_module_guid returns the event_module_guid rule contexts. + GetEvent_module_guid() IId_Context + + // GetEvent_package_name returns the event_package_name rule contexts. + GetEvent_package_name() IId_Context + + // GetPredicate_source_name returns the predicate_source_name rule contexts. + GetPredicate_source_name() IId_Context + + // GetPredicate_compare_name returns the predicate_compare_name rule contexts. + GetPredicate_compare_name() IId_Context + + // SetEvent_field_name sets the event_field_name rule contexts. + SetEvent_field_name(IId_Context) + + // SetEvent_module_guid sets the event_module_guid rule contexts. + SetEvent_module_guid(IId_Context) + + // SetEvent_package_name sets the event_package_name rule contexts. + SetEvent_package_name(IId_Context) + + // SetPredicate_source_name sets the predicate_source_name rule contexts. + SetPredicate_source_name(IId_Context) + + // SetPredicate_compare_name sets the predicate_compare_name rule contexts. + SetPredicate_compare_name(IId_Context) + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + DECIMAL() antlr.TerminalNode + STRING() antlr.TerminalNode + EQUAL() antlr.TerminalNode + GREATER() antlr.TerminalNode + LESS() antlr.TerminalNode + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + EXCLAMATION() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + COMMA() antlr.TerminalNode + + // IsEvent_session_predicate_leafContext differentiates from other interfaces. + IsEvent_session_predicate_leafContext() +} + +type Event_session_predicate_leafContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + event_field_name IId_Context + event_module_guid IId_Context + event_package_name IId_Context + predicate_source_name IId_Context + predicate_compare_name IId_Context +} + +func NewEmptyEvent_session_predicate_leafContext() *Event_session_predicate_leafContext { + var p = new(Event_session_predicate_leafContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_event_session_predicate_leaf + return p +} + +func InitEmptyEvent_session_predicate_leafContext(p *Event_session_predicate_leafContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_event_session_predicate_leaf +} + +func (*Event_session_predicate_leafContext) IsEvent_session_predicate_leafContext() {} + +func NewEvent_session_predicate_leafContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_session_predicate_leafContext { + var p = new(Event_session_predicate_leafContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_event_session_predicate_leaf + + return p +} + +func (s *Event_session_predicate_leafContext) GetParser() antlr.Parser { return s.parser } + +func (s *Event_session_predicate_leafContext) GetEvent_field_name() IId_Context { + return s.event_field_name +} + +func (s *Event_session_predicate_leafContext) GetEvent_module_guid() IId_Context { + return s.event_module_guid +} + +func (s *Event_session_predicate_leafContext) GetEvent_package_name() IId_Context { + return s.event_package_name +} + +func (s *Event_session_predicate_leafContext) GetPredicate_source_name() IId_Context { + return s.predicate_source_name +} + +func (s *Event_session_predicate_leafContext) GetPredicate_compare_name() IId_Context { + return s.predicate_compare_name +} + +func (s *Event_session_predicate_leafContext) SetEvent_field_name(v IId_Context) { + s.event_field_name = v +} + +func (s *Event_session_predicate_leafContext) SetEvent_module_guid(v IId_Context) { + s.event_module_guid = v +} + +func (s *Event_session_predicate_leafContext) SetEvent_package_name(v IId_Context) { + s.event_package_name = v +} + +func (s *Event_session_predicate_leafContext) SetPredicate_source_name(v IId_Context) { + s.predicate_source_name = v +} + +func (s *Event_session_predicate_leafContext) SetPredicate_compare_name(v IId_Context) { + s.predicate_compare_name = v +} + +func (s *Event_session_predicate_leafContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Event_session_predicate_leafContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Event_session_predicate_leafContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Event_session_predicate_leafContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Event_session_predicate_leafContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Event_session_predicate_leafContext) GREATER() antlr.TerminalNode { + return s.GetToken(TSqlParserGREATER, 0) +} + +func (s *Event_session_predicate_leafContext) LESS() antlr.TerminalNode { + return s.GetToken(TSqlParserLESS, 0) +} + +func (s *Event_session_predicate_leafContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Event_session_predicate_leafContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Event_session_predicate_leafContext) EXCLAMATION() antlr.TerminalNode { + return s.GetToken(TSqlParserEXCLAMATION, 0) +} + +func (s *Event_session_predicate_leafContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Event_session_predicate_leafContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Event_session_predicate_leafContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Event_session_predicate_leafContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Event_session_predicate_leafContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Event_session_predicate_leafContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEvent_session_predicate_leaf(s) + } +} + +func (s *Event_session_predicate_leafContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEvent_session_predicate_leaf(s) + } +} + +func (s *Event_session_predicate_leafContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEvent_session_predicate_leaf(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Event_session_predicate_leaf() (localctx IEvent_session_predicate_leafContext) { + localctx = NewEvent_session_predicate_leafContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 310, TSqlParserRULE_event_session_predicate_leaf) + var _la int + + p.SetState(3807) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 326, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(3779) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 322, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3751) + + var _x = p.Id_() + + localctx.(*Event_session_predicate_leafContext).event_field_name = _x + } + + case 2: + p.SetState(3762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 320, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3752) + + var _x = p.Id_() + + localctx.(*Event_session_predicate_leafContext).event_field_name = _x + } + + case 2: + p.SetState(3756) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 319, p.GetParserRuleContext()) == 1 { + { + p.SetState(3753) + + var _x = p.Id_() + + localctx.(*Event_session_predicate_leafContext).event_module_guid = _x + } + { + p.SetState(3754) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3758) + + var _x = p.Id_() + + localctx.(*Event_session_predicate_leafContext).event_package_name = _x + } + { + p.SetState(3759) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3760) + + var _x = p.Id_() + + localctx.(*Event_session_predicate_leafContext).predicate_source_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(3775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 321, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3764) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(3765) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3766) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(3767) + p.Match(TSqlParserEXCLAMATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3768) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(3769) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(3770) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3771) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(3772) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + { + p.SetState(3773) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3774) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(3777) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDECIMAL || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(3784) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 323, p.GetParserRuleContext()) == 1 { + { + p.SetState(3781) + + var _x = p.Id_() + + localctx.(*Event_session_predicate_leafContext).event_module_guid = _x + } + { + p.SetState(3782) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3786) + + var _x = p.Id_() + + localctx.(*Event_session_predicate_leafContext).event_package_name = _x + } + { + p.SetState(3787) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3788) + + var _x = p.Id_() + + localctx.(*Event_session_predicate_leafContext).predicate_compare_name = _x + } + { + p.SetState(3789) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3803) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 325, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3790) + + var _x = p.Id_() + + localctx.(*Event_session_predicate_leafContext).event_field_name = _x + } + + case 2: + p.SetState(3794) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 324, p.GetParserRuleContext()) == 1 { + { + p.SetState(3791) + + var _x = p.Id_() + + localctx.(*Event_session_predicate_leafContext).event_module_guid = _x + } + { + p.SetState(3792) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3796) + + var _x = p.Id_() + + localctx.(*Event_session_predicate_leafContext).event_package_name = _x + } + { + p.SetState(3797) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3798) + + var _x = p.Id_() + + localctx.(*Event_session_predicate_leafContext).predicate_source_name = _x + } + + { + p.SetState(3800) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3801) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDECIMAL || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(3805) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_external_data_sourceContext is an interface to support dynamic dispatch. +type IAlter_external_data_sourceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLocation returns the location token. + GetLocation() antlr.Token + + // GetResource_manager_location returns the resource_manager_location token. + GetResource_manager_location() antlr.Token + + // SetLocation sets the location token. + SetLocation(antlr.Token) + + // SetResource_manager_location sets the resource_manager_location token. + SetResource_manager_location(antlr.Token) + + // GetData_source_name returns the data_source_name rule contexts. + GetData_source_name() IId_Context + + // GetCredential_name returns the credential_name rule contexts. + GetCredential_name() IId_Context + + // SetData_source_name sets the data_source_name rule contexts. + SetData_source_name(IId_Context) + + // SetCredential_name sets the credential_name rule contexts. + SetCredential_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + DATA() antlr.TerminalNode + SOURCE() antlr.TerminalNode + SET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllLOCATION() []antlr.TerminalNode + LOCATION(i int) antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllRESOURCE_MANAGER_LOCATION() []antlr.TerminalNode + RESOURCE_MANAGER_LOCATION(i int) antlr.TerminalNode + AllCREDENTIAL() []antlr.TerminalNode + CREDENTIAL(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + TYPE() antlr.TerminalNode + BLOB_STORAGE() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + + // IsAlter_external_data_sourceContext differentiates from other interfaces. + IsAlter_external_data_sourceContext() +} + +type Alter_external_data_sourceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + data_source_name IId_Context + location antlr.Token + resource_manager_location antlr.Token + credential_name IId_Context +} + +func NewEmptyAlter_external_data_sourceContext() *Alter_external_data_sourceContext { + var p = new(Alter_external_data_sourceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_external_data_source + return p +} + +func InitEmptyAlter_external_data_sourceContext(p *Alter_external_data_sourceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_external_data_source +} + +func (*Alter_external_data_sourceContext) IsAlter_external_data_sourceContext() {} + +func NewAlter_external_data_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_external_data_sourceContext { + var p = new(Alter_external_data_sourceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_external_data_source + + return p +} + +func (s *Alter_external_data_sourceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_external_data_sourceContext) GetLocation() antlr.Token { return s.location } + +func (s *Alter_external_data_sourceContext) GetResource_manager_location() antlr.Token { + return s.resource_manager_location +} + +func (s *Alter_external_data_sourceContext) SetLocation(v antlr.Token) { s.location = v } + +func (s *Alter_external_data_sourceContext) SetResource_manager_location(v antlr.Token) { + s.resource_manager_location = v +} + +func (s *Alter_external_data_sourceContext) GetData_source_name() IId_Context { + return s.data_source_name +} + +func (s *Alter_external_data_sourceContext) GetCredential_name() IId_Context { + return s.credential_name +} + +func (s *Alter_external_data_sourceContext) SetData_source_name(v IId_Context) { + s.data_source_name = v +} + +func (s *Alter_external_data_sourceContext) SetCredential_name(v IId_Context) { s.credential_name = v } + +func (s *Alter_external_data_sourceContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_external_data_sourceContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Alter_external_data_sourceContext) DATA() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA, 0) +} + +func (s *Alter_external_data_sourceContext) SOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserSOURCE, 0) +} + +func (s *Alter_external_data_sourceContext) SET() antlr.TerminalNode { + return s.GetToken(TSqlParserSET, 0) +} + +func (s *Alter_external_data_sourceContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_external_data_sourceContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_external_data_sourceContext) AllLOCATION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOCATION) +} + +func (s *Alter_external_data_sourceContext) LOCATION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOCATION, i) +} + +func (s *Alter_external_data_sourceContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_external_data_sourceContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_external_data_sourceContext) AllRESOURCE_MANAGER_LOCATION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRESOURCE_MANAGER_LOCATION) +} + +func (s *Alter_external_data_sourceContext) RESOURCE_MANAGER_LOCATION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRESOURCE_MANAGER_LOCATION, i) +} + +func (s *Alter_external_data_sourceContext) AllCREDENTIAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCREDENTIAL) +} + +func (s *Alter_external_data_sourceContext) CREDENTIAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCREDENTIAL, i) +} + +func (s *Alter_external_data_sourceContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Alter_external_data_sourceContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Alter_external_data_sourceContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_external_data_sourceContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_external_data_sourceContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_external_data_sourceContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Alter_external_data_sourceContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *Alter_external_data_sourceContext) BLOB_STORAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserBLOB_STORAGE, 0) +} + +func (s *Alter_external_data_sourceContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Alter_external_data_sourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_external_data_sourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_external_data_sourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_external_data_source(s) + } +} + +func (s *Alter_external_data_sourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_external_data_source(s) + } +} + +func (s *Alter_external_data_sourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_external_data_source(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_external_data_source() (localctx IAlter_external_data_sourceContext) { + localctx = NewAlter_external_data_sourceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 312, TSqlParserRULE_alter_external_data_source) + var _la int + + var _alt int + + p.SetState(3856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 332, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3809) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3810) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3811) + p.Match(TSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3812) + p.Match(TSqlParserSOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3813) + + var _x = p.Id_() + + localctx.(*Alter_external_data_sourceContext).data_source_name = _x + } + { + p.SetState(3814) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3830) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(3830) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLOCATION: + { + p.SetState(3815) + p.Match(TSqlParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3816) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3817) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_external_data_sourceContext).location = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3818) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserRESOURCE_MANAGER_LOCATION: + { + p.SetState(3821) + p.Match(TSqlParserRESOURCE_MANAGER_LOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3822) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3823) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_external_data_sourceContext).resource_manager_location = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3824) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserCREDENTIAL: + { + p.SetState(3827) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3828) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3829) + + var _x = p.Id_() + + localctx.(*Alter_external_data_sourceContext).credential_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3832) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 330, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3834) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3835) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3836) + p.Match(TSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3837) + p.Match(TSqlParserSOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3838) + + var _x = p.Id_() + + localctx.(*Alter_external_data_sourceContext).data_source_name = _x + } + { + p.SetState(3839) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3840) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3841) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3842) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3843) + p.Match(TSqlParserBLOB_STORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3844) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3845) + p.Match(TSqlParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3846) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3847) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_external_data_sourceContext).location = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3852) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3848) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3849) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3850) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3851) + + var _x = p.Id_() + + localctx.(*Alter_external_data_sourceContext).credential_name = _x + } + + } + { + p.SetState(3854) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_external_libraryContext is an interface to support dynamic dispatch. +type IAlter_external_libraryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetClient_library returns the client_library token. + GetClient_library() antlr.Token + + // SetClient_library sets the client_library token. + SetClient_library(antlr.Token) + + // GetLibrary_name returns the library_name rule contexts. + GetLibrary_name() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // GetExternal_data_source_name returns the external_data_source_name rule contexts. + GetExternal_data_source_name() IId_Context + + // SetLibrary_name sets the library_name rule contexts. + SetLibrary_name(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // SetExternal_data_source_name sets the external_data_source_name rule contexts. + SetExternal_data_source_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + SET() antlr.TerminalNode + ADD() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + CONTENT() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + BINARY() antlr.TerminalNode + NONE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + PLATFORM() antlr.TerminalNode + STRING() antlr.TerminalNode + AllLANGUAGE() []antlr.TerminalNode + LANGUAGE(i int) antlr.TerminalNode + AllDATA_SOURCE() []antlr.TerminalNode + DATA_SOURCE(i int) antlr.TerminalNode + AllR() []antlr.TerminalNode + R(i int) antlr.TerminalNode + AllPYTHON() []antlr.TerminalNode + PYTHON(i int) antlr.TerminalNode + WINDOWS() antlr.TerminalNode + LINUX() antlr.TerminalNode + + // IsAlter_external_libraryContext differentiates from other interfaces. + IsAlter_external_libraryContext() +} + +type Alter_external_libraryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + library_name IId_Context + owner_name IId_Context + client_library antlr.Token + external_data_source_name IId_Context +} + +func NewEmptyAlter_external_libraryContext() *Alter_external_libraryContext { + var p = new(Alter_external_libraryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_external_library + return p +} + +func InitEmptyAlter_external_libraryContext(p *Alter_external_libraryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_external_library +} + +func (*Alter_external_libraryContext) IsAlter_external_libraryContext() {} + +func NewAlter_external_libraryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_external_libraryContext { + var p = new(Alter_external_libraryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_external_library + + return p +} + +func (s *Alter_external_libraryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_external_libraryContext) GetClient_library() antlr.Token { return s.client_library } + +func (s *Alter_external_libraryContext) SetClient_library(v antlr.Token) { s.client_library = v } + +func (s *Alter_external_libraryContext) GetLibrary_name() IId_Context { return s.library_name } + +func (s *Alter_external_libraryContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Alter_external_libraryContext) GetExternal_data_source_name() IId_Context { + return s.external_data_source_name +} + +func (s *Alter_external_libraryContext) SetLibrary_name(v IId_Context) { s.library_name = v } + +func (s *Alter_external_libraryContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Alter_external_libraryContext) SetExternal_data_source_name(v IId_Context) { + s.external_data_source_name = v +} + +func (s *Alter_external_libraryContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_external_libraryContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Alter_external_libraryContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(TSqlParserLIBRARY, 0) +} + +func (s *Alter_external_libraryContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_external_libraryContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_external_libraryContext) SET() antlr.TerminalNode { + return s.GetToken(TSqlParserSET, 0) +} + +func (s *Alter_external_libraryContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_external_libraryContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Alter_external_libraryContext) CONTENT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTENT, 0) +} + +func (s *Alter_external_libraryContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_external_libraryContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_external_libraryContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_external_libraryContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Alter_external_libraryContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Alter_external_libraryContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Alter_external_libraryContext) BINARY() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY, 0) +} + +func (s *Alter_external_libraryContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Alter_external_libraryContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_external_libraryContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_external_libraryContext) PLATFORM() antlr.TerminalNode { + return s.GetToken(TSqlParserPLATFORM, 0) +} + +func (s *Alter_external_libraryContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Alter_external_libraryContext) AllLANGUAGE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLANGUAGE) +} + +func (s *Alter_external_libraryContext) LANGUAGE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLANGUAGE, i) +} + +func (s *Alter_external_libraryContext) AllDATA_SOURCE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDATA_SOURCE) +} + +func (s *Alter_external_libraryContext) DATA_SOURCE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDATA_SOURCE, i) +} + +func (s *Alter_external_libraryContext) AllR() []antlr.TerminalNode { + return s.GetTokens(TSqlParserR) +} + +func (s *Alter_external_libraryContext) R(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserR, i) +} + +func (s *Alter_external_libraryContext) AllPYTHON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserPYTHON) +} + +func (s *Alter_external_libraryContext) PYTHON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserPYTHON, i) +} + +func (s *Alter_external_libraryContext) WINDOWS() antlr.TerminalNode { + return s.GetToken(TSqlParserWINDOWS, 0) +} + +func (s *Alter_external_libraryContext) LINUX() antlr.TerminalNode { + return s.GetToken(TSqlParserLINUX, 0) +} + +func (s *Alter_external_libraryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_external_libraryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_external_libraryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_external_library(s) + } +} + +func (s *Alter_external_libraryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_external_library(s) + } +} + +func (s *Alter_external_libraryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_external_library(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_external_library() (localctx IAlter_external_libraryContext) { + localctx = NewAlter_external_libraryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 314, TSqlParserRULE_alter_external_library) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3858) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3859) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3860) + p.Match(TSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3861) + + var _x = p.Id_() + + localctx.(*Alter_external_libraryContext).library_name = _x + } + p.SetState(3864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(3862) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3863) + + var _x = p.Id_() + + localctx.(*Alter_external_libraryContext).owner_name = _x + } + + } + { + p.SetState(3866) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserADD || _la == TSqlParserSET) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + { + p.SetState(3867) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3868) + p.Match(TSqlParserCONTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3869) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3873) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(3870) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_external_libraryContext).client_library = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserBINARY: + { + p.SetState(3871) + p.Match(TSqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNONE: + { + p.SetState(3872) + p.Match(TSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + { + p.SetState(3875) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3876) + p.Match(TSqlParserPLATFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3877) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3879) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLINUX || _la == TSqlParserWINDOWS { + { + p.SetState(3878) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLINUX || _la == TSqlParserWINDOWS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(3881) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(3883) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserDATA_SOURCE || _la == TSqlParserLANGUAGE || _la == TSqlParserCOMMA { + p.SetState(3893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLANGUAGE, TSqlParserCOMMA: + p.SetState(3885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3884) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3887) + p.Match(TSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3888) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3889) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserPYTHON || _la == TSqlParserR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserDATA_SOURCE: + { + p.SetState(3890) + p.Match(TSqlParserDATA_SOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3891) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3892) + + var _x = p.Id_() + + localctx.(*Alter_external_libraryContext).external_data_source_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3895) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3897) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_external_libraryContext is an interface to support dynamic dispatch. +type ICreate_external_libraryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetClient_library returns the client_library token. + GetClient_library() antlr.Token + + // SetClient_library sets the client_library token. + SetClient_library(antlr.Token) + + // GetLibrary_name returns the library_name rule contexts. + GetLibrary_name() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // GetExternal_data_source_name returns the external_data_source_name rule contexts. + GetExternal_data_source_name() IId_Context + + // SetLibrary_name sets the library_name rule contexts. + SetLibrary_name(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // SetExternal_data_source_name sets the external_data_source_name rule contexts. + SetExternal_data_source_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + FROM() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AUTHORIZATION() antlr.TerminalNode + WITH() antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + BINARY() antlr.TerminalNode + NONE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + CONTENT() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + STRING() antlr.TerminalNode + PLATFORM() antlr.TerminalNode + AllLANGUAGE() []antlr.TerminalNode + LANGUAGE(i int) antlr.TerminalNode + AllDATA_SOURCE() []antlr.TerminalNode + DATA_SOURCE(i int) antlr.TerminalNode + AllR() []antlr.TerminalNode + R(i int) antlr.TerminalNode + AllPYTHON() []antlr.TerminalNode + PYTHON(i int) antlr.TerminalNode + WINDOWS() antlr.TerminalNode + LINUX() antlr.TerminalNode + + // IsCreate_external_libraryContext differentiates from other interfaces. + IsCreate_external_libraryContext() +} + +type Create_external_libraryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + library_name IId_Context + owner_name IId_Context + client_library antlr.Token + external_data_source_name IId_Context +} + +func NewEmptyCreate_external_libraryContext() *Create_external_libraryContext { + var p = new(Create_external_libraryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_external_library + return p +} + +func InitEmptyCreate_external_libraryContext(p *Create_external_libraryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_external_library +} + +func (*Create_external_libraryContext) IsCreate_external_libraryContext() {} + +func NewCreate_external_libraryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_external_libraryContext { + var p = new(Create_external_libraryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_external_library + + return p +} + +func (s *Create_external_libraryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_external_libraryContext) GetClient_library() antlr.Token { return s.client_library } + +func (s *Create_external_libraryContext) SetClient_library(v antlr.Token) { s.client_library = v } + +func (s *Create_external_libraryContext) GetLibrary_name() IId_Context { return s.library_name } + +func (s *Create_external_libraryContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Create_external_libraryContext) GetExternal_data_source_name() IId_Context { + return s.external_data_source_name +} + +func (s *Create_external_libraryContext) SetLibrary_name(v IId_Context) { s.library_name = v } + +func (s *Create_external_libraryContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Create_external_libraryContext) SetExternal_data_source_name(v IId_Context) { + s.external_data_source_name = v +} + +func (s *Create_external_libraryContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_external_libraryContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Create_external_libraryContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(TSqlParserLIBRARY, 0) +} + +func (s *Create_external_libraryContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Create_external_libraryContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_external_libraryContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_external_libraryContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_external_libraryContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_external_libraryContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Create_external_libraryContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Create_external_libraryContext) BINARY() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY, 0) +} + +func (s *Create_external_libraryContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Create_external_libraryContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_external_libraryContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_external_libraryContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_external_libraryContext) CONTENT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTENT, 0) +} + +func (s *Create_external_libraryContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_external_libraryContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_external_libraryContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_external_libraryContext) PLATFORM() antlr.TerminalNode { + return s.GetToken(TSqlParserPLATFORM, 0) +} + +func (s *Create_external_libraryContext) AllLANGUAGE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLANGUAGE) +} + +func (s *Create_external_libraryContext) LANGUAGE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLANGUAGE, i) +} + +func (s *Create_external_libraryContext) AllDATA_SOURCE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDATA_SOURCE) +} + +func (s *Create_external_libraryContext) DATA_SOURCE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDATA_SOURCE, i) +} + +func (s *Create_external_libraryContext) AllR() []antlr.TerminalNode { + return s.GetTokens(TSqlParserR) +} + +func (s *Create_external_libraryContext) R(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserR, i) +} + +func (s *Create_external_libraryContext) AllPYTHON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserPYTHON) +} + +func (s *Create_external_libraryContext) PYTHON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserPYTHON, i) +} + +func (s *Create_external_libraryContext) WINDOWS() antlr.TerminalNode { + return s.GetToken(TSqlParserWINDOWS, 0) +} + +func (s *Create_external_libraryContext) LINUX() antlr.TerminalNode { + return s.GetToken(TSqlParserLINUX, 0) +} + +func (s *Create_external_libraryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_external_libraryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_external_libraryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_external_library(s) + } +} + +func (s *Create_external_libraryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_external_library(s) + } +} + +func (s *Create_external_libraryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_external_library(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_external_library() (localctx ICreate_external_libraryContext) { + localctx = NewCreate_external_libraryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 316, TSqlParserRULE_create_external_library) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3899) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3900) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3901) + p.Match(TSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3902) + + var _x = p.Id_() + + localctx.(*Create_external_libraryContext).library_name = _x + } + p.SetState(3905) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(3903) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3904) + + var _x = p.Id_() + + localctx.(*Create_external_libraryContext).owner_name = _x + } + + } + { + p.SetState(3907) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3909) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3908) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLR_BRACKET { + { + p.SetState(3911) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCONTENT { + { + p.SetState(3914) + p.Match(TSqlParserCONTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3915) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(3918) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_external_libraryContext).client_library = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserBINARY: + { + p.SetState(3919) + p.Match(TSqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNONE: + { + p.SetState(3920) + p.Match(TSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3923) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3924) + p.Match(TSqlParserPLATFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3925) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3927) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLINUX || _la == TSqlParserWINDOWS { + { + p.SetState(3926) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLINUX || _la == TSqlParserWINDOWS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(3929) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(3947) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 349, p.GetParserRuleContext()) == 1 { + { + p.SetState(3932) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserDATA_SOURCE || _la == TSqlParserLANGUAGE || _la == TSqlParserCOMMA { + p.SetState(3942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLANGUAGE, TSqlParserCOMMA: + p.SetState(3934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3933) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3936) + p.Match(TSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3937) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3938) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserPYTHON || _la == TSqlParserR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserDATA_SOURCE: + { + p.SetState(3939) + p.Match(TSqlParserDATA_SOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3940) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3941) + + var _x = p.Id_() + + localctx.(*Create_external_libraryContext).external_data_source_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3946) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_external_resource_poolContext is an interface to support dynamic dispatch. +type IAlter_external_resource_poolContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMax_cpu_percent returns the max_cpu_percent token. + GetMax_cpu_percent() antlr.Token + + // GetMax_memory_percent returns the max_memory_percent token. + GetMax_memory_percent() antlr.Token + + // GetMax_processes returns the max_processes token. + GetMax_processes() antlr.Token + + // SetMax_cpu_percent sets the max_cpu_percent token. + SetMax_cpu_percent(antlr.Token) + + // SetMax_memory_percent sets the max_memory_percent token. + SetMax_memory_percent(antlr.Token) + + // SetMax_processes sets the max_processes token. + SetMax_processes(antlr.Token) + + // GetPool_name returns the pool_name rule contexts. + GetPool_name() IId_Context + + // SetPool_name sets the pool_name rule contexts. + SetPool_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + POOL() antlr.TerminalNode + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + MAX_CPU_PERCENT() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + DEFAULT_DOUBLE_QUOTE() antlr.TerminalNode + AFFINITY() antlr.TerminalNode + CPU() antlr.TerminalNode + NUMANODE() antlr.TerminalNode + Id_() IId_Context + MAX_MEMORY_PERCENT() antlr.TerminalNode + MAX_PROCESSES() antlr.TerminalNode + AUTO() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + + // IsAlter_external_resource_poolContext differentiates from other interfaces. + IsAlter_external_resource_poolContext() +} + +type Alter_external_resource_poolContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + pool_name IId_Context + max_cpu_percent antlr.Token + max_memory_percent antlr.Token + max_processes antlr.Token +} + +func NewEmptyAlter_external_resource_poolContext() *Alter_external_resource_poolContext { + var p = new(Alter_external_resource_poolContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_external_resource_pool + return p +} + +func InitEmptyAlter_external_resource_poolContext(p *Alter_external_resource_poolContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_external_resource_pool +} + +func (*Alter_external_resource_poolContext) IsAlter_external_resource_poolContext() {} + +func NewAlter_external_resource_poolContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_external_resource_poolContext { + var p = new(Alter_external_resource_poolContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_external_resource_pool + + return p +} + +func (s *Alter_external_resource_poolContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_external_resource_poolContext) GetMax_cpu_percent() antlr.Token { + return s.max_cpu_percent +} + +func (s *Alter_external_resource_poolContext) GetMax_memory_percent() antlr.Token { + return s.max_memory_percent +} + +func (s *Alter_external_resource_poolContext) GetMax_processes() antlr.Token { return s.max_processes } + +func (s *Alter_external_resource_poolContext) SetMax_cpu_percent(v antlr.Token) { + s.max_cpu_percent = v +} + +func (s *Alter_external_resource_poolContext) SetMax_memory_percent(v antlr.Token) { + s.max_memory_percent = v +} + +func (s *Alter_external_resource_poolContext) SetMax_processes(v antlr.Token) { s.max_processes = v } + +func (s *Alter_external_resource_poolContext) GetPool_name() IId_Context { return s.pool_name } + +func (s *Alter_external_resource_poolContext) SetPool_name(v IId_Context) { s.pool_name = v } + +func (s *Alter_external_resource_poolContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_external_resource_poolContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Alter_external_resource_poolContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESOURCE, 0) +} + +func (s *Alter_external_resource_poolContext) POOL() antlr.TerminalNode { + return s.GetToken(TSqlParserPOOL, 0) +} + +func (s *Alter_external_resource_poolContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_external_resource_poolContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Alter_external_resource_poolContext) MAX_CPU_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_CPU_PERCENT, 0) +} + +func (s *Alter_external_resource_poolContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_external_resource_poolContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_external_resource_poolContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Alter_external_resource_poolContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Alter_external_resource_poolContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Alter_external_resource_poolContext) DEFAULT_DOUBLE_QUOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_DOUBLE_QUOTE, 0) +} + +func (s *Alter_external_resource_poolContext) AFFINITY() antlr.TerminalNode { + return s.GetToken(TSqlParserAFFINITY, 0) +} + +func (s *Alter_external_resource_poolContext) CPU() antlr.TerminalNode { + return s.GetToken(TSqlParserCPU, 0) +} + +func (s *Alter_external_resource_poolContext) NUMANODE() antlr.TerminalNode { + return s.GetToken(TSqlParserNUMANODE, 0) +} + +func (s *Alter_external_resource_poolContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_external_resource_poolContext) MAX_MEMORY_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_MEMORY_PERCENT, 0) +} + +func (s *Alter_external_resource_poolContext) MAX_PROCESSES() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_PROCESSES, 0) +} + +func (s *Alter_external_resource_poolContext) AUTO() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO, 0) +} + +func (s *Alter_external_resource_poolContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_external_resource_poolContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_external_resource_poolContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTO) +} + +func (s *Alter_external_resource_poolContext) TO(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTO, i) +} + +func (s *Alter_external_resource_poolContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_external_resource_poolContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_external_resource_poolContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_external_resource_pool(s) + } +} + +func (s *Alter_external_resource_poolContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_external_resource_pool(s) + } +} + +func (s *Alter_external_resource_poolContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_external_resource_pool(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_external_resource_pool() (localctx IAlter_external_resource_poolContext) { + localctx = NewAlter_external_resource_poolContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 318, TSqlParserRULE_alter_external_resource_pool) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3949) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3950) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3951) + p.Match(TSqlParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3952) + p.Match(TSqlParserPOOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3955) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 350, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3953) + + var _x = p.Id_() + + localctx.(*Alter_external_resource_poolContext).pool_name = _x + } + + case 2: + { + p.SetState(3954) + p.Match(TSqlParserDEFAULT_DOUBLE_QUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(3957) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3958) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3959) + p.Match(TSqlParserMAX_CPU_PERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3960) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3961) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_external_resource_poolContext).max_cpu_percent = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3999) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAFFINITY, TSqlParserCOMMA: + p.SetState(3963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3962) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3965) + p.Match(TSqlParserAFFINITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3966) + p.Match(TSqlParserCPU) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3967) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3981) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAUTO: + { + p.SetState(3968) + p.Match(TSqlParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL, TSqlParserCOMMA: + p.SetState(3977) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(3977) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 353, p.GetParserRuleContext()) { + case 1: + p.SetState(3970) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3969) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3972) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3973) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3974) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(3975) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3976) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3979) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 354, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserNUMANODE: + { + p.SetState(3983) + p.Match(TSqlParserNUMANODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3984) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(3995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 358, p.GetParserRuleContext()) { + case 1: + p.SetState(3986) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3985) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3988) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3989) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3990) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(3992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(3991) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3994) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3997) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 359, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(4007) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 362, p.GetParserRuleContext()) == 1 { + p.SetState(4002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4001) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4004) + p.Match(TSqlParserMAX_MEMORY_PERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4005) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4006) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_external_resource_poolContext).max_memory_percent = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMAX_PROCESSES || _la == TSqlParserCOMMA { + p.SetState(4010) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4009) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4012) + p.Match(TSqlParserMAX_PROCESSES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4013) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4014) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_external_resource_poolContext).max_processes = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4017) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_external_resource_poolContext is an interface to support dynamic dispatch. +type ICreate_external_resource_poolContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMax_cpu_percent returns the max_cpu_percent token. + GetMax_cpu_percent() antlr.Token + + // GetMax_memory_percent returns the max_memory_percent token. + GetMax_memory_percent() antlr.Token + + // GetMax_processes returns the max_processes token. + GetMax_processes() antlr.Token + + // SetMax_cpu_percent sets the max_cpu_percent token. + SetMax_cpu_percent(antlr.Token) + + // SetMax_memory_percent sets the max_memory_percent token. + SetMax_memory_percent(antlr.Token) + + // SetMax_processes sets the max_processes token. + SetMax_processes(antlr.Token) + + // GetPool_name returns the pool_name rule contexts. + GetPool_name() IId_Context + + // SetPool_name sets the pool_name rule contexts. + SetPool_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + POOL() antlr.TerminalNode + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + MAX_CPU_PERCENT() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Id_() IId_Context + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + AFFINITY() antlr.TerminalNode + CPU() antlr.TerminalNode + NUMANODE() antlr.TerminalNode + MAX_MEMORY_PERCENT() antlr.TerminalNode + MAX_PROCESSES() antlr.TerminalNode + AUTO() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + + // IsCreate_external_resource_poolContext differentiates from other interfaces. + IsCreate_external_resource_poolContext() +} + +type Create_external_resource_poolContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + pool_name IId_Context + max_cpu_percent antlr.Token + max_memory_percent antlr.Token + max_processes antlr.Token +} + +func NewEmptyCreate_external_resource_poolContext() *Create_external_resource_poolContext { + var p = new(Create_external_resource_poolContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_external_resource_pool + return p +} + +func InitEmptyCreate_external_resource_poolContext(p *Create_external_resource_poolContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_external_resource_pool +} + +func (*Create_external_resource_poolContext) IsCreate_external_resource_poolContext() {} + +func NewCreate_external_resource_poolContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_external_resource_poolContext { + var p = new(Create_external_resource_poolContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_external_resource_pool + + return p +} + +func (s *Create_external_resource_poolContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_external_resource_poolContext) GetMax_cpu_percent() antlr.Token { + return s.max_cpu_percent +} + +func (s *Create_external_resource_poolContext) GetMax_memory_percent() antlr.Token { + return s.max_memory_percent +} + +func (s *Create_external_resource_poolContext) GetMax_processes() antlr.Token { return s.max_processes } + +func (s *Create_external_resource_poolContext) SetMax_cpu_percent(v antlr.Token) { + s.max_cpu_percent = v +} + +func (s *Create_external_resource_poolContext) SetMax_memory_percent(v antlr.Token) { + s.max_memory_percent = v +} + +func (s *Create_external_resource_poolContext) SetMax_processes(v antlr.Token) { s.max_processes = v } + +func (s *Create_external_resource_poolContext) GetPool_name() IId_Context { return s.pool_name } + +func (s *Create_external_resource_poolContext) SetPool_name(v IId_Context) { s.pool_name = v } + +func (s *Create_external_resource_poolContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_external_resource_poolContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Create_external_resource_poolContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESOURCE, 0) +} + +func (s *Create_external_resource_poolContext) POOL() antlr.TerminalNode { + return s.GetToken(TSqlParserPOOL, 0) +} + +func (s *Create_external_resource_poolContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_external_resource_poolContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_external_resource_poolContext) MAX_CPU_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_CPU_PERCENT, 0) +} + +func (s *Create_external_resource_poolContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_external_resource_poolContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_external_resource_poolContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_external_resource_poolContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_external_resource_poolContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Create_external_resource_poolContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Create_external_resource_poolContext) AFFINITY() antlr.TerminalNode { + return s.GetToken(TSqlParserAFFINITY, 0) +} + +func (s *Create_external_resource_poolContext) CPU() antlr.TerminalNode { + return s.GetToken(TSqlParserCPU, 0) +} + +func (s *Create_external_resource_poolContext) NUMANODE() antlr.TerminalNode { + return s.GetToken(TSqlParserNUMANODE, 0) +} + +func (s *Create_external_resource_poolContext) MAX_MEMORY_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_MEMORY_PERCENT, 0) +} + +func (s *Create_external_resource_poolContext) MAX_PROCESSES() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_PROCESSES, 0) +} + +func (s *Create_external_resource_poolContext) AUTO() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO, 0) +} + +func (s *Create_external_resource_poolContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_external_resource_poolContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_external_resource_poolContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTO) +} + +func (s *Create_external_resource_poolContext) TO(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTO, i) +} + +func (s *Create_external_resource_poolContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_external_resource_poolContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_external_resource_poolContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_external_resource_pool(s) + } +} + +func (s *Create_external_resource_poolContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_external_resource_pool(s) + } +} + +func (s *Create_external_resource_poolContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_external_resource_pool(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_external_resource_pool() (localctx ICreate_external_resource_poolContext) { + localctx = NewCreate_external_resource_poolContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 320, TSqlParserRULE_create_external_resource_pool) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4019) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4020) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4021) + p.Match(TSqlParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4022) + p.Match(TSqlParserPOOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4023) + + var _x = p.Id_() + + localctx.(*Create_external_resource_poolContext).pool_name = _x + } + { + p.SetState(4024) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4025) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4026) + p.Match(TSqlParserMAX_CPU_PERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4027) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4028) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_external_resource_poolContext).max_cpu_percent = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAFFINITY, TSqlParserCOMMA: + p.SetState(4030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4029) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4032) + p.Match(TSqlParserAFFINITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4033) + p.Match(TSqlParserCPU) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4034) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4048) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAUTO: + { + p.SetState(4035) + p.Match(TSqlParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL, TSqlParserCOMMA: + p.SetState(4044) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(4044) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 367, p.GetParserRuleContext()) { + case 1: + p.SetState(4037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4036) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4039) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4040) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4041) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(4042) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4043) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4046) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 368, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserNUMANODE: + { + p.SetState(4050) + p.Match(TSqlParserNUMANODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4051) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4062) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(4062) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 372, p.GetParserRuleContext()) { + case 1: + p.SetState(4053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4052) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4055) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4056) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4057) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(4059) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4058) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4061) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4064) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 373, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(4074) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 376, p.GetParserRuleContext()) == 1 { + p.SetState(4069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4068) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4071) + p.Match(TSqlParserMAX_MEMORY_PERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4072) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4073) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_external_resource_poolContext).max_memory_percent = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMAX_PROCESSES || _la == TSqlParserCOMMA { + p.SetState(4077) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4076) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4079) + p.Match(TSqlParserMAX_PROCESSES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4080) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4081) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_external_resource_poolContext).max_processes = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4084) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_fulltext_catalogContext is an interface to support dynamic dispatch. +type IAlter_fulltext_catalogContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCatalog_name returns the catalog_name rule contexts. + GetCatalog_name() IId_Context + + // SetCatalog_name sets the catalog_name rule contexts. + SetCatalog_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + FULLTEXT() antlr.TerminalNode + CATALOG() antlr.TerminalNode + Id_() IId_Context + REBUILD() antlr.TerminalNode + REORGANIZE() antlr.TerminalNode + AS() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + WITH() antlr.TerminalNode + ACCENT_SENSITIVITY() antlr.TerminalNode + EQUAL() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsAlter_fulltext_catalogContext differentiates from other interfaces. + IsAlter_fulltext_catalogContext() +} + +type Alter_fulltext_catalogContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + catalog_name IId_Context +} + +func NewEmptyAlter_fulltext_catalogContext() *Alter_fulltext_catalogContext { + var p = new(Alter_fulltext_catalogContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_fulltext_catalog + return p +} + +func InitEmptyAlter_fulltext_catalogContext(p *Alter_fulltext_catalogContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_fulltext_catalog +} + +func (*Alter_fulltext_catalogContext) IsAlter_fulltext_catalogContext() {} + +func NewAlter_fulltext_catalogContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_fulltext_catalogContext { + var p = new(Alter_fulltext_catalogContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_fulltext_catalog + + return p +} + +func (s *Alter_fulltext_catalogContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_fulltext_catalogContext) GetCatalog_name() IId_Context { return s.catalog_name } + +func (s *Alter_fulltext_catalogContext) SetCatalog_name(v IId_Context) { s.catalog_name = v } + +func (s *Alter_fulltext_catalogContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_fulltext_catalogContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXT, 0) +} + +func (s *Alter_fulltext_catalogContext) CATALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserCATALOG, 0) +} + +func (s *Alter_fulltext_catalogContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_fulltext_catalogContext) REBUILD() antlr.TerminalNode { + return s.GetToken(TSqlParserREBUILD, 0) +} + +func (s *Alter_fulltext_catalogContext) REORGANIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserREORGANIZE, 0) +} + +func (s *Alter_fulltext_catalogContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Alter_fulltext_catalogContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Alter_fulltext_catalogContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_fulltext_catalogContext) ACCENT_SENSITIVITY() antlr.TerminalNode { + return s.GetToken(TSqlParserACCENT_SENSITIVITY, 0) +} + +func (s *Alter_fulltext_catalogContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_fulltext_catalogContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Alter_fulltext_catalogContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Alter_fulltext_catalogContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_fulltext_catalogContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_fulltext_catalogContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_fulltext_catalog(s) + } +} + +func (s *Alter_fulltext_catalogContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_fulltext_catalog(s) + } +} + +func (s *Alter_fulltext_catalogContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_fulltext_catalog(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_fulltext_catalog() (localctx IAlter_fulltext_catalogContext) { + localctx = NewAlter_fulltext_catalogContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 322, TSqlParserRULE_alter_fulltext_catalog) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4086) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4087) + p.Match(TSqlParserFULLTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4088) + p.Match(TSqlParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4089) + + var _x = p.Id_() + + localctx.(*Alter_fulltext_catalogContext).catalog_name = _x + } + p.SetState(4100) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserREBUILD: + { + p.SetState(4090) + p.Match(TSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4095) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 379, p.GetParserRuleContext()) == 1 { + { + p.SetState(4091) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4092) + p.Match(TSqlParserACCENT_SENSITIVITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4093) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4094) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserREORGANIZE: + { + p.SetState(4097) + p.Match(TSqlParserREORGANIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserAS: + { + p.SetState(4098) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4099) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_fulltext_catalogContext is an interface to support dynamic dispatch. +type ICreate_fulltext_catalogContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRootpath returns the rootpath token. + GetRootpath() antlr.Token + + // SetRootpath sets the rootpath token. + SetRootpath(antlr.Token) + + // GetCatalog_name returns the catalog_name rule contexts. + GetCatalog_name() IId_Context + + // GetFilegroup returns the filegroup rule contexts. + GetFilegroup() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // SetCatalog_name sets the catalog_name rule contexts. + SetCatalog_name(IId_Context) + + // SetFilegroup sets the filegroup rule contexts. + SetFilegroup(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + FULLTEXT() antlr.TerminalNode + CATALOG() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + IN() antlr.TerminalNode + PATH() antlr.TerminalNode + WITH() antlr.TerminalNode + ACCENT_SENSITIVITY() antlr.TerminalNode + EQUAL() antlr.TerminalNode + AS() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + STRING() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsCreate_fulltext_catalogContext differentiates from other interfaces. + IsCreate_fulltext_catalogContext() +} + +type Create_fulltext_catalogContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + catalog_name IId_Context + filegroup IId_Context + rootpath antlr.Token + owner_name IId_Context +} + +func NewEmptyCreate_fulltext_catalogContext() *Create_fulltext_catalogContext { + var p = new(Create_fulltext_catalogContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_fulltext_catalog + return p +} + +func InitEmptyCreate_fulltext_catalogContext(p *Create_fulltext_catalogContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_fulltext_catalog +} + +func (*Create_fulltext_catalogContext) IsCreate_fulltext_catalogContext() {} + +func NewCreate_fulltext_catalogContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_fulltext_catalogContext { + var p = new(Create_fulltext_catalogContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_fulltext_catalog + + return p +} + +func (s *Create_fulltext_catalogContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_fulltext_catalogContext) GetRootpath() antlr.Token { return s.rootpath } + +func (s *Create_fulltext_catalogContext) SetRootpath(v antlr.Token) { s.rootpath = v } + +func (s *Create_fulltext_catalogContext) GetCatalog_name() IId_Context { return s.catalog_name } + +func (s *Create_fulltext_catalogContext) GetFilegroup() IId_Context { return s.filegroup } + +func (s *Create_fulltext_catalogContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Create_fulltext_catalogContext) SetCatalog_name(v IId_Context) { s.catalog_name = v } + +func (s *Create_fulltext_catalogContext) SetFilegroup(v IId_Context) { s.filegroup = v } + +func (s *Create_fulltext_catalogContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Create_fulltext_catalogContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_fulltext_catalogContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXT, 0) +} + +func (s *Create_fulltext_catalogContext) CATALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserCATALOG, 0) +} + +func (s *Create_fulltext_catalogContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_fulltext_catalogContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_fulltext_catalogContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Create_fulltext_catalogContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Create_fulltext_catalogContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROUP, 0) +} + +func (s *Create_fulltext_catalogContext) IN() antlr.TerminalNode { + return s.GetToken(TSqlParserIN, 0) +} + +func (s *Create_fulltext_catalogContext) PATH() antlr.TerminalNode { + return s.GetToken(TSqlParserPATH, 0) +} + +func (s *Create_fulltext_catalogContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_fulltext_catalogContext) ACCENT_SENSITIVITY() antlr.TerminalNode { + return s.GetToken(TSqlParserACCENT_SENSITIVITY, 0) +} + +func (s *Create_fulltext_catalogContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_fulltext_catalogContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Create_fulltext_catalogContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Create_fulltext_catalogContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_fulltext_catalogContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_fulltext_catalogContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Create_fulltext_catalogContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_fulltext_catalogContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_fulltext_catalogContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_fulltext_catalog(s) + } +} + +func (s *Create_fulltext_catalogContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_fulltext_catalog(s) + } +} + +func (s *Create_fulltext_catalogContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_fulltext_catalog(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_fulltext_catalog() (localctx ICreate_fulltext_catalogContext) { + localctx = NewCreate_fulltext_catalogContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 324, TSqlParserRULE_create_fulltext_catalog) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4102) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4103) + p.Match(TSqlParserFULLTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4104) + p.Match(TSqlParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4105) + + var _x = p.Id_() + + localctx.(*Create_fulltext_catalogContext).catalog_name = _x + } + p.SetState(4109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(4106) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4107) + p.Match(TSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4108) + + var _x = p.Id_() + + localctx.(*Create_fulltext_catalogContext).filegroup = _x + } + + } + p.SetState(4114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIN { + { + p.SetState(4111) + p.Match(TSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4112) + p.Match(TSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4113) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_fulltext_catalogContext).rootpath = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4120) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 383, p.GetParserRuleContext()) == 1 { + { + p.SetState(4116) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4117) + p.Match(TSqlParserACCENT_SENSITIVITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4118) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4119) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4124) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(4122) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4123) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4128) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(4126) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4127) + + var _x = p.Id_() + + localctx.(*Create_fulltext_catalogContext).owner_name = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_fulltext_stoplistContext is an interface to support dynamic dispatch. +type IAlter_fulltext_stoplistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetStopword returns the stopword token. + GetStopword() antlr.Token + + // SetStopword sets the stopword token. + SetStopword(antlr.Token) + + // GetStoplist_name returns the stoplist_name rule contexts. + GetStoplist_name() IId_Context + + // SetStoplist_name sets the stoplist_name rule contexts. + SetStoplist_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + FULLTEXT() antlr.TerminalNode + STOPLIST() antlr.TerminalNode + Id_() IId_Context + ADD() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + DROP() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + DECIMAL() antlr.TerminalNode + BINARY() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsAlter_fulltext_stoplistContext differentiates from other interfaces. + IsAlter_fulltext_stoplistContext() +} + +type Alter_fulltext_stoplistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + stoplist_name IId_Context + stopword antlr.Token +} + +func NewEmptyAlter_fulltext_stoplistContext() *Alter_fulltext_stoplistContext { + var p = new(Alter_fulltext_stoplistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_fulltext_stoplist + return p +} + +func InitEmptyAlter_fulltext_stoplistContext(p *Alter_fulltext_stoplistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_fulltext_stoplist +} + +func (*Alter_fulltext_stoplistContext) IsAlter_fulltext_stoplistContext() {} + +func NewAlter_fulltext_stoplistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_fulltext_stoplistContext { + var p = new(Alter_fulltext_stoplistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_fulltext_stoplist + + return p +} + +func (s *Alter_fulltext_stoplistContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_fulltext_stoplistContext) GetStopword() antlr.Token { return s.stopword } + +func (s *Alter_fulltext_stoplistContext) SetStopword(v antlr.Token) { s.stopword = v } + +func (s *Alter_fulltext_stoplistContext) GetStoplist_name() IId_Context { return s.stoplist_name } + +func (s *Alter_fulltext_stoplistContext) SetStoplist_name(v IId_Context) { s.stoplist_name = v } + +func (s *Alter_fulltext_stoplistContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_fulltext_stoplistContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXT, 0) +} + +func (s *Alter_fulltext_stoplistContext) STOPLIST() antlr.TerminalNode { + return s.GetToken(TSqlParserSTOPLIST, 0) +} + +func (s *Alter_fulltext_stoplistContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_fulltext_stoplistContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_fulltext_stoplistContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserLANGUAGE, 0) +} + +func (s *Alter_fulltext_stoplistContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Alter_fulltext_stoplistContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Alter_fulltext_stoplistContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Alter_fulltext_stoplistContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Alter_fulltext_stoplistContext) BINARY() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY, 0) +} + +func (s *Alter_fulltext_stoplistContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Alter_fulltext_stoplistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_fulltext_stoplistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_fulltext_stoplistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_fulltext_stoplist(s) + } +} + +func (s *Alter_fulltext_stoplistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_fulltext_stoplist(s) + } +} + +func (s *Alter_fulltext_stoplistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_fulltext_stoplist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_fulltext_stoplist() (localctx IAlter_fulltext_stoplistContext) { + localctx = NewAlter_fulltext_stoplistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 326, TSqlParserRULE_alter_fulltext_stoplist) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4130) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4131) + p.Match(TSqlParserFULLTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4132) + p.Match(TSqlParserSTOPLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4133) + + var _x = p.Id_() + + localctx.(*Alter_fulltext_stoplistContext).stoplist_name = _x + } + p.SetState(4147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserADD: + { + p.SetState(4134) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4135) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_fulltext_stoplistContext).stopword = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4136) + p.Match(TSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4137) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1182)) & ^0x3f) == 0 && ((int64(1)<<(_la-1182))&13) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserDROP: + { + p.SetState(4138) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 386, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4139) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_fulltext_stoplistContext).stopword = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4140) + p.Match(TSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4141) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1182)) & ^0x3f) == 0 && ((int64(1)<<(_la-1182))&13) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + { + p.SetState(4142) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4143) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1182)) & ^0x3f) == 0 && ((int64(1)<<(_la-1182))&13) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 3: + { + p.SetState(4144) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_fulltext_stoplistContext is an interface to support dynamic dispatch. +type ICreate_fulltext_stoplistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetStoplist_name returns the stoplist_name rule contexts. + GetStoplist_name() IId_Context + + // GetDatabase_name returns the database_name rule contexts. + GetDatabase_name() IId_Context + + // GetSource_stoplist_name returns the source_stoplist_name rule contexts. + GetSource_stoplist_name() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // SetStoplist_name sets the stoplist_name rule contexts. + SetStoplist_name(IId_Context) + + // SetDatabase_name sets the database_name rule contexts. + SetDatabase_name(IId_Context) + + // SetSource_stoplist_name sets the source_stoplist_name rule contexts. + SetSource_stoplist_name(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + FULLTEXT() antlr.TerminalNode + AllSTOPLIST() []antlr.TerminalNode + STOPLIST(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + FROM() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + DOT() antlr.TerminalNode + + // IsCreate_fulltext_stoplistContext differentiates from other interfaces. + IsCreate_fulltext_stoplistContext() +} + +type Create_fulltext_stoplistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + stoplist_name IId_Context + database_name IId_Context + source_stoplist_name IId_Context + owner_name IId_Context +} + +func NewEmptyCreate_fulltext_stoplistContext() *Create_fulltext_stoplistContext { + var p = new(Create_fulltext_stoplistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_fulltext_stoplist + return p +} + +func InitEmptyCreate_fulltext_stoplistContext(p *Create_fulltext_stoplistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_fulltext_stoplist +} + +func (*Create_fulltext_stoplistContext) IsCreate_fulltext_stoplistContext() {} + +func NewCreate_fulltext_stoplistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_fulltext_stoplistContext { + var p = new(Create_fulltext_stoplistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_fulltext_stoplist + + return p +} + +func (s *Create_fulltext_stoplistContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_fulltext_stoplistContext) GetStoplist_name() IId_Context { return s.stoplist_name } + +func (s *Create_fulltext_stoplistContext) GetDatabase_name() IId_Context { return s.database_name } + +func (s *Create_fulltext_stoplistContext) GetSource_stoplist_name() IId_Context { + return s.source_stoplist_name +} + +func (s *Create_fulltext_stoplistContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Create_fulltext_stoplistContext) SetStoplist_name(v IId_Context) { s.stoplist_name = v } + +func (s *Create_fulltext_stoplistContext) SetDatabase_name(v IId_Context) { s.database_name = v } + +func (s *Create_fulltext_stoplistContext) SetSource_stoplist_name(v IId_Context) { + s.source_stoplist_name = v +} + +func (s *Create_fulltext_stoplistContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Create_fulltext_stoplistContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_fulltext_stoplistContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXT, 0) +} + +func (s *Create_fulltext_stoplistContext) AllSTOPLIST() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTOPLIST) +} + +func (s *Create_fulltext_stoplistContext) STOPLIST(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTOPLIST, i) +} + +func (s *Create_fulltext_stoplistContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_fulltext_stoplistContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_fulltext_stoplistContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Create_fulltext_stoplistContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_fulltext_stoplistContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(TSqlParserSYSTEM, 0) +} + +func (s *Create_fulltext_stoplistContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Create_fulltext_stoplistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_fulltext_stoplistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_fulltext_stoplistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_fulltext_stoplist(s) + } +} + +func (s *Create_fulltext_stoplistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_fulltext_stoplist(s) + } +} + +func (s *Create_fulltext_stoplistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_fulltext_stoplist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_fulltext_stoplist() (localctx ICreate_fulltext_stoplistContext) { + localctx = NewCreate_fulltext_stoplistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 328, TSqlParserRULE_create_fulltext_stoplist) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4149) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4150) + p.Match(TSqlParserFULLTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4151) + p.Match(TSqlParserSTOPLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4152) + + var _x = p.Id_() + + localctx.(*Create_fulltext_stoplistContext).stoplist_name = _x + } + p.SetState(4164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFROM { + { + p.SetState(4153) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4162) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 389, p.GetParserRuleContext()) { + case 1: + p.SetState(4157) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 388, p.GetParserRuleContext()) == 1 { + { + p.SetState(4154) + + var _x = p.Id_() + + localctx.(*Create_fulltext_stoplistContext).database_name = _x + } + { + p.SetState(4155) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4159) + + var _x = p.Id_() + + localctx.(*Create_fulltext_stoplistContext).source_stoplist_name = _x + } + + case 2: + { + p.SetState(4160) + p.Match(TSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4161) + p.Match(TSqlParserSTOPLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(4168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(4166) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4167) + + var _x = p.Id_() + + localctx.(*Create_fulltext_stoplistContext).owner_name = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_login_sql_serverContext is an interface to support dynamic dispatch. +type IAlter_login_sql_serverContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // GetPassword_hash returns the password_hash token. + GetPassword_hash() antlr.Token + + // GetOld_password returns the old_password token. + GetOld_password() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // SetPassword_hash sets the password_hash token. + SetPassword_hash(antlr.Token) + + // SetOld_password sets the old_password token. + SetOld_password(antlr.Token) + + // GetLogin_name returns the login_name rule contexts. + GetLogin_name() IId_Context + + // GetDefault_database returns the default_database rule contexts. + GetDefault_database() IId_Context + + // GetDefault_laguage returns the default_laguage rule contexts. + GetDefault_laguage() IId_Context + + // GetCredential_name returns the credential_name rule contexts. + GetCredential_name() IId_Context + + // SetLogin_name sets the login_name rule contexts. + SetLogin_name(IId_Context) + + // SetDefault_database sets the default_database rule contexts. + SetDefault_database(IId_Context) + + // SetDefault_laguage sets the default_laguage rule contexts. + SetDefault_laguage(IId_Context) + + // SetCredential_name sets the credential_name rule contexts. + SetCredential_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + LOGIN() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + WITH() antlr.TerminalNode + AllCREDENTIAL() []antlr.TerminalNode + CREDENTIAL(i int) antlr.TerminalNode + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + OLD_PASSWORD() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + DEFAULT_DATABASE() antlr.TerminalNode + DEFAULT_LANGUAGE() antlr.TerminalNode + NAME() antlr.TerminalNode + CHECK_POLICY() antlr.TerminalNode + CHECK_EXPIRATION() antlr.TerminalNode + NO() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllOFF() []antlr.TerminalNode + OFF(i int) antlr.TerminalNode + PASSWORD() antlr.TerminalNode + HASHED() antlr.TerminalNode + AllMUST_CHANGE() []antlr.TerminalNode + MUST_CHANGE(i int) antlr.TerminalNode + AllUNLOCK() []antlr.TerminalNode + UNLOCK(i int) antlr.TerminalNode + BINARY() antlr.TerminalNode + + // IsAlter_login_sql_serverContext differentiates from other interfaces. + IsAlter_login_sql_serverContext() +} + +type Alter_login_sql_serverContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + login_name IId_Context + password antlr.Token + password_hash antlr.Token + old_password antlr.Token + default_database IId_Context + default_laguage IId_Context + credential_name IId_Context +} + +func NewEmptyAlter_login_sql_serverContext() *Alter_login_sql_serverContext { + var p = new(Alter_login_sql_serverContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_login_sql_server + return p +} + +func InitEmptyAlter_login_sql_serverContext(p *Alter_login_sql_serverContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_login_sql_server +} + +func (*Alter_login_sql_serverContext) IsAlter_login_sql_serverContext() {} + +func NewAlter_login_sql_serverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_login_sql_serverContext { + var p = new(Alter_login_sql_serverContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_login_sql_server + + return p +} + +func (s *Alter_login_sql_serverContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_login_sql_serverContext) GetPassword() antlr.Token { return s.password } + +func (s *Alter_login_sql_serverContext) GetPassword_hash() antlr.Token { return s.password_hash } + +func (s *Alter_login_sql_serverContext) GetOld_password() antlr.Token { return s.old_password } + +func (s *Alter_login_sql_serverContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Alter_login_sql_serverContext) SetPassword_hash(v antlr.Token) { s.password_hash = v } + +func (s *Alter_login_sql_serverContext) SetOld_password(v antlr.Token) { s.old_password = v } + +func (s *Alter_login_sql_serverContext) GetLogin_name() IId_Context { return s.login_name } + +func (s *Alter_login_sql_serverContext) GetDefault_database() IId_Context { return s.default_database } + +func (s *Alter_login_sql_serverContext) GetDefault_laguage() IId_Context { return s.default_laguage } + +func (s *Alter_login_sql_serverContext) GetCredential_name() IId_Context { return s.credential_name } + +func (s *Alter_login_sql_serverContext) SetLogin_name(v IId_Context) { s.login_name = v } + +func (s *Alter_login_sql_serverContext) SetDefault_database(v IId_Context) { s.default_database = v } + +func (s *Alter_login_sql_serverContext) SetDefault_laguage(v IId_Context) { s.default_laguage = v } + +func (s *Alter_login_sql_serverContext) SetCredential_name(v IId_Context) { s.credential_name = v } + +func (s *Alter_login_sql_serverContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_login_sql_serverContext) LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, 0) +} + +func (s *Alter_login_sql_serverContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_login_sql_serverContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_login_sql_serverContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_login_sql_serverContext) AllCREDENTIAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCREDENTIAL) +} + +func (s *Alter_login_sql_serverContext) CREDENTIAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCREDENTIAL, i) +} + +func (s *Alter_login_sql_serverContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_login_sql_serverContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Alter_login_sql_serverContext) OLD_PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserOLD_PASSWORD, 0) +} + +func (s *Alter_login_sql_serverContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_login_sql_serverContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_login_sql_serverContext) DEFAULT_DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_DATABASE, 0) +} + +func (s *Alter_login_sql_serverContext) DEFAULT_LANGUAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_LANGUAGE, 0) +} + +func (s *Alter_login_sql_serverContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *Alter_login_sql_serverContext) CHECK_POLICY() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECK_POLICY, 0) +} + +func (s *Alter_login_sql_serverContext) CHECK_EXPIRATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECK_EXPIRATION, 0) +} + +func (s *Alter_login_sql_serverContext) NO() antlr.TerminalNode { + return s.GetToken(TSqlParserNO, 0) +} + +func (s *Alter_login_sql_serverContext) ENABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserENABLE, 0) +} + +func (s *Alter_login_sql_serverContext) DISABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLE, 0) +} + +func (s *Alter_login_sql_serverContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Alter_login_sql_serverContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Alter_login_sql_serverContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Alter_login_sql_serverContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Alter_login_sql_serverContext) AllOFF() []antlr.TerminalNode { + return s.GetTokens(TSqlParserOFF) +} + +func (s *Alter_login_sql_serverContext) OFF(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, i) +} + +func (s *Alter_login_sql_serverContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Alter_login_sql_serverContext) HASHED() antlr.TerminalNode { + return s.GetToken(TSqlParserHASHED, 0) +} + +func (s *Alter_login_sql_serverContext) AllMUST_CHANGE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMUST_CHANGE) +} + +func (s *Alter_login_sql_serverContext) MUST_CHANGE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMUST_CHANGE, i) +} + +func (s *Alter_login_sql_serverContext) AllUNLOCK() []antlr.TerminalNode { + return s.GetTokens(TSqlParserUNLOCK) +} + +func (s *Alter_login_sql_serverContext) UNLOCK(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserUNLOCK, i) +} + +func (s *Alter_login_sql_serverContext) BINARY() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY, 0) +} + +func (s *Alter_login_sql_serverContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_login_sql_serverContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_login_sql_serverContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_login_sql_server(s) + } +} + +func (s *Alter_login_sql_serverContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_login_sql_server(s) + } +} + +func (s *Alter_login_sql_serverContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_login_sql_server(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_login_sql_server() (localctx IAlter_login_sql_serverContext) { + localctx = NewAlter_login_sql_serverContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 330, TSqlParserRULE_alter_login_sql_server) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4170) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4171) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4172) + + var _x = p.Id_() + + localctx.(*Alter_login_sql_serverContext).login_name = _x + } + p.SetState(4240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 405, p.GetParserRuleContext()) { + case 1: + p.SetState(4174) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 392, p.GetParserRuleContext()) == 1 { + { + p.SetState(4173) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISABLE || _la == TSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(4176) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4190) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 395, p.GetParserRuleContext()) == 1 { + { + p.SetState(4177) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4178) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(4179) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_login_sql_serverContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserBINARY: + { + p.SetState(4180) + + var _m = p.Match(TSqlParserBINARY) + + localctx.(*Alter_login_sql_serverContext).password_hash = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4181) + p.Match(TSqlParserHASHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 394, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4184) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserMUST_CHANGE || _la == TSqlParserUNLOCK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(4189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 394, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4201) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 397, p.GetParserRuleContext()) == 1 { + { + p.SetState(4192) + p.Match(TSqlParserOLD_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4193) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4194) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_login_sql_serverContext).old_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 396, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4195) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserMUST_CHANGE || _la == TSqlParserUNLOCK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(4200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 396, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4206) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 398, p.GetParserRuleContext()) == 1 { + { + p.SetState(4203) + p.Match(TSqlParserDEFAULT_DATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4204) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4205) + + var _x = p.Id_() + + localctx.(*Alter_login_sql_serverContext).default_database = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4211) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 399, p.GetParserRuleContext()) == 1 { + { + p.SetState(4208) + p.Match(TSqlParserDEFAULT_LANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4209) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4210) + + var _x = p.Id_() + + localctx.(*Alter_login_sql_serverContext).default_laguage = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4216) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 400, p.GetParserRuleContext()) == 1 { + { + p.SetState(4213) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4214) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4215) + + var _x = p.Id_() + + localctx.(*Alter_login_sql_serverContext).login_name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4221) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 401, p.GetParserRuleContext()) == 1 { + { + p.SetState(4218) + p.Match(TSqlParserCHECK_POLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4219) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4220) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4226) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 402, p.GetParserRuleContext()) == 1 { + { + p.SetState(4223) + p.Match(TSqlParserCHECK_EXPIRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4224) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4225) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4231) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 403, p.GetParserRuleContext()) == 1 { + { + p.SetState(4228) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4229) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4230) + + var _x = p.Id_() + + localctx.(*Alter_login_sql_serverContext).credential_name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4235) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 404, p.GetParserRuleContext()) == 1 { + { + p.SetState(4233) + p.Match(TSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4234) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + { + p.SetState(4237) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserADD || _la == TSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4238) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4239) + + var _x = p.Id_() + + localctx.(*Alter_login_sql_serverContext).credential_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_login_sql_serverContext is an interface to support dynamic dispatch. +type ICreate_login_sql_serverContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // GetPassword_hash returns the password_hash token. + GetPassword_hash() antlr.Token + + // GetSid returns the sid token. + GetSid() antlr.Token + + // GetDefault_language returns the default_language token. + GetDefault_language() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // SetPassword_hash sets the password_hash token. + SetPassword_hash(antlr.Token) + + // SetSid sets the sid token. + SetSid(antlr.Token) + + // SetDefault_language sets the default_language token. + SetDefault_language(antlr.Token) + + // GetLogin_name returns the login_name rule contexts. + GetLogin_name() IId_Context + + // GetDefault_database returns the default_database rule contexts. + GetDefault_database() IId_Context + + // GetDefault_laguage returns the default_laguage rule contexts. + GetDefault_laguage() IId_Context + + // GetCredential_name returns the credential_name rule contexts. + GetCredential_name() IId_Context + + // GetCertname returns the certname rule contexts. + GetCertname() IId_Context + + // GetAsym_key_name returns the asym_key_name rule contexts. + GetAsym_key_name() IId_Context + + // SetLogin_name sets the login_name rule contexts. + SetLogin_name(IId_Context) + + // SetDefault_database sets the default_database rule contexts. + SetDefault_database(IId_Context) + + // SetDefault_laguage sets the default_laguage rule contexts. + SetDefault_laguage(IId_Context) + + // SetCredential_name sets the credential_name rule contexts. + SetCredential_name(IId_Context) + + // SetCertname sets the certname rule contexts. + SetCertname(IId_Context) + + // SetAsym_key_name sets the asym_key_name rule contexts. + SetAsym_key_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + LOGIN() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + WITH() antlr.TerminalNode + FROM() antlr.TerminalNode + SID() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + DEFAULT_DATABASE() antlr.TerminalNode + DEFAULT_LANGUAGE() antlr.TerminalNode + CHECK_EXPIRATION() antlr.TerminalNode + CHECK_POLICY() antlr.TerminalNode + CREDENTIAL() antlr.TerminalNode + AllBINARY() []antlr.TerminalNode + BINARY(i int) antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllOFF() []antlr.TerminalNode + OFF(i int) antlr.TerminalNode + WINDOWS() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + ASYMMETRIC() antlr.TerminalNode + KEY() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + HASHED() antlr.TerminalNode + AllMUST_CHANGE() []antlr.TerminalNode + MUST_CHANGE(i int) antlr.TerminalNode + AllUNLOCK() []antlr.TerminalNode + UNLOCK(i int) antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsCreate_login_sql_serverContext differentiates from other interfaces. + IsCreate_login_sql_serverContext() +} + +type Create_login_sql_serverContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + login_name IId_Context + password antlr.Token + password_hash antlr.Token + sid antlr.Token + default_database IId_Context + default_laguage IId_Context + credential_name IId_Context + default_language antlr.Token + certname IId_Context + asym_key_name IId_Context +} + +func NewEmptyCreate_login_sql_serverContext() *Create_login_sql_serverContext { + var p = new(Create_login_sql_serverContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_login_sql_server + return p +} + +func InitEmptyCreate_login_sql_serverContext(p *Create_login_sql_serverContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_login_sql_server +} + +func (*Create_login_sql_serverContext) IsCreate_login_sql_serverContext() {} + +func NewCreate_login_sql_serverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_login_sql_serverContext { + var p = new(Create_login_sql_serverContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_login_sql_server + + return p +} + +func (s *Create_login_sql_serverContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_login_sql_serverContext) GetPassword() antlr.Token { return s.password } + +func (s *Create_login_sql_serverContext) GetPassword_hash() antlr.Token { return s.password_hash } + +func (s *Create_login_sql_serverContext) GetSid() antlr.Token { return s.sid } + +func (s *Create_login_sql_serverContext) GetDefault_language() antlr.Token { return s.default_language } + +func (s *Create_login_sql_serverContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Create_login_sql_serverContext) SetPassword_hash(v antlr.Token) { s.password_hash = v } + +func (s *Create_login_sql_serverContext) SetSid(v antlr.Token) { s.sid = v } + +func (s *Create_login_sql_serverContext) SetDefault_language(v antlr.Token) { s.default_language = v } + +func (s *Create_login_sql_serverContext) GetLogin_name() IId_Context { return s.login_name } + +func (s *Create_login_sql_serverContext) GetDefault_database() IId_Context { return s.default_database } + +func (s *Create_login_sql_serverContext) GetDefault_laguage() IId_Context { return s.default_laguage } + +func (s *Create_login_sql_serverContext) GetCredential_name() IId_Context { return s.credential_name } + +func (s *Create_login_sql_serverContext) GetCertname() IId_Context { return s.certname } + +func (s *Create_login_sql_serverContext) GetAsym_key_name() IId_Context { return s.asym_key_name } + +func (s *Create_login_sql_serverContext) SetLogin_name(v IId_Context) { s.login_name = v } + +func (s *Create_login_sql_serverContext) SetDefault_database(v IId_Context) { s.default_database = v } + +func (s *Create_login_sql_serverContext) SetDefault_laguage(v IId_Context) { s.default_laguage = v } + +func (s *Create_login_sql_serverContext) SetCredential_name(v IId_Context) { s.credential_name = v } + +func (s *Create_login_sql_serverContext) SetCertname(v IId_Context) { s.certname = v } + +func (s *Create_login_sql_serverContext) SetAsym_key_name(v IId_Context) { s.asym_key_name = v } + +func (s *Create_login_sql_serverContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_login_sql_serverContext) LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, 0) +} + +func (s *Create_login_sql_serverContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_login_sql_serverContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_login_sql_serverContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_login_sql_serverContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Create_login_sql_serverContext) SID() antlr.TerminalNode { + return s.GetToken(TSqlParserSID, 0) +} + +func (s *Create_login_sql_serverContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_login_sql_serverContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_login_sql_serverContext) DEFAULT_DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_DATABASE, 0) +} + +func (s *Create_login_sql_serverContext) DEFAULT_LANGUAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_LANGUAGE, 0) +} + +func (s *Create_login_sql_serverContext) CHECK_EXPIRATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECK_EXPIRATION, 0) +} + +func (s *Create_login_sql_serverContext) CHECK_POLICY() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECK_POLICY, 0) +} + +func (s *Create_login_sql_serverContext) CREDENTIAL() antlr.TerminalNode { + return s.GetToken(TSqlParserCREDENTIAL, 0) +} + +func (s *Create_login_sql_serverContext) AllBINARY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBINARY) +} + +func (s *Create_login_sql_serverContext) BINARY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY, i) +} + +func (s *Create_login_sql_serverContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Create_login_sql_serverContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Create_login_sql_serverContext) AllOFF() []antlr.TerminalNode { + return s.GetTokens(TSqlParserOFF) +} + +func (s *Create_login_sql_serverContext) OFF(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, i) +} + +func (s *Create_login_sql_serverContext) WINDOWS() antlr.TerminalNode { + return s.GetToken(TSqlParserWINDOWS, 0) +} + +func (s *Create_login_sql_serverContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Create_login_sql_serverContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, 0) +} + +func (s *Create_login_sql_serverContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Create_login_sql_serverContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Create_login_sql_serverContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_login_sql_serverContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_login_sql_serverContext) HASHED() antlr.TerminalNode { + return s.GetToken(TSqlParserHASHED, 0) +} + +func (s *Create_login_sql_serverContext) AllMUST_CHANGE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMUST_CHANGE) +} + +func (s *Create_login_sql_serverContext) MUST_CHANGE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMUST_CHANGE, i) +} + +func (s *Create_login_sql_serverContext) AllUNLOCK() []antlr.TerminalNode { + return s.GetTokens(TSqlParserUNLOCK) +} + +func (s *Create_login_sql_serverContext) UNLOCK(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserUNLOCK, i) +} + +func (s *Create_login_sql_serverContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_login_sql_serverContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_login_sql_serverContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_login_sql_serverContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_login_sql_server(s) + } +} + +func (s *Create_login_sql_serverContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_login_sql_server(s) + } +} + +func (s *Create_login_sql_serverContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_login_sql_server(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_login_sql_server() (localctx ICreate_login_sql_serverContext) { + localctx = NewCreate_login_sql_serverContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 332, TSqlParserRULE_create_login_sql_server) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4242) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4243) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4244) + + var _x = p.Id_() + + localctx.(*Create_login_sql_serverContext).login_name = _x + } + p.SetState(4335) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserWITH: + { + p.SetState(4245) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4259) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 408, p.GetParserRuleContext()) == 1 { + { + p.SetState(4246) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4247) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4251) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(4248) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_login_sql_serverContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserBINARY: + { + p.SetState(4249) + + var _m = p.Match(TSqlParserBINARY) + + localctx.(*Create_login_sql_serverContext).password_hash = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4250) + p.Match(TSqlParserHASHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 407, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4253) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserMUST_CHANGE || _la == TSqlParserUNLOCK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(4258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 407, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4267) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 410, p.GetParserRuleContext()) == 1 { + p.SetState(4262) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4261) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4264) + p.Match(TSqlParserSID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4265) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4266) + + var _m = p.Match(TSqlParserBINARY) + + localctx.(*Create_login_sql_serverContext).sid = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4275) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 412, p.GetParserRuleContext()) == 1 { + p.SetState(4270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4269) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4272) + p.Match(TSqlParserDEFAULT_DATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4273) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4274) + + var _x = p.Id_() + + localctx.(*Create_login_sql_serverContext).default_database = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4283) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 414, p.GetParserRuleContext()) == 1 { + p.SetState(4278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4277) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4280) + p.Match(TSqlParserDEFAULT_LANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4281) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4282) + + var _x = p.Id_() + + localctx.(*Create_login_sql_serverContext).default_laguage = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4291) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 416, p.GetParserRuleContext()) == 1 { + p.SetState(4286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4285) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4288) + p.Match(TSqlParserCHECK_EXPIRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4289) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4290) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4299) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 418, p.GetParserRuleContext()) == 1 { + p.SetState(4294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4293) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4296) + p.Match(TSqlParserCHECK_POLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4297) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4298) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4307) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 420, p.GetParserRuleContext()) == 1 { + p.SetState(4302) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4301) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4304) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4305) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4306) + + var _x = p.Id_() + + localctx.(*Create_login_sql_serverContext).credential_name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserFROM: + { + p.SetState(4309) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4333) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserWINDOWS: + { + p.SetState(4310) + p.Match(TSqlParserWINDOWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(4311) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4318) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 422, p.GetParserRuleContext()) == 1 { + p.SetState(4313) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4312) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4315) + p.Match(TSqlParserDEFAULT_DATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4316) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4317) + + var _x = p.Id_() + + localctx.(*Create_login_sql_serverContext).default_database = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4326) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 424, p.GetParserRuleContext()) == 1 { + p.SetState(4321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4320) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4323) + p.Match(TSqlParserDEFAULT_LANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4324) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4325) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_login_sql_serverContext).default_language = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserCERTIFICATE: + { + p.SetState(4328) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4329) + + var _x = p.Id_() + + localctx.(*Create_login_sql_serverContext).certname = _x + } + + case TSqlParserASYMMETRIC: + { + p.SetState(4330) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4331) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4332) + + var _x = p.Id_() + + localctx.(*Create_login_sql_serverContext).asym_key_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_login_azure_sqlContext is an interface to support dynamic dispatch. +type IAlter_login_azure_sqlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // GetOld_password returns the old_password token. + GetOld_password() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // SetOld_password sets the old_password token. + SetOld_password(antlr.Token) + + // GetLogin_name returns the login_name rule contexts. + GetLogin_name() IId_Context + + // SetLogin_name sets the login_name rule contexts. + SetLogin_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + LOGIN() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + WITH() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + NAME() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + OLD_PASSWORD() antlr.TerminalNode + + // IsAlter_login_azure_sqlContext differentiates from other interfaces. + IsAlter_login_azure_sqlContext() +} + +type Alter_login_azure_sqlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + login_name IId_Context + password antlr.Token + old_password antlr.Token +} + +func NewEmptyAlter_login_azure_sqlContext() *Alter_login_azure_sqlContext { + var p = new(Alter_login_azure_sqlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_login_azure_sql + return p +} + +func InitEmptyAlter_login_azure_sqlContext(p *Alter_login_azure_sqlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_login_azure_sql +} + +func (*Alter_login_azure_sqlContext) IsAlter_login_azure_sqlContext() {} + +func NewAlter_login_azure_sqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_login_azure_sqlContext { + var p = new(Alter_login_azure_sqlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_login_azure_sql + + return p +} + +func (s *Alter_login_azure_sqlContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_login_azure_sqlContext) GetPassword() antlr.Token { return s.password } + +func (s *Alter_login_azure_sqlContext) GetOld_password() antlr.Token { return s.old_password } + +func (s *Alter_login_azure_sqlContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Alter_login_azure_sqlContext) SetOld_password(v antlr.Token) { s.old_password = v } + +func (s *Alter_login_azure_sqlContext) GetLogin_name() IId_Context { return s.login_name } + +func (s *Alter_login_azure_sqlContext) SetLogin_name(v IId_Context) { s.login_name = v } + +func (s *Alter_login_azure_sqlContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_login_azure_sqlContext) LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, 0) +} + +func (s *Alter_login_azure_sqlContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_login_azure_sqlContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_login_azure_sqlContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_login_azure_sqlContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Alter_login_azure_sqlContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_login_azure_sqlContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_login_azure_sqlContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *Alter_login_azure_sqlContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Alter_login_azure_sqlContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Alter_login_azure_sqlContext) ENABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserENABLE, 0) +} + +func (s *Alter_login_azure_sqlContext) DISABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLE, 0) +} + +func (s *Alter_login_azure_sqlContext) OLD_PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserOLD_PASSWORD, 0) +} + +func (s *Alter_login_azure_sqlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_login_azure_sqlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_login_azure_sqlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_login_azure_sql(s) + } +} + +func (s *Alter_login_azure_sqlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_login_azure_sql(s) + } +} + +func (s *Alter_login_azure_sqlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_login_azure_sql(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_login_azure_sql() (localctx IAlter_login_azure_sqlContext) { + localctx = NewAlter_login_azure_sqlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 334, TSqlParserRULE_alter_login_azure_sql) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4337) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4338) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4339) + + var _x = p.Id_() + + localctx.(*Alter_login_azure_sqlContext).login_name = _x + } + p.SetState(4357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 430, p.GetParserRuleContext()) { + case 1: + p.SetState(4341) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 427, p.GetParserRuleContext()) == 1 { + { + p.SetState(4340) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISABLE || _la == TSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(4343) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPASSWORD: + { + p.SetState(4344) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4345) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4346) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_login_azure_sqlContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4350) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 428, p.GetParserRuleContext()) == 1 { + { + p.SetState(4347) + p.Match(TSqlParserOLD_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4348) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4349) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_login_azure_sqlContext).old_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserNAME: + { + p.SetState(4352) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4353) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4354) + + var _x = p.Id_() + + localctx.(*Alter_login_azure_sqlContext).login_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_login_azure_sqlContext is an interface to support dynamic dispatch. +type ICreate_login_azure_sqlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSid returns the sid token. + GetSid() antlr.Token + + // SetSid sets the sid token. + SetSid(antlr.Token) + + // GetLogin_name returns the login_name rule contexts. + GetLogin_name() IId_Context + + // SetLogin_name sets the login_name rule contexts. + SetLogin_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + LOGIN() antlr.TerminalNode + WITH() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + STRING() antlr.TerminalNode + Id_() IId_Context + SID() antlr.TerminalNode + BINARY() antlr.TerminalNode + + // IsCreate_login_azure_sqlContext differentiates from other interfaces. + IsCreate_login_azure_sqlContext() +} + +type Create_login_azure_sqlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + login_name IId_Context + sid antlr.Token +} + +func NewEmptyCreate_login_azure_sqlContext() *Create_login_azure_sqlContext { + var p = new(Create_login_azure_sqlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_login_azure_sql + return p +} + +func InitEmptyCreate_login_azure_sqlContext(p *Create_login_azure_sqlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_login_azure_sql +} + +func (*Create_login_azure_sqlContext) IsCreate_login_azure_sqlContext() {} + +func NewCreate_login_azure_sqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_login_azure_sqlContext { + var p = new(Create_login_azure_sqlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_login_azure_sql + + return p +} + +func (s *Create_login_azure_sqlContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_login_azure_sqlContext) GetSid() antlr.Token { return s.sid } + +func (s *Create_login_azure_sqlContext) SetSid(v antlr.Token) { s.sid = v } + +func (s *Create_login_azure_sqlContext) GetLogin_name() IId_Context { return s.login_name } + +func (s *Create_login_azure_sqlContext) SetLogin_name(v IId_Context) { s.login_name = v } + +func (s *Create_login_azure_sqlContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_login_azure_sqlContext) LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, 0) +} + +func (s *Create_login_azure_sqlContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_login_azure_sqlContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Create_login_azure_sqlContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_login_azure_sqlContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_login_azure_sqlContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_login_azure_sqlContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_login_azure_sqlContext) SID() antlr.TerminalNode { + return s.GetToken(TSqlParserSID, 0) +} + +func (s *Create_login_azure_sqlContext) BINARY() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY, 0) +} + +func (s *Create_login_azure_sqlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_login_azure_sqlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_login_azure_sqlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_login_azure_sql(s) + } +} + +func (s *Create_login_azure_sqlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_login_azure_sql(s) + } +} + +func (s *Create_login_azure_sqlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_login_azure_sql(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_login_azure_sql() (localctx ICreate_login_azure_sqlContext) { + localctx = NewCreate_login_azure_sqlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 336, TSqlParserRULE_create_login_azure_sql) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4359) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4360) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4361) + + var _x = p.Id_() + + localctx.(*Create_login_azure_sqlContext).login_name = _x + } + { + p.SetState(4362) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4363) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4364) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4365) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4369) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 431, p.GetParserRuleContext()) == 1 { + { + p.SetState(4366) + p.Match(TSqlParserSID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4367) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4368) + + var _m = p.Match(TSqlParserBINARY) + + localctx.(*Create_login_azure_sqlContext).sid = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_login_azure_sql_dw_and_pdwContext is an interface to support dynamic dispatch. +type IAlter_login_azure_sql_dw_and_pdwContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // GetOld_password returns the old_password token. + GetOld_password() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // SetOld_password sets the old_password token. + SetOld_password(antlr.Token) + + // GetLogin_name returns the login_name rule contexts. + GetLogin_name() IId_Context + + // SetLogin_name sets the login_name rule contexts. + SetLogin_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + LOGIN() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + WITH() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + NAME() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + OLD_PASSWORD() antlr.TerminalNode + AllMUST_CHANGE() []antlr.TerminalNode + MUST_CHANGE(i int) antlr.TerminalNode + AllUNLOCK() []antlr.TerminalNode + UNLOCK(i int) antlr.TerminalNode + + // IsAlter_login_azure_sql_dw_and_pdwContext differentiates from other interfaces. + IsAlter_login_azure_sql_dw_and_pdwContext() +} + +type Alter_login_azure_sql_dw_and_pdwContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + login_name IId_Context + password antlr.Token + old_password antlr.Token +} + +func NewEmptyAlter_login_azure_sql_dw_and_pdwContext() *Alter_login_azure_sql_dw_and_pdwContext { + var p = new(Alter_login_azure_sql_dw_and_pdwContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_login_azure_sql_dw_and_pdw + return p +} + +func InitEmptyAlter_login_azure_sql_dw_and_pdwContext(p *Alter_login_azure_sql_dw_and_pdwContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_login_azure_sql_dw_and_pdw +} + +func (*Alter_login_azure_sql_dw_and_pdwContext) IsAlter_login_azure_sql_dw_and_pdwContext() {} + +func NewAlter_login_azure_sql_dw_and_pdwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_login_azure_sql_dw_and_pdwContext { + var p = new(Alter_login_azure_sql_dw_and_pdwContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_login_azure_sql_dw_and_pdw + + return p +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_login_azure_sql_dw_and_pdwContext) GetPassword() antlr.Token { return s.password } + +func (s *Alter_login_azure_sql_dw_and_pdwContext) GetOld_password() antlr.Token { + return s.old_password +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Alter_login_azure_sql_dw_and_pdwContext) SetOld_password(v antlr.Token) { s.old_password = v } + +func (s *Alter_login_azure_sql_dw_and_pdwContext) GetLogin_name() IId_Context { return s.login_name } + +func (s *Alter_login_azure_sql_dw_and_pdwContext) SetLogin_name(v IId_Context) { s.login_name = v } + +func (s *Alter_login_azure_sql_dw_and_pdwContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, 0) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) ENABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserENABLE, 0) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) DISABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLE, 0) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) OLD_PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserOLD_PASSWORD, 0) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) AllMUST_CHANGE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMUST_CHANGE) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) MUST_CHANGE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMUST_CHANGE, i) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) AllUNLOCK() []antlr.TerminalNode { + return s.GetTokens(TSqlParserUNLOCK) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) UNLOCK(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserUNLOCK, i) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_login_azure_sql_dw_and_pdw(s) + } +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_login_azure_sql_dw_and_pdw(s) + } +} + +func (s *Alter_login_azure_sql_dw_and_pdwContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_login_azure_sql_dw_and_pdw(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_login_azure_sql_dw_and_pdw() (localctx IAlter_login_azure_sql_dw_and_pdwContext) { + localctx = NewAlter_login_azure_sql_dw_and_pdwContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 338, TSqlParserRULE_alter_login_azure_sql_dw_and_pdw) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4371) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4372) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4373) + + var _x = p.Id_() + + localctx.(*Alter_login_azure_sql_dw_and_pdwContext).login_name = _x + } + p.SetState(4397) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 436, p.GetParserRuleContext()) { + case 1: + p.SetState(4375) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 432, p.GetParserRuleContext()) == 1 { + { + p.SetState(4374) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISABLE || _la == TSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(4377) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4395) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPASSWORD: + { + p.SetState(4378) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4379) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4380) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_login_azure_sql_dw_and_pdwContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4390) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 434, p.GetParserRuleContext()) == 1 { + { + p.SetState(4381) + p.Match(TSqlParserOLD_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4382) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4383) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_login_azure_sql_dw_and_pdwContext).old_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4387) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 433, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4384) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserMUST_CHANGE || _la == TSqlParserUNLOCK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(4389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 433, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserNAME: + { + p.SetState(4392) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4393) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4394) + + var _x = p.Id_() + + localctx.(*Alter_login_azure_sql_dw_and_pdwContext).login_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_login_pdwContext is an interface to support dynamic dispatch. +type ICreate_login_pdwContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // GetLoginName returns the loginName rule contexts. + GetLoginName() IId_Context + + // SetLoginName sets the loginName rule contexts. + SetLoginName(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + LOGIN() antlr.TerminalNode + Id_() IId_Context + WITH() antlr.TerminalNode + FROM() antlr.TerminalNode + WINDOWS() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + STRING() antlr.TerminalNode + MUST_CHANGE() antlr.TerminalNode + CHECK_POLICY() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsCreate_login_pdwContext differentiates from other interfaces. + IsCreate_login_pdwContext() +} + +type Create_login_pdwContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + loginName IId_Context + password antlr.Token +} + +func NewEmptyCreate_login_pdwContext() *Create_login_pdwContext { + var p = new(Create_login_pdwContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_login_pdw + return p +} + +func InitEmptyCreate_login_pdwContext(p *Create_login_pdwContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_login_pdw +} + +func (*Create_login_pdwContext) IsCreate_login_pdwContext() {} + +func NewCreate_login_pdwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_login_pdwContext { + var p = new(Create_login_pdwContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_login_pdw + + return p +} + +func (s *Create_login_pdwContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_login_pdwContext) GetPassword() antlr.Token { return s.password } + +func (s *Create_login_pdwContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Create_login_pdwContext) GetLoginName() IId_Context { return s.loginName } + +func (s *Create_login_pdwContext) SetLoginName(v IId_Context) { s.loginName = v } + +func (s *Create_login_pdwContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_login_pdwContext) LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, 0) +} + +func (s *Create_login_pdwContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_login_pdwContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_login_pdwContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Create_login_pdwContext) WINDOWS() antlr.TerminalNode { + return s.GetToken(TSqlParserWINDOWS, 0) +} + +func (s *Create_login_pdwContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Create_login_pdwContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_login_pdwContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_login_pdwContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_login_pdwContext) MUST_CHANGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMUST_CHANGE, 0) +} + +func (s *Create_login_pdwContext) CHECK_POLICY() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECK_POLICY, 0) +} + +func (s *Create_login_pdwContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Create_login_pdwContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Create_login_pdwContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_login_pdwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_login_pdwContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_login_pdw(s) + } +} + +func (s *Create_login_pdwContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_login_pdw(s) + } +} + +func (s *Create_login_pdwContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_login_pdw(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_login_pdw() (localctx ICreate_login_pdwContext) { + localctx = NewCreate_login_pdwContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 340, TSqlParserRULE_create_login_pdw) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4399) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4400) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4401) + + var _x = p.Id_() + + localctx.(*Create_login_pdwContext).loginName = _x + } + p.SetState(4418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserWITH: + { + p.SetState(4402) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(4403) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4404) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4405) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_login_pdwContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4407) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 437, p.GetParserRuleContext()) == 1 { + { + p.SetState(4406) + p.Match(TSqlParserMUST_CHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4414) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 439, p.GetParserRuleContext()) == 1 { + { + p.SetState(4409) + p.Match(TSqlParserCHECK_POLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4410) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4412) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOFF || _la == TSqlParserON { + { + p.SetState(4411) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserFROM: + { + p.SetState(4416) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4417) + p.Match(TSqlParserWINDOWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_master_key_sql_serverContext is an interface to support dynamic dispatch. +type IAlter_master_key_sql_serverContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // GetEncryption_password returns the encryption_password token. + GetEncryption_password() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // SetEncryption_password sets the encryption_password token. + SetEncryption_password(antlr.Token) + + // Getter signatures + ALTER() antlr.TerminalNode + AllMASTER() []antlr.TerminalNode + MASTER(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + REGENERATE() antlr.TerminalNode + WITH() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + BY() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + EQUAL() antlr.TerminalNode + STRING() antlr.TerminalNode + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + SERVICE() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsAlter_master_key_sql_serverContext differentiates from other interfaces. + IsAlter_master_key_sql_serverContext() +} + +type Alter_master_key_sql_serverContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + password antlr.Token + encryption_password antlr.Token +} + +func NewEmptyAlter_master_key_sql_serverContext() *Alter_master_key_sql_serverContext { + var p = new(Alter_master_key_sql_serverContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_master_key_sql_server + return p +} + +func InitEmptyAlter_master_key_sql_serverContext(p *Alter_master_key_sql_serverContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_master_key_sql_server +} + +func (*Alter_master_key_sql_serverContext) IsAlter_master_key_sql_serverContext() {} + +func NewAlter_master_key_sql_serverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_master_key_sql_serverContext { + var p = new(Alter_master_key_sql_serverContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_master_key_sql_server + + return p +} + +func (s *Alter_master_key_sql_serverContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_master_key_sql_serverContext) GetPassword() antlr.Token { return s.password } + +func (s *Alter_master_key_sql_serverContext) GetEncryption_password() antlr.Token { + return s.encryption_password +} + +func (s *Alter_master_key_sql_serverContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Alter_master_key_sql_serverContext) SetEncryption_password(v antlr.Token) { + s.encryption_password = v +} + +func (s *Alter_master_key_sql_serverContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_master_key_sql_serverContext) AllMASTER() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMASTER) +} + +func (s *Alter_master_key_sql_serverContext) MASTER(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, i) +} + +func (s *Alter_master_key_sql_serverContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserKEY) +} + +func (s *Alter_master_key_sql_serverContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, i) +} + +func (s *Alter_master_key_sql_serverContext) REGENERATE() antlr.TerminalNode { + return s.GetToken(TSqlParserREGENERATE, 0) +} + +func (s *Alter_master_key_sql_serverContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_master_key_sql_serverContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Alter_master_key_sql_serverContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Alter_master_key_sql_serverContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Alter_master_key_sql_serverContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_master_key_sql_serverContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Alter_master_key_sql_serverContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_master_key_sql_serverContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Alter_master_key_sql_serverContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *Alter_master_key_sql_serverContext) FORCE() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCE, 0) +} + +func (s *Alter_master_key_sql_serverContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_master_key_sql_serverContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_master_key_sql_serverContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_master_key_sql_server(s) + } +} + +func (s *Alter_master_key_sql_serverContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_master_key_sql_server(s) + } +} + +func (s *Alter_master_key_sql_serverContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_master_key_sql_server(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_master_key_sql_server() (localctx IAlter_master_key_sql_serverContext) { + localctx = NewAlter_master_key_sql_serverContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 342, TSqlParserRULE_alter_master_key_sql_server) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4420) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4421) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4422) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4444) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFORCE, TSqlParserREGENERATE: + p.SetState(4424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFORCE { + { + p.SetState(4423) + p.Match(TSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4426) + p.Match(TSqlParserREGENERATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4427) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4428) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4429) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4430) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4431) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4432) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_master_key_sql_serverContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserADD, TSqlParserDROP: + { + p.SetState(4433) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserADD || _la == TSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4434) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4435) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSERVICE: + { + p.SetState(4436) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4437) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4438) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPASSWORD: + { + p.SetState(4439) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4440) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4441) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_master_key_sql_serverContext).encryption_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_master_key_sql_serverContext is an interface to support dynamic dispatch. +type ICreate_master_key_sql_serverContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // Getter signatures + CREATE() antlr.TerminalNode + MASTER() antlr.TerminalNode + KEY() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + BY() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + EQUAL() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsCreate_master_key_sql_serverContext differentiates from other interfaces. + IsCreate_master_key_sql_serverContext() +} + +type Create_master_key_sql_serverContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + password antlr.Token +} + +func NewEmptyCreate_master_key_sql_serverContext() *Create_master_key_sql_serverContext { + var p = new(Create_master_key_sql_serverContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_master_key_sql_server + return p +} + +func InitEmptyCreate_master_key_sql_serverContext(p *Create_master_key_sql_serverContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_master_key_sql_server +} + +func (*Create_master_key_sql_serverContext) IsCreate_master_key_sql_serverContext() {} + +func NewCreate_master_key_sql_serverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_master_key_sql_serverContext { + var p = new(Create_master_key_sql_serverContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_master_key_sql_server + + return p +} + +func (s *Create_master_key_sql_serverContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_master_key_sql_serverContext) GetPassword() antlr.Token { return s.password } + +func (s *Create_master_key_sql_serverContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Create_master_key_sql_serverContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_master_key_sql_serverContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *Create_master_key_sql_serverContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Create_master_key_sql_serverContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Create_master_key_sql_serverContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Create_master_key_sql_serverContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Create_master_key_sql_serverContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_master_key_sql_serverContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_master_key_sql_serverContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_master_key_sql_serverContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_master_key_sql_serverContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_master_key_sql_server(s) + } +} + +func (s *Create_master_key_sql_serverContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_master_key_sql_server(s) + } +} + +func (s *Create_master_key_sql_serverContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_master_key_sql_server(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_master_key_sql_server() (localctx ICreate_master_key_sql_serverContext) { + localctx = NewCreate_master_key_sql_serverContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 344, TSqlParserRULE_create_master_key_sql_server) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4446) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4447) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4448) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4449) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4450) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4451) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4452) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4453) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_master_key_sql_serverContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_master_key_azure_sqlContext is an interface to support dynamic dispatch. +type IAlter_master_key_azure_sqlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // GetEncryption_password returns the encryption_password token. + GetEncryption_password() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // SetEncryption_password sets the encryption_password token. + SetEncryption_password(antlr.Token) + + // Getter signatures + ALTER() antlr.TerminalNode + AllMASTER() []antlr.TerminalNode + MASTER(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + REGENERATE() antlr.TerminalNode + WITH() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + BY() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + EQUAL() antlr.TerminalNode + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + STRING() antlr.TerminalNode + SERVICE() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsAlter_master_key_azure_sqlContext differentiates from other interfaces. + IsAlter_master_key_azure_sqlContext() +} + +type Alter_master_key_azure_sqlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + password antlr.Token + encryption_password antlr.Token +} + +func NewEmptyAlter_master_key_azure_sqlContext() *Alter_master_key_azure_sqlContext { + var p = new(Alter_master_key_azure_sqlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_master_key_azure_sql + return p +} + +func InitEmptyAlter_master_key_azure_sqlContext(p *Alter_master_key_azure_sqlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_master_key_azure_sql +} + +func (*Alter_master_key_azure_sqlContext) IsAlter_master_key_azure_sqlContext() {} + +func NewAlter_master_key_azure_sqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_master_key_azure_sqlContext { + var p = new(Alter_master_key_azure_sqlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_master_key_azure_sql + + return p +} + +func (s *Alter_master_key_azure_sqlContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_master_key_azure_sqlContext) GetPassword() antlr.Token { return s.password } + +func (s *Alter_master_key_azure_sqlContext) GetEncryption_password() antlr.Token { + return s.encryption_password +} + +func (s *Alter_master_key_azure_sqlContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Alter_master_key_azure_sqlContext) SetEncryption_password(v antlr.Token) { + s.encryption_password = v +} + +func (s *Alter_master_key_azure_sqlContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_master_key_azure_sqlContext) AllMASTER() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMASTER) +} + +func (s *Alter_master_key_azure_sqlContext) MASTER(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, i) +} + +func (s *Alter_master_key_azure_sqlContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserKEY) +} + +func (s *Alter_master_key_azure_sqlContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, i) +} + +func (s *Alter_master_key_azure_sqlContext) REGENERATE() antlr.TerminalNode { + return s.GetToken(TSqlParserREGENERATE, 0) +} + +func (s *Alter_master_key_azure_sqlContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_master_key_azure_sqlContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Alter_master_key_azure_sqlContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Alter_master_key_azure_sqlContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Alter_master_key_azure_sqlContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_master_key_azure_sqlContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_master_key_azure_sqlContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Alter_master_key_azure_sqlContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Alter_master_key_azure_sqlContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *Alter_master_key_azure_sqlContext) FORCE() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCE, 0) +} + +func (s *Alter_master_key_azure_sqlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_master_key_azure_sqlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_master_key_azure_sqlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_master_key_azure_sql(s) + } +} + +func (s *Alter_master_key_azure_sqlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_master_key_azure_sql(s) + } +} + +func (s *Alter_master_key_azure_sqlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_master_key_azure_sql(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_master_key_azure_sql() (localctx IAlter_master_key_azure_sqlContext) { + localctx = NewAlter_master_key_azure_sqlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 346, TSqlParserRULE_alter_master_key_azure_sql) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4455) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4456) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4457) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4485) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFORCE, TSqlParserREGENERATE: + p.SetState(4459) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFORCE { + { + p.SetState(4458) + p.Match(TSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4461) + p.Match(TSqlParserREGENERATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4462) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4463) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4464) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4465) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4466) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4467) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_master_key_azure_sqlContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserADD: + { + p.SetState(4468) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4469) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4470) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSERVICE: + { + p.SetState(4471) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4472) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4473) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPASSWORD: + { + p.SetState(4474) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4475) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4476) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_master_key_azure_sqlContext).encryption_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserDROP: + { + p.SetState(4479) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4480) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4481) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4482) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4483) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4484) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_master_key_azure_sqlContext).encryption_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_master_key_azure_sqlContext is an interface to support dynamic dispatch. +type ICreate_master_key_azure_sqlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // Getter signatures + CREATE() antlr.TerminalNode + MASTER() antlr.TerminalNode + KEY() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + BY() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + EQUAL() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsCreate_master_key_azure_sqlContext differentiates from other interfaces. + IsCreate_master_key_azure_sqlContext() +} + +type Create_master_key_azure_sqlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + password antlr.Token +} + +func NewEmptyCreate_master_key_azure_sqlContext() *Create_master_key_azure_sqlContext { + var p = new(Create_master_key_azure_sqlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_master_key_azure_sql + return p +} + +func InitEmptyCreate_master_key_azure_sqlContext(p *Create_master_key_azure_sqlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_master_key_azure_sql +} + +func (*Create_master_key_azure_sqlContext) IsCreate_master_key_azure_sqlContext() {} + +func NewCreate_master_key_azure_sqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_master_key_azure_sqlContext { + var p = new(Create_master_key_azure_sqlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_master_key_azure_sql + + return p +} + +func (s *Create_master_key_azure_sqlContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_master_key_azure_sqlContext) GetPassword() antlr.Token { return s.password } + +func (s *Create_master_key_azure_sqlContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Create_master_key_azure_sqlContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_master_key_azure_sqlContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *Create_master_key_azure_sqlContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Create_master_key_azure_sqlContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Create_master_key_azure_sqlContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Create_master_key_azure_sqlContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Create_master_key_azure_sqlContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_master_key_azure_sqlContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_master_key_azure_sqlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_master_key_azure_sqlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_master_key_azure_sqlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_master_key_azure_sql(s) + } +} + +func (s *Create_master_key_azure_sqlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_master_key_azure_sql(s) + } +} + +func (s *Create_master_key_azure_sqlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_master_key_azure_sql(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_master_key_azure_sql() (localctx ICreate_master_key_azure_sqlContext) { + localctx = NewCreate_master_key_azure_sqlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 348, TSqlParserRULE_create_master_key_azure_sql) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4487) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4488) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4489) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4495) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 447, p.GetParserRuleContext()) == 1 { + { + p.SetState(4490) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4491) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4492) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4493) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4494) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_master_key_azure_sqlContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_message_typeContext is an interface to support dynamic dispatch. +type IAlter_message_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMessage_type_name returns the message_type_name rule contexts. + GetMessage_type_name() IId_Context + + // GetSchema_collection_name returns the schema_collection_name rule contexts. + GetSchema_collection_name() IId_Context + + // SetMessage_type_name sets the message_type_name rule contexts. + SetMessage_type_name(IId_Context) + + // SetSchema_collection_name sets the schema_collection_name rule contexts. + SetSchema_collection_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + MESSAGE() antlr.TerminalNode + TYPE() antlr.TerminalNode + VALIDATION() antlr.TerminalNode + EQUAL() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + NONE() antlr.TerminalNode + EMPTY() antlr.TerminalNode + WELL_FORMED_XML() antlr.TerminalNode + VALID_XML() antlr.TerminalNode + WITH() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + COLLECTION() antlr.TerminalNode + + // IsAlter_message_typeContext differentiates from other interfaces. + IsAlter_message_typeContext() +} + +type Alter_message_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + message_type_name IId_Context + schema_collection_name IId_Context +} + +func NewEmptyAlter_message_typeContext() *Alter_message_typeContext { + var p = new(Alter_message_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_message_type + return p +} + +func InitEmptyAlter_message_typeContext(p *Alter_message_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_message_type +} + +func (*Alter_message_typeContext) IsAlter_message_typeContext() {} + +func NewAlter_message_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_message_typeContext { + var p = new(Alter_message_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_message_type + + return p +} + +func (s *Alter_message_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_message_typeContext) GetMessage_type_name() IId_Context { return s.message_type_name } + +func (s *Alter_message_typeContext) GetSchema_collection_name() IId_Context { + return s.schema_collection_name +} + +func (s *Alter_message_typeContext) SetMessage_type_name(v IId_Context) { s.message_type_name = v } + +func (s *Alter_message_typeContext) SetSchema_collection_name(v IId_Context) { + s.schema_collection_name = v +} + +func (s *Alter_message_typeContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_message_typeContext) MESSAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE, 0) +} + +func (s *Alter_message_typeContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *Alter_message_typeContext) VALIDATION() antlr.TerminalNode { + return s.GetToken(TSqlParserVALIDATION, 0) +} + +func (s *Alter_message_typeContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_message_typeContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_message_typeContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_message_typeContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Alter_message_typeContext) EMPTY() antlr.TerminalNode { + return s.GetToken(TSqlParserEMPTY, 0) +} + +func (s *Alter_message_typeContext) WELL_FORMED_XML() antlr.TerminalNode { + return s.GetToken(TSqlParserWELL_FORMED_XML, 0) +} + +func (s *Alter_message_typeContext) VALID_XML() antlr.TerminalNode { + return s.GetToken(TSqlParserVALID_XML, 0) +} + +func (s *Alter_message_typeContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_message_typeContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Alter_message_typeContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLECTION, 0) +} + +func (s *Alter_message_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_message_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_message_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_message_type(s) + } +} + +func (s *Alter_message_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_message_type(s) + } +} + +func (s *Alter_message_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_message_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_message_type() (localctx IAlter_message_typeContext) { + localctx = NewAlter_message_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 350, TSqlParserRULE_alter_message_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4497) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4498) + p.Match(TSqlParserMESSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4499) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4500) + + var _x = p.Id_() + + localctx.(*Alter_message_typeContext).message_type_name = _x + } + { + p.SetState(4501) + p.Match(TSqlParserVALIDATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4502) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4511) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserNONE: + { + p.SetState(4503) + p.Match(TSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEMPTY: + { + p.SetState(4504) + p.Match(TSqlParserEMPTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserWELL_FORMED_XML: + { + p.SetState(4505) + p.Match(TSqlParserWELL_FORMED_XML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserVALID_XML: + { + p.SetState(4506) + p.Match(TSqlParserVALID_XML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4507) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4508) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4509) + p.Match(TSqlParserCOLLECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4510) + + var _x = p.Id_() + + localctx.(*Alter_message_typeContext).schema_collection_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_partition_functionContext is an interface to support dynamic dispatch. +type IAlter_partition_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartition_function_name returns the partition_function_name rule contexts. + GetPartition_function_name() IId_Context + + // SetPartition_function_name sets the partition_function_name rule contexts. + SetPartition_function_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + PARTITION() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + RANGE() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + Id_() IId_Context + SPLIT() antlr.TerminalNode + MERGE() antlr.TerminalNode + + // IsAlter_partition_functionContext differentiates from other interfaces. + IsAlter_partition_functionContext() +} + +type Alter_partition_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partition_function_name IId_Context +} + +func NewEmptyAlter_partition_functionContext() *Alter_partition_functionContext { + var p = new(Alter_partition_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_partition_function + return p +} + +func InitEmptyAlter_partition_functionContext(p *Alter_partition_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_partition_function +} + +func (*Alter_partition_functionContext) IsAlter_partition_functionContext() {} + +func NewAlter_partition_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_partition_functionContext { + var p = new(Alter_partition_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_partition_function + + return p +} + +func (s *Alter_partition_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_partition_functionContext) GetPartition_function_name() IId_Context { + return s.partition_function_name +} + +func (s *Alter_partition_functionContext) SetPartition_function_name(v IId_Context) { + s.partition_function_name = v +} + +func (s *Alter_partition_functionContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_partition_functionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITION, 0) +} + +func (s *Alter_partition_functionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(TSqlParserFUNCTION, 0) +} + +func (s *Alter_partition_functionContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Alter_partition_functionContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Alter_partition_functionContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Alter_partition_functionContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Alter_partition_functionContext) RANGE() antlr.TerminalNode { + return s.GetToken(TSqlParserRANGE, 0) +} + +func (s *Alter_partition_functionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Alter_partition_functionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_partition_functionContext) SPLIT() antlr.TerminalNode { + return s.GetToken(TSqlParserSPLIT, 0) +} + +func (s *Alter_partition_functionContext) MERGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMERGE, 0) +} + +func (s *Alter_partition_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_partition_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_partition_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_partition_function(s) + } +} + +func (s *Alter_partition_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_partition_function(s) + } +} + +func (s *Alter_partition_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_partition_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_partition_function() (localctx IAlter_partition_functionContext) { + localctx = NewAlter_partition_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 352, TSqlParserRULE_alter_partition_function) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4513) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4514) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4515) + p.Match(TSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4516) + + var _x = p.Id_() + + localctx.(*Alter_partition_functionContext).partition_function_name = _x + } + { + p.SetState(4517) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4518) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4519) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserMERGE || _la == TSqlParserSPLIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4520) + p.Match(TSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4521) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4522) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4523) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_partition_schemeContext is an interface to support dynamic dispatch. +type IAlter_partition_schemeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartition_scheme_name returns the partition_scheme_name rule contexts. + GetPartition_scheme_name() IId_Context + + // GetFile_group_name returns the file_group_name rule contexts. + GetFile_group_name() IId_Context + + // SetPartition_scheme_name sets the partition_scheme_name rule contexts. + SetPartition_scheme_name(IId_Context) + + // SetFile_group_name sets the file_group_name rule contexts. + SetFile_group_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + PARTITION() antlr.TerminalNode + SCHEME() antlr.TerminalNode + NEXT() antlr.TerminalNode + USED() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + + // IsAlter_partition_schemeContext differentiates from other interfaces. + IsAlter_partition_schemeContext() +} + +type Alter_partition_schemeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partition_scheme_name IId_Context + file_group_name IId_Context +} + +func NewEmptyAlter_partition_schemeContext() *Alter_partition_schemeContext { + var p = new(Alter_partition_schemeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_partition_scheme + return p +} + +func InitEmptyAlter_partition_schemeContext(p *Alter_partition_schemeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_partition_scheme +} + +func (*Alter_partition_schemeContext) IsAlter_partition_schemeContext() {} + +func NewAlter_partition_schemeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_partition_schemeContext { + var p = new(Alter_partition_schemeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_partition_scheme + + return p +} + +func (s *Alter_partition_schemeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_partition_schemeContext) GetPartition_scheme_name() IId_Context { + return s.partition_scheme_name +} + +func (s *Alter_partition_schemeContext) GetFile_group_name() IId_Context { return s.file_group_name } + +func (s *Alter_partition_schemeContext) SetPartition_scheme_name(v IId_Context) { + s.partition_scheme_name = v +} + +func (s *Alter_partition_schemeContext) SetFile_group_name(v IId_Context) { s.file_group_name = v } + +func (s *Alter_partition_schemeContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_partition_schemeContext) PARTITION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITION, 0) +} + +func (s *Alter_partition_schemeContext) SCHEME() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEME, 0) +} + +func (s *Alter_partition_schemeContext) NEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserNEXT, 0) +} + +func (s *Alter_partition_schemeContext) USED() antlr.TerminalNode { + return s.GetToken(TSqlParserUSED, 0) +} + +func (s *Alter_partition_schemeContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_partition_schemeContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_partition_schemeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_partition_schemeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_partition_schemeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_partition_scheme(s) + } +} + +func (s *Alter_partition_schemeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_partition_scheme(s) + } +} + +func (s *Alter_partition_schemeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_partition_scheme(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_partition_scheme() (localctx IAlter_partition_schemeContext) { + localctx = NewAlter_partition_schemeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 354, TSqlParserRULE_alter_partition_scheme) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4525) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4526) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4527) + p.Match(TSqlParserSCHEME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4528) + + var _x = p.Id_() + + localctx.(*Alter_partition_schemeContext).partition_scheme_name = _x + } + { + p.SetState(4529) + p.Match(TSqlParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4530) + p.Match(TSqlParserUSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4532) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 449, p.GetParserRuleContext()) == 1 { + { + p.SetState(4531) + + var _x = p.Id_() + + localctx.(*Alter_partition_schemeContext).file_group_name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_remote_service_bindingContext is an interface to support dynamic dispatch. +type IAlter_remote_service_bindingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBinding_name returns the binding_name rule contexts. + GetBinding_name() IId_Context + + // GetUser_name returns the user_name rule contexts. + GetUser_name() IId_Context + + // SetBinding_name sets the binding_name rule contexts. + SetBinding_name(IId_Context) + + // SetUser_name sets the user_name rule contexts. + SetUser_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + REMOTE() antlr.TerminalNode + SERVICE() antlr.TerminalNode + BINDING() antlr.TerminalNode + WITH() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + USER() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + ANONYMOUS() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsAlter_remote_service_bindingContext differentiates from other interfaces. + IsAlter_remote_service_bindingContext() +} + +type Alter_remote_service_bindingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + binding_name IId_Context + user_name IId_Context +} + +func NewEmptyAlter_remote_service_bindingContext() *Alter_remote_service_bindingContext { + var p = new(Alter_remote_service_bindingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_remote_service_binding + return p +} + +func InitEmptyAlter_remote_service_bindingContext(p *Alter_remote_service_bindingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_remote_service_binding +} + +func (*Alter_remote_service_bindingContext) IsAlter_remote_service_bindingContext() {} + +func NewAlter_remote_service_bindingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_remote_service_bindingContext { + var p = new(Alter_remote_service_bindingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_remote_service_binding + + return p +} + +func (s *Alter_remote_service_bindingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_remote_service_bindingContext) GetBinding_name() IId_Context { return s.binding_name } + +func (s *Alter_remote_service_bindingContext) GetUser_name() IId_Context { return s.user_name } + +func (s *Alter_remote_service_bindingContext) SetBinding_name(v IId_Context) { s.binding_name = v } + +func (s *Alter_remote_service_bindingContext) SetUser_name(v IId_Context) { s.user_name = v } + +func (s *Alter_remote_service_bindingContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_remote_service_bindingContext) REMOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOTE, 0) +} + +func (s *Alter_remote_service_bindingContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *Alter_remote_service_bindingContext) BINDING() antlr.TerminalNode { + return s.GetToken(TSqlParserBINDING, 0) +} + +func (s *Alter_remote_service_bindingContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_remote_service_bindingContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_remote_service_bindingContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_remote_service_bindingContext) USER() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER, 0) +} + +func (s *Alter_remote_service_bindingContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_remote_service_bindingContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_remote_service_bindingContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Alter_remote_service_bindingContext) ANONYMOUS() antlr.TerminalNode { + return s.GetToken(TSqlParserANONYMOUS, 0) +} + +func (s *Alter_remote_service_bindingContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Alter_remote_service_bindingContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Alter_remote_service_bindingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_remote_service_bindingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_remote_service_bindingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_remote_service_binding(s) + } +} + +func (s *Alter_remote_service_bindingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_remote_service_binding(s) + } +} + +func (s *Alter_remote_service_bindingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_remote_service_binding(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_remote_service_binding() (localctx IAlter_remote_service_bindingContext) { + localctx = NewAlter_remote_service_bindingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 356, TSqlParserRULE_alter_remote_service_binding) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4534) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4535) + p.Match(TSqlParserREMOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4536) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4537) + p.Match(TSqlParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4538) + + var _x = p.Id_() + + localctx.(*Alter_remote_service_bindingContext).binding_name = _x + } + { + p.SetState(4539) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4543) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserUSER { + { + p.SetState(4540) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4541) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4542) + + var _x = p.Id_() + + localctx.(*Alter_remote_service_bindingContext).user_name = _x + } + + } + p.SetState(4549) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4545) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4546) + p.Match(TSqlParserANONYMOUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4547) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4548) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_remote_service_bindingContext is an interface to support dynamic dispatch. +type ICreate_remote_service_bindingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRemote_service_name returns the remote_service_name token. + GetRemote_service_name() antlr.Token + + // SetRemote_service_name sets the remote_service_name token. + SetRemote_service_name(antlr.Token) + + // GetBinding_name returns the binding_name rule contexts. + GetBinding_name() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // GetUser_name returns the user_name rule contexts. + GetUser_name() IId_Context + + // SetBinding_name sets the binding_name rule contexts. + SetBinding_name(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // SetUser_name sets the user_name rule contexts. + SetUser_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + REMOTE() antlr.TerminalNode + AllSERVICE() []antlr.TerminalNode + SERVICE(i int) antlr.TerminalNode + BINDING() antlr.TerminalNode + TO() antlr.TerminalNode + WITH() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + STRING() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + USER() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + ANONYMOUS() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsCreate_remote_service_bindingContext differentiates from other interfaces. + IsCreate_remote_service_bindingContext() +} + +type Create_remote_service_bindingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + binding_name IId_Context + owner_name IId_Context + remote_service_name antlr.Token + user_name IId_Context +} + +func NewEmptyCreate_remote_service_bindingContext() *Create_remote_service_bindingContext { + var p = new(Create_remote_service_bindingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_remote_service_binding + return p +} + +func InitEmptyCreate_remote_service_bindingContext(p *Create_remote_service_bindingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_remote_service_binding +} + +func (*Create_remote_service_bindingContext) IsCreate_remote_service_bindingContext() {} + +func NewCreate_remote_service_bindingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_remote_service_bindingContext { + var p = new(Create_remote_service_bindingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_remote_service_binding + + return p +} + +func (s *Create_remote_service_bindingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_remote_service_bindingContext) GetRemote_service_name() antlr.Token { + return s.remote_service_name +} + +func (s *Create_remote_service_bindingContext) SetRemote_service_name(v antlr.Token) { + s.remote_service_name = v +} + +func (s *Create_remote_service_bindingContext) GetBinding_name() IId_Context { return s.binding_name } + +func (s *Create_remote_service_bindingContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Create_remote_service_bindingContext) GetUser_name() IId_Context { return s.user_name } + +func (s *Create_remote_service_bindingContext) SetBinding_name(v IId_Context) { s.binding_name = v } + +func (s *Create_remote_service_bindingContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Create_remote_service_bindingContext) SetUser_name(v IId_Context) { s.user_name = v } + +func (s *Create_remote_service_bindingContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_remote_service_bindingContext) REMOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOTE, 0) +} + +func (s *Create_remote_service_bindingContext) AllSERVICE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSERVICE) +} + +func (s *Create_remote_service_bindingContext) SERVICE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, i) +} + +func (s *Create_remote_service_bindingContext) BINDING() antlr.TerminalNode { + return s.GetToken(TSqlParserBINDING, 0) +} + +func (s *Create_remote_service_bindingContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Create_remote_service_bindingContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_remote_service_bindingContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_remote_service_bindingContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_remote_service_bindingContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_remote_service_bindingContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_remote_service_bindingContext) USER() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER, 0) +} + +func (s *Create_remote_service_bindingContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_remote_service_bindingContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_remote_service_bindingContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Create_remote_service_bindingContext) ANONYMOUS() antlr.TerminalNode { + return s.GetToken(TSqlParserANONYMOUS, 0) +} + +func (s *Create_remote_service_bindingContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Create_remote_service_bindingContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Create_remote_service_bindingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_remote_service_bindingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_remote_service_bindingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_remote_service_binding(s) + } +} + +func (s *Create_remote_service_bindingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_remote_service_binding(s) + } +} + +func (s *Create_remote_service_bindingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_remote_service_binding(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_remote_service_binding() (localctx ICreate_remote_service_bindingContext) { + localctx = NewCreate_remote_service_bindingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 358, TSqlParserRULE_create_remote_service_binding) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4551) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4552) + p.Match(TSqlParserREMOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4553) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4554) + p.Match(TSqlParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4555) + + var _x = p.Id_() + + localctx.(*Create_remote_service_bindingContext).binding_name = _x + } + p.SetState(4558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(4556) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4557) + + var _x = p.Id_() + + localctx.(*Create_remote_service_bindingContext).owner_name = _x + } + + } + { + p.SetState(4560) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4561) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4562) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_remote_service_bindingContext).remote_service_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4563) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserUSER { + { + p.SetState(4564) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4565) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4566) + + var _x = p.Id_() + + localctx.(*Create_remote_service_bindingContext).user_name = _x + } + + } + p.SetState(4573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4569) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4570) + p.Match(TSqlParserANONYMOUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4571) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4572) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_resource_poolContext is an interface to support dynamic dispatch. +type ICreate_resource_poolContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPool_name returns the pool_name rule contexts. + GetPool_name() IId_Context + + // SetPool_name sets the pool_name rule contexts. + SetPool_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + POOL() antlr.TerminalNode + Id_() IId_Context + WITH() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + MIN_CPU_PERCENT() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + MAX_CPU_PERCENT() antlr.TerminalNode + CAP_CPU_PERCENT() antlr.TerminalNode + AFFINITY() antlr.TerminalNode + SCHEDULER() antlr.TerminalNode + MIN_MEMORY_PERCENT() antlr.TerminalNode + MAX_MEMORY_PERCENT() antlr.TerminalNode + MIN_IOPS_PER_VOLUME() antlr.TerminalNode + MAX_IOPS_PER_VOLUME() antlr.TerminalNode + AUTO() antlr.TerminalNode + NUMANODE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + + // IsCreate_resource_poolContext differentiates from other interfaces. + IsCreate_resource_poolContext() +} + +type Create_resource_poolContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + pool_name IId_Context +} + +func NewEmptyCreate_resource_poolContext() *Create_resource_poolContext { + var p = new(Create_resource_poolContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_resource_pool + return p +} + +func InitEmptyCreate_resource_poolContext(p *Create_resource_poolContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_resource_pool +} + +func (*Create_resource_poolContext) IsCreate_resource_poolContext() {} + +func NewCreate_resource_poolContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_resource_poolContext { + var p = new(Create_resource_poolContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_resource_pool + + return p +} + +func (s *Create_resource_poolContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_resource_poolContext) GetPool_name() IId_Context { return s.pool_name } + +func (s *Create_resource_poolContext) SetPool_name(v IId_Context) { s.pool_name = v } + +func (s *Create_resource_poolContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_resource_poolContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESOURCE, 0) +} + +func (s *Create_resource_poolContext) POOL() antlr.TerminalNode { + return s.GetToken(TSqlParserPOOL, 0) +} + +func (s *Create_resource_poolContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_resource_poolContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_resource_poolContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Create_resource_poolContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Create_resource_poolContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Create_resource_poolContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Create_resource_poolContext) MIN_CPU_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserMIN_CPU_PERCENT, 0) +} + +func (s *Create_resource_poolContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_resource_poolContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_resource_poolContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Create_resource_poolContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Create_resource_poolContext) MAX_CPU_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_CPU_PERCENT, 0) +} + +func (s *Create_resource_poolContext) CAP_CPU_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserCAP_CPU_PERCENT, 0) +} + +func (s *Create_resource_poolContext) AFFINITY() antlr.TerminalNode { + return s.GetToken(TSqlParserAFFINITY, 0) +} + +func (s *Create_resource_poolContext) SCHEDULER() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEDULER, 0) +} + +func (s *Create_resource_poolContext) MIN_MEMORY_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserMIN_MEMORY_PERCENT, 0) +} + +func (s *Create_resource_poolContext) MAX_MEMORY_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_MEMORY_PERCENT, 0) +} + +func (s *Create_resource_poolContext) MIN_IOPS_PER_VOLUME() antlr.TerminalNode { + return s.GetToken(TSqlParserMIN_IOPS_PER_VOLUME, 0) +} + +func (s *Create_resource_poolContext) MAX_IOPS_PER_VOLUME() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_IOPS_PER_VOLUME, 0) +} + +func (s *Create_resource_poolContext) AUTO() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO, 0) +} + +func (s *Create_resource_poolContext) NUMANODE() antlr.TerminalNode { + return s.GetToken(TSqlParserNUMANODE, 0) +} + +func (s *Create_resource_poolContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_resource_poolContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_resource_poolContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTO) +} + +func (s *Create_resource_poolContext) TO(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTO, i) +} + +func (s *Create_resource_poolContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_resource_poolContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_resource_poolContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_resource_pool(s) + } +} + +func (s *Create_resource_poolContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_resource_pool(s) + } +} + +func (s *Create_resource_poolContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_resource_pool(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_resource_pool() (localctx ICreate_resource_poolContext) { + localctx = NewCreate_resource_poolContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 360, TSqlParserRULE_create_resource_pool) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4575) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4576) + p.Match(TSqlParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4577) + p.Match(TSqlParserPOOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4578) + + var _x = p.Id_() + + localctx.(*Create_resource_poolContext).pool_name = _x + } + p.SetState(4681) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 478, p.GetParserRuleContext()) == 1 { + { + p.SetState(4579) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4580) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4587) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 456, p.GetParserRuleContext()) == 1 { + p.SetState(4582) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4581) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4584) + p.Match(TSqlParserMIN_CPU_PERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4585) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4586) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4595) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 458, p.GetParserRuleContext()) == 1 { + p.SetState(4590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4589) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4592) + p.Match(TSqlParserMAX_CPU_PERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4593) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4594) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4603) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 460, p.GetParserRuleContext()) == 1 { + p.SetState(4598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4597) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4600) + p.Match(TSqlParserCAP_CPU_PERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4601) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4602) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4646) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 469, p.GetParserRuleContext()) == 1 { + p.SetState(4606) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4605) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4608) + p.Match(TSqlParserAFFINITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4609) + p.Match(TSqlParserSCHEDULER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4610) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAUTO: + { + p.SetState(4611) + p.Match(TSqlParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserLR_BRACKET: + { + p.SetState(4612) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4622) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserDECIMAL || _la == TSqlParserCOMMA { + p.SetState(4614) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4613) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4620) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 463, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4616) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(4617) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4618) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4619) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(4624) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4626) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNUMANODE: + { + p.SetState(4627) + p.Match(TSqlParserNUMANODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4628) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4629) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4639) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserDECIMAL || _la == TSqlParserCOMMA { + p.SetState(4631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4630) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 466, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4633) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(4634) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4635) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4636) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(4641) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4643) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4654) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 471, p.GetParserRuleContext()) == 1 { + p.SetState(4649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4648) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4651) + p.Match(TSqlParserMIN_MEMORY_PERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4652) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4653) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4662) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 473, p.GetParserRuleContext()) == 1 { + p.SetState(4657) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4656) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4659) + p.Match(TSqlParserMAX_MEMORY_PERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4660) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4661) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4670) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 475, p.GetParserRuleContext()) == 1 { + p.SetState(4665) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4664) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4667) + p.Match(TSqlParserMIN_IOPS_PER_VOLUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4668) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4669) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4678) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMAX_IOPS_PER_VOLUME || _la == TSqlParserCOMMA { + p.SetState(4673) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4672) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4675) + p.Match(TSqlParserMAX_IOPS_PER_VOLUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4676) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4677) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4680) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_resource_governorContext is an interface to support dynamic dispatch. +type IAlter_resource_governorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMax_outstanding_io_per_volume returns the max_outstanding_io_per_volume token. + GetMax_outstanding_io_per_volume() antlr.Token + + // SetMax_outstanding_io_per_volume sets the max_outstanding_io_per_volume token. + SetMax_outstanding_io_per_volume(antlr.Token) + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetFunction_name returns the function_name rule contexts. + GetFunction_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetFunction_name sets the function_name rule contexts. + SetFunction_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + GOVERNOR() antlr.TerminalNode + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + CLASSIFIER_FUNCTION() antlr.TerminalNode + EQUAL() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + RESET() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + MAX_OUTSTANDING_IO_PER_VOLUME() antlr.TerminalNode + DISABLE() antlr.TerminalNode + RECONFIGURE() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + DOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + + // IsAlter_resource_governorContext differentiates from other interfaces. + IsAlter_resource_governorContext() +} + +type Alter_resource_governorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + function_name IId_Context + max_outstanding_io_per_volume antlr.Token +} + +func NewEmptyAlter_resource_governorContext() *Alter_resource_governorContext { + var p = new(Alter_resource_governorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_resource_governor + return p +} + +func InitEmptyAlter_resource_governorContext(p *Alter_resource_governorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_resource_governor +} + +func (*Alter_resource_governorContext) IsAlter_resource_governorContext() {} + +func NewAlter_resource_governorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_resource_governorContext { + var p = new(Alter_resource_governorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_resource_governor + + return p +} + +func (s *Alter_resource_governorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_resource_governorContext) GetMax_outstanding_io_per_volume() antlr.Token { + return s.max_outstanding_io_per_volume +} + +func (s *Alter_resource_governorContext) SetMax_outstanding_io_per_volume(v antlr.Token) { + s.max_outstanding_io_per_volume = v +} + +func (s *Alter_resource_governorContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Alter_resource_governorContext) GetFunction_name() IId_Context { return s.function_name } + +func (s *Alter_resource_governorContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Alter_resource_governorContext) SetFunction_name(v IId_Context) { s.function_name = v } + +func (s *Alter_resource_governorContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_resource_governorContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESOURCE, 0) +} + +func (s *Alter_resource_governorContext) GOVERNOR() antlr.TerminalNode { + return s.GetToken(TSqlParserGOVERNOR, 0) +} + +func (s *Alter_resource_governorContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_resource_governorContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Alter_resource_governorContext) CLASSIFIER_FUNCTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCLASSIFIER_FUNCTION, 0) +} + +func (s *Alter_resource_governorContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_resource_governorContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Alter_resource_governorContext) RESET() antlr.TerminalNode { + return s.GetToken(TSqlParserRESET, 0) +} + +func (s *Alter_resource_governorContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS, 0) +} + +func (s *Alter_resource_governorContext) MAX_OUTSTANDING_IO_PER_VOLUME() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, 0) +} + +func (s *Alter_resource_governorContext) DISABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLE, 0) +} + +func (s *Alter_resource_governorContext) RECONFIGURE() antlr.TerminalNode { + return s.GetToken(TSqlParserRECONFIGURE, 0) +} + +func (s *Alter_resource_governorContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Alter_resource_governorContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Alter_resource_governorContext) NULL_() antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_, 0) +} + +func (s *Alter_resource_governorContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_resource_governorContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_resource_governorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_resource_governorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_resource_governorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_resource_governor(s) + } +} + +func (s *Alter_resource_governorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_resource_governor(s) + } +} + +func (s *Alter_resource_governorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_resource_governor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_resource_governor() (localctx IAlter_resource_governorContext) { + localctx = NewAlter_resource_governorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 362, TSqlParserRULE_alter_resource_governor) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4683) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4684) + p.Match(TSqlParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4685) + p.Match(TSqlParserGOVERNOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 480, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4686) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISABLE || _la == TSqlParserRECONFIGURE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + { + p.SetState(4687) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4688) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4689) + p.Match(TSqlParserCLASSIFIER_FUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4690) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(4691) + + var _x = p.Id_() + + localctx.(*Alter_resource_governorContext).schema_name = _x + } + { + p.SetState(4692) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4693) + + var _x = p.Id_() + + localctx.(*Alter_resource_governorContext).function_name = _x + } + + case TSqlParserNULL_: + { + p.SetState(4695) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(4698) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(4699) + p.Match(TSqlParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4700) + p.Match(TSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(4701) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4702) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4703) + p.Match(TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4704) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4705) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_resource_governorContext).max_outstanding_io_per_volume = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4706) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_database_audit_specificationContext is an interface to support dynamic dispatch. +type IAlter_database_audit_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAudit_specification_name returns the audit_specification_name rule contexts. + GetAudit_specification_name() IId_Context + + // GetAudit_name returns the audit_name rule contexts. + GetAudit_name() IId_Context + + // SetAudit_specification_name sets the audit_specification_name rule contexts. + SetAudit_specification_name(IId_Context) + + // SetAudit_name sets the audit_name rule contexts. + SetAudit_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + AllAUDIT() []antlr.TerminalNode + AUDIT(i int) antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + FOR() antlr.TerminalNode + SERVER() antlr.TerminalNode + AllAudit_action_spec_group() []IAudit_action_spec_groupContext + Audit_action_spec_group(i int) IAudit_action_spec_groupContext + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + STATE() antlr.TerminalNode + EQUAL() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_database_audit_specificationContext differentiates from other interfaces. + IsAlter_database_audit_specificationContext() +} + +type Alter_database_audit_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + audit_specification_name IId_Context + audit_name IId_Context +} + +func NewEmptyAlter_database_audit_specificationContext() *Alter_database_audit_specificationContext { + var p = new(Alter_database_audit_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_database_audit_specification + return p +} + +func InitEmptyAlter_database_audit_specificationContext(p *Alter_database_audit_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_database_audit_specification +} + +func (*Alter_database_audit_specificationContext) IsAlter_database_audit_specificationContext() {} + +func NewAlter_database_audit_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_database_audit_specificationContext { + var p = new(Alter_database_audit_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_database_audit_specification + + return p +} + +func (s *Alter_database_audit_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_database_audit_specificationContext) GetAudit_specification_name() IId_Context { + return s.audit_specification_name +} + +func (s *Alter_database_audit_specificationContext) GetAudit_name() IId_Context { return s.audit_name } + +func (s *Alter_database_audit_specificationContext) SetAudit_specification_name(v IId_Context) { + s.audit_specification_name = v +} + +func (s *Alter_database_audit_specificationContext) SetAudit_name(v IId_Context) { s.audit_name = v } + +func (s *Alter_database_audit_specificationContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_database_audit_specificationContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Alter_database_audit_specificationContext) AllAUDIT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAUDIT) +} + +func (s *Alter_database_audit_specificationContext) AUDIT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT, i) +} + +func (s *Alter_database_audit_specificationContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserSPECIFICATION, 0) +} + +func (s *Alter_database_audit_specificationContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_database_audit_specificationContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_database_audit_specificationContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Alter_database_audit_specificationContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Alter_database_audit_specificationContext) AllAudit_action_spec_group() []IAudit_action_spec_groupContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAudit_action_spec_groupContext); ok { + len++ + } + } + + tst := make([]IAudit_action_spec_groupContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAudit_action_spec_groupContext); ok { + tst[i] = t.(IAudit_action_spec_groupContext) + i++ + } + } + + return tst +} + +func (s *Alter_database_audit_specificationContext) Audit_action_spec_group(i int) IAudit_action_spec_groupContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_action_spec_groupContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAudit_action_spec_groupContext) +} + +func (s *Alter_database_audit_specificationContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_database_audit_specificationContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Alter_database_audit_specificationContext) STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATE, 0) +} + +func (s *Alter_database_audit_specificationContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_database_audit_specificationContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Alter_database_audit_specificationContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Alter_database_audit_specificationContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Alter_database_audit_specificationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_database_audit_specificationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_database_audit_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_database_audit_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_database_audit_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_database_audit_specification(s) + } +} + +func (s *Alter_database_audit_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_database_audit_specification(s) + } +} + +func (s *Alter_database_audit_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_database_audit_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_database_audit_specification() (localctx IAlter_database_audit_specificationContext) { + localctx = NewAlter_database_audit_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 364, TSqlParserRULE_alter_database_audit_specification) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4709) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4710) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4711) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4712) + p.Match(TSqlParserSPECIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4713) + + var _x = p.Id_() + + localctx.(*Alter_database_audit_specificationContext).audit_specification_name = _x + } + p.SetState(4718) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR { + { + p.SetState(4714) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4715) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4716) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4717) + + var _x = p.Id_() + + localctx.(*Alter_database_audit_specificationContext).audit_name = _x + } + + } + p.SetState(4728) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 483, p.GetParserRuleContext()) == 1 { + { + p.SetState(4720) + p.Audit_action_spec_group() + } + p.SetState(4725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(4721) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4722) + p.Audit_action_spec_group() + } + + p.SetState(4727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4736) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 484, p.GetParserRuleContext()) == 1 { + { + p.SetState(4730) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4731) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4732) + p.Match(TSqlParserSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4733) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4734) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4735) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAudit_action_spec_groupContext is an interface to support dynamic dispatch. +type IAudit_action_spec_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAudit_action_group_name returns the audit_action_group_name rule contexts. + GetAudit_action_group_name() IId_Context + + // SetAudit_action_group_name sets the audit_action_group_name rule contexts. + SetAudit_action_group_name(IId_Context) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + Audit_action_specification() IAudit_action_specificationContext + Id_() IId_Context + + // IsAudit_action_spec_groupContext differentiates from other interfaces. + IsAudit_action_spec_groupContext() +} + +type Audit_action_spec_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + audit_action_group_name IId_Context +} + +func NewEmptyAudit_action_spec_groupContext() *Audit_action_spec_groupContext { + var p = new(Audit_action_spec_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_audit_action_spec_group + return p +} + +func InitEmptyAudit_action_spec_groupContext(p *Audit_action_spec_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_audit_action_spec_group +} + +func (*Audit_action_spec_groupContext) IsAudit_action_spec_groupContext() {} + +func NewAudit_action_spec_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_action_spec_groupContext { + var p = new(Audit_action_spec_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_audit_action_spec_group + + return p +} + +func (s *Audit_action_spec_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_action_spec_groupContext) GetAudit_action_group_name() IId_Context { + return s.audit_action_group_name +} + +func (s *Audit_action_spec_groupContext) SetAudit_action_group_name(v IId_Context) { + s.audit_action_group_name = v +} + +func (s *Audit_action_spec_groupContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Audit_action_spec_groupContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Audit_action_spec_groupContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Audit_action_spec_groupContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Audit_action_spec_groupContext) Audit_action_specification() IAudit_action_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_action_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_action_specificationContext) +} + +func (s *Audit_action_spec_groupContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Audit_action_spec_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_action_spec_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_action_spec_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAudit_action_spec_group(s) + } +} + +func (s *Audit_action_spec_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAudit_action_spec_group(s) + } +} + +func (s *Audit_action_spec_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAudit_action_spec_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Audit_action_spec_group() (localctx IAudit_action_spec_groupContext) { + localctx = NewAudit_action_spec_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 366, TSqlParserRULE_audit_action_spec_group) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4738) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserADD || _la == TSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4739) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 485, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4740) + p.Audit_action_specification() + } + + case 2: + { + p.SetState(4741) + + var _x = p.Id_() + + localctx.(*Audit_action_spec_groupContext).audit_action_group_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(4744) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAudit_action_specificationContext is an interface to support dynamic dispatch. +type IAudit_action_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAction_specification() []IAction_specificationContext + Action_specification(i int) IAction_specificationContext + ON() antlr.TerminalNode + Audit_securable() IAudit_securableContext + BY() antlr.TerminalNode + AllPrincipal_id() []IPrincipal_idContext + Principal_id(i int) IPrincipal_idContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Audit_class_name() IAudit_class_nameContext + DOUBLE_COLON() antlr.TerminalNode + + // IsAudit_action_specificationContext differentiates from other interfaces. + IsAudit_action_specificationContext() +} + +type Audit_action_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_action_specificationContext() *Audit_action_specificationContext { + var p = new(Audit_action_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_audit_action_specification + return p +} + +func InitEmptyAudit_action_specificationContext(p *Audit_action_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_audit_action_specification +} + +func (*Audit_action_specificationContext) IsAudit_action_specificationContext() {} + +func NewAudit_action_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_action_specificationContext { + var p = new(Audit_action_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_audit_action_specification + + return p +} + +func (s *Audit_action_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_action_specificationContext) AllAction_specification() []IAction_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAction_specificationContext); ok { + len++ + } + } + + tst := make([]IAction_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAction_specificationContext); ok { + tst[i] = t.(IAction_specificationContext) + i++ + } + } + + return tst +} + +func (s *Audit_action_specificationContext) Action_specification(i int) IAction_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAction_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAction_specificationContext) +} + +func (s *Audit_action_specificationContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Audit_action_specificationContext) Audit_securable() IAudit_securableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_securableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_securableContext) +} + +func (s *Audit_action_specificationContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Audit_action_specificationContext) AllPrincipal_id() []IPrincipal_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPrincipal_idContext); ok { + len++ + } + } + + tst := make([]IPrincipal_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPrincipal_idContext); ok { + tst[i] = t.(IPrincipal_idContext) + i++ + } + } + + return tst +} + +func (s *Audit_action_specificationContext) Principal_id(i int) IPrincipal_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrincipal_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPrincipal_idContext) +} + +func (s *Audit_action_specificationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Audit_action_specificationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Audit_action_specificationContext) Audit_class_name() IAudit_class_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_class_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_class_nameContext) +} + +func (s *Audit_action_specificationContext) DOUBLE_COLON() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_COLON, 0) +} + +func (s *Audit_action_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_action_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_action_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAudit_action_specification(s) + } +} + +func (s *Audit_action_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAudit_action_specification(s) + } +} + +func (s *Audit_action_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAudit_action_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Audit_action_specification() (localctx IAudit_action_specificationContext) { + localctx = NewAudit_action_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 368, TSqlParserRULE_audit_action_specification) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4746) + p.Action_specification() + } + p.SetState(4751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(4747) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4748) + p.Action_specification() + } + + p.SetState(4753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4754) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4758) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 487, p.GetParserRuleContext()) == 1 { + { + p.SetState(4755) + p.Audit_class_name() + } + { + p.SetState(4756) + p.Match(TSqlParserDOUBLE_COLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4760) + p.Audit_securable() + } + { + p.SetState(4761) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4762) + p.Principal_id() + } + p.SetState(4767) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(4763) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4764) + p.Principal_id() + } + + p.SetState(4769) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAction_specificationContext is an interface to support dynamic dispatch. +type IAction_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + INSERT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + DELETE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + RECEIVE() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + + // IsAction_specificationContext differentiates from other interfaces. + IsAction_specificationContext() +} + +type Action_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAction_specificationContext() *Action_specificationContext { + var p = new(Action_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_action_specification + return p +} + +func InitEmptyAction_specificationContext(p *Action_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_action_specification +} + +func (*Action_specificationContext) IsAction_specificationContext() {} + +func NewAction_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Action_specificationContext { + var p = new(Action_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_action_specification + + return p +} + +func (s *Action_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Action_specificationContext) SELECT() antlr.TerminalNode { + return s.GetToken(TSqlParserSELECT, 0) +} + +func (s *Action_specificationContext) INSERT() antlr.TerminalNode { + return s.GetToken(TSqlParserINSERT, 0) +} + +func (s *Action_specificationContext) UPDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserUPDATE, 0) +} + +func (s *Action_specificationContext) DELETE() antlr.TerminalNode { + return s.GetToken(TSqlParserDELETE, 0) +} + +func (s *Action_specificationContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXECUTE, 0) +} + +func (s *Action_specificationContext) RECEIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserRECEIVE, 0) +} + +func (s *Action_specificationContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(TSqlParserREFERENCES, 0) +} + +func (s *Action_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Action_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Action_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAction_specification(s) + } +} + +func (s *Action_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAction_specification(s) + } +} + +func (s *Action_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAction_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Action_specification() (localctx IAction_specificationContext) { + localctx = NewAction_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 370, TSqlParserRULE_action_specification) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4770) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDELETE || _la == TSqlParserEXECUTE || _la == TSqlParserINSERT || _la == TSqlParserRECEIVE || _la == TSqlParserREFERENCES || _la == TSqlParserSELECT || _la == TSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAudit_class_nameContext is an interface to support dynamic dispatch. +type IAudit_class_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + TABLE() antlr.TerminalNode + + // IsAudit_class_nameContext differentiates from other interfaces. + IsAudit_class_nameContext() +} + +type Audit_class_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_class_nameContext() *Audit_class_nameContext { + var p = new(Audit_class_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_audit_class_name + return p +} + +func InitEmptyAudit_class_nameContext(p *Audit_class_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_audit_class_name +} + +func (*Audit_class_nameContext) IsAudit_class_nameContext() {} + +func NewAudit_class_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_class_nameContext { + var p = new(Audit_class_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_audit_class_name + + return p +} + +func (s *Audit_class_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_class_nameContext) OBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT, 0) +} + +func (s *Audit_class_nameContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Audit_class_nameContext) TABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLE, 0) +} + +func (s *Audit_class_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_class_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_class_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAudit_class_name(s) + } +} + +func (s *Audit_class_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAudit_class_name(s) + } +} + +func (s *Audit_class_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAudit_class_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Audit_class_name() (localctx IAudit_class_nameContext) { + localctx = NewAudit_class_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 372, TSqlParserRULE_audit_class_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4772) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOBJECT || _la == TSqlParserSCHEMA || _la == TSqlParserTABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAudit_securableContext is an interface to support dynamic dispatch. +type IAudit_securableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsAudit_securableContext differentiates from other interfaces. + IsAudit_securableContext() +} + +type Audit_securableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_securableContext() *Audit_securableContext { + var p = new(Audit_securableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_audit_securable + return p +} + +func InitEmptyAudit_securableContext(p *Audit_securableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_audit_securable +} + +func (*Audit_securableContext) IsAudit_securableContext() {} + +func NewAudit_securableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_securableContext { + var p = new(Audit_securableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_audit_securable + + return p +} + +func (s *Audit_securableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_securableContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Audit_securableContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Audit_securableContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Audit_securableContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Audit_securableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_securableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_securableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAudit_securable(s) + } +} + +func (s *Audit_securableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAudit_securable(s) + } +} + +func (s *Audit_securableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAudit_securable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Audit_securable() (localctx IAudit_securableContext) { + localctx = NewAudit_securableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 374, TSqlParserRULE_audit_securable) + p.EnterOuterAlt(localctx, 1) + p.SetState(4782) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 490, p.GetParserRuleContext()) == 1 { + p.SetState(4777) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 489, p.GetParserRuleContext()) == 1 { + { + p.SetState(4774) + p.Id_() + } + { + p.SetState(4775) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4779) + p.Id_() + } + { + p.SetState(4780) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4784) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_db_roleContext is an interface to support dynamic dispatch. +type IAlter_db_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRole_name returns the role_name rule contexts. + GetRole_name() IId_Context + + // GetDatabase_principal returns the database_principal rule contexts. + GetDatabase_principal() IId_Context + + // GetNew_role_name returns the new_role_name rule contexts. + GetNew_role_name() IId_Context + + // SetRole_name sets the role_name rule contexts. + SetRole_name(IId_Context) + + // SetDatabase_principal sets the database_principal rule contexts. + SetDatabase_principal(IId_Context) + + // SetNew_role_name sets the new_role_name rule contexts. + SetNew_role_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + ROLE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + MEMBER() antlr.TerminalNode + WITH() antlr.TerminalNode + NAME() antlr.TerminalNode + EQUAL() antlr.TerminalNode + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsAlter_db_roleContext differentiates from other interfaces. + IsAlter_db_roleContext() +} + +type Alter_db_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + role_name IId_Context + database_principal IId_Context + new_role_name IId_Context +} + +func NewEmptyAlter_db_roleContext() *Alter_db_roleContext { + var p = new(Alter_db_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_db_role + return p +} + +func InitEmptyAlter_db_roleContext(p *Alter_db_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_db_role +} + +func (*Alter_db_roleContext) IsAlter_db_roleContext() {} + +func NewAlter_db_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_db_roleContext { + var p = new(Alter_db_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_db_role + + return p +} + +func (s *Alter_db_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_db_roleContext) GetRole_name() IId_Context { return s.role_name } + +func (s *Alter_db_roleContext) GetDatabase_principal() IId_Context { return s.database_principal } + +func (s *Alter_db_roleContext) GetNew_role_name() IId_Context { return s.new_role_name } + +func (s *Alter_db_roleContext) SetRole_name(v IId_Context) { s.role_name = v } + +func (s *Alter_db_roleContext) SetDatabase_principal(v IId_Context) { s.database_principal = v } + +func (s *Alter_db_roleContext) SetNew_role_name(v IId_Context) { s.new_role_name = v } + +func (s *Alter_db_roleContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_db_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Alter_db_roleContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_db_roleContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_db_roleContext) MEMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserMEMBER, 0) +} + +func (s *Alter_db_roleContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_db_roleContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *Alter_db_roleContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_db_roleContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_db_roleContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Alter_db_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_db_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_db_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_db_role(s) + } +} + +func (s *Alter_db_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_db_role(s) + } +} + +func (s *Alter_db_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_db_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_db_role() (localctx IAlter_db_roleContext) { + localctx = NewAlter_db_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 376, TSqlParserRULE_alter_db_role) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4786) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4787) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4788) + + var _x = p.Id_() + + localctx.(*Alter_db_roleContext).role_name = _x + } + p.SetState(4796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserADD, TSqlParserDROP: + { + p.SetState(4789) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserADD || _la == TSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4790) + p.Match(TSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4791) + + var _x = p.Id_() + + localctx.(*Alter_db_roleContext).database_principal = _x + } + + case TSqlParserWITH: + { + p.SetState(4792) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4793) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4794) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4795) + + var _x = p.Id_() + + localctx.(*Alter_db_roleContext).new_role_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_database_audit_specificationContext is an interface to support dynamic dispatch. +type ICreate_database_audit_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAudit_specification_name returns the audit_specification_name rule contexts. + GetAudit_specification_name() IId_Context + + // GetAudit_name returns the audit_name rule contexts. + GetAudit_name() IId_Context + + // SetAudit_specification_name sets the audit_specification_name rule contexts. + SetAudit_specification_name(IId_Context) + + // SetAudit_name sets the audit_name rule contexts. + SetAudit_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + AllAUDIT() []antlr.TerminalNode + AUDIT(i int) antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + FOR() antlr.TerminalNode + SERVER() antlr.TerminalNode + AllAudit_action_spec_group() []IAudit_action_spec_groupContext + Audit_action_spec_group(i int) IAudit_action_spec_groupContext + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + STATE() antlr.TerminalNode + EQUAL() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_database_audit_specificationContext differentiates from other interfaces. + IsCreate_database_audit_specificationContext() +} + +type Create_database_audit_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + audit_specification_name IId_Context + audit_name IId_Context +} + +func NewEmptyCreate_database_audit_specificationContext() *Create_database_audit_specificationContext { + var p = new(Create_database_audit_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_database_audit_specification + return p +} + +func InitEmptyCreate_database_audit_specificationContext(p *Create_database_audit_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_database_audit_specification +} + +func (*Create_database_audit_specificationContext) IsCreate_database_audit_specificationContext() {} + +func NewCreate_database_audit_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_database_audit_specificationContext { + var p = new(Create_database_audit_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_database_audit_specification + + return p +} + +func (s *Create_database_audit_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_database_audit_specificationContext) GetAudit_specification_name() IId_Context { + return s.audit_specification_name +} + +func (s *Create_database_audit_specificationContext) GetAudit_name() IId_Context { return s.audit_name } + +func (s *Create_database_audit_specificationContext) SetAudit_specification_name(v IId_Context) { + s.audit_specification_name = v +} + +func (s *Create_database_audit_specificationContext) SetAudit_name(v IId_Context) { s.audit_name = v } + +func (s *Create_database_audit_specificationContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_database_audit_specificationContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Create_database_audit_specificationContext) AllAUDIT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAUDIT) +} + +func (s *Create_database_audit_specificationContext) AUDIT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT, i) +} + +func (s *Create_database_audit_specificationContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserSPECIFICATION, 0) +} + +func (s *Create_database_audit_specificationContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_database_audit_specificationContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_database_audit_specificationContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_database_audit_specificationContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Create_database_audit_specificationContext) AllAudit_action_spec_group() []IAudit_action_spec_groupContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAudit_action_spec_groupContext); ok { + len++ + } + } + + tst := make([]IAudit_action_spec_groupContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAudit_action_spec_groupContext); ok { + tst[i] = t.(IAudit_action_spec_groupContext) + i++ + } + } + + return tst +} + +func (s *Create_database_audit_specificationContext) Audit_action_spec_group(i int) IAudit_action_spec_groupContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_action_spec_groupContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAudit_action_spec_groupContext) +} + +func (s *Create_database_audit_specificationContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_database_audit_specificationContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_database_audit_specificationContext) STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATE, 0) +} + +func (s *Create_database_audit_specificationContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_database_audit_specificationContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_database_audit_specificationContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Create_database_audit_specificationContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Create_database_audit_specificationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_database_audit_specificationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_database_audit_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_database_audit_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_database_audit_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_database_audit_specification(s) + } +} + +func (s *Create_database_audit_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_database_audit_specification(s) + } +} + +func (s *Create_database_audit_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_database_audit_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_database_audit_specification() (localctx ICreate_database_audit_specificationContext) { + localctx = NewCreate_database_audit_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 378, TSqlParserRULE_create_database_audit_specification) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4798) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4799) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4800) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4801) + p.Match(TSqlParserSPECIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4802) + + var _x = p.Id_() + + localctx.(*Create_database_audit_specificationContext).audit_specification_name = _x + } + p.SetState(4807) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR { + { + p.SetState(4803) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4804) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4805) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4806) + + var _x = p.Id_() + + localctx.(*Create_database_audit_specificationContext).audit_name = _x + } + + } + p.SetState(4817) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 494, p.GetParserRuleContext()) == 1 { + { + p.SetState(4809) + p.Audit_action_spec_group() + } + p.SetState(4814) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(4810) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4811) + p.Audit_action_spec_group() + } + + p.SetState(4816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4825) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 495, p.GetParserRuleContext()) == 1 { + { + p.SetState(4819) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4820) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4821) + p.Match(TSqlParserSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4822) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4823) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4824) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_db_roleContext is an interface to support dynamic dispatch. +type ICreate_db_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRole_name returns the role_name rule contexts. + GetRole_name() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // SetRole_name sets the role_name rule contexts. + SetRole_name(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + ROLE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AUTHORIZATION() antlr.TerminalNode + + // IsCreate_db_roleContext differentiates from other interfaces. + IsCreate_db_roleContext() +} + +type Create_db_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + role_name IId_Context + owner_name IId_Context +} + +func NewEmptyCreate_db_roleContext() *Create_db_roleContext { + var p = new(Create_db_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_db_role + return p +} + +func InitEmptyCreate_db_roleContext(p *Create_db_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_db_role +} + +func (*Create_db_roleContext) IsCreate_db_roleContext() {} + +func NewCreate_db_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_db_roleContext { + var p = new(Create_db_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_db_role + + return p +} + +func (s *Create_db_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_db_roleContext) GetRole_name() IId_Context { return s.role_name } + +func (s *Create_db_roleContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Create_db_roleContext) SetRole_name(v IId_Context) { s.role_name = v } + +func (s *Create_db_roleContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Create_db_roleContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_db_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Create_db_roleContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_db_roleContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_db_roleContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_db_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_db_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_db_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_db_role(s) + } +} + +func (s *Create_db_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_db_role(s) + } +} + +func (s *Create_db_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_db_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_db_role() (localctx ICreate_db_roleContext) { + localctx = NewCreate_db_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 380, TSqlParserRULE_create_db_role) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4827) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4828) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4829) + + var _x = p.Id_() + + localctx.(*Create_db_roleContext).role_name = _x + } + p.SetState(4832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(4830) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4831) + + var _x = p.Id_() + + localctx.(*Create_db_roleContext).owner_name = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_routeContext is an interface to support dynamic dispatch. +type ICreate_routeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRoute_service_name returns the route_service_name token. + GetRoute_service_name() antlr.Token + + // GetBroker_instance_identifier returns the broker_instance_identifier token. + GetBroker_instance_identifier() antlr.Token + + // SetRoute_service_name sets the route_service_name token. + SetRoute_service_name(antlr.Token) + + // SetBroker_instance_identifier sets the broker_instance_identifier token. + SetBroker_instance_identifier(antlr.Token) + + // GetRoute_name returns the route_name rule contexts. + GetRoute_name() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // SetRoute_name sets the route_name rule contexts. + SetRoute_name(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + ROUTE() antlr.TerminalNode + WITH() antlr.TerminalNode + ADDRESS() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AUTHORIZATION() antlr.TerminalNode + SERVICE_NAME() antlr.TerminalNode + BROKER_INSTANCE() antlr.TerminalNode + LIFETIME() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + MIRROR_ADDRESS() antlr.TerminalNode + + // IsCreate_routeContext differentiates from other interfaces. + IsCreate_routeContext() +} + +type Create_routeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + route_name IId_Context + owner_name IId_Context + route_service_name antlr.Token + broker_instance_identifier antlr.Token +} + +func NewEmptyCreate_routeContext() *Create_routeContext { + var p = new(Create_routeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_route + return p +} + +func InitEmptyCreate_routeContext(p *Create_routeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_route +} + +func (*Create_routeContext) IsCreate_routeContext() {} + +func NewCreate_routeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_routeContext { + var p = new(Create_routeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_route + + return p +} + +func (s *Create_routeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_routeContext) GetRoute_service_name() antlr.Token { return s.route_service_name } + +func (s *Create_routeContext) GetBroker_instance_identifier() antlr.Token { + return s.broker_instance_identifier +} + +func (s *Create_routeContext) SetRoute_service_name(v antlr.Token) { s.route_service_name = v } + +func (s *Create_routeContext) SetBroker_instance_identifier(v antlr.Token) { + s.broker_instance_identifier = v +} + +func (s *Create_routeContext) GetRoute_name() IId_Context { return s.route_name } + +func (s *Create_routeContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Create_routeContext) SetRoute_name(v IId_Context) { s.route_name = v } + +func (s *Create_routeContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Create_routeContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_routeContext) ROUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserROUTE, 0) +} + +func (s *Create_routeContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_routeContext) ADDRESS() antlr.TerminalNode { + return s.GetToken(TSqlParserADDRESS, 0) +} + +func (s *Create_routeContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_routeContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_routeContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Create_routeContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Create_routeContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_routeContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_routeContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_routeContext) SERVICE_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE_NAME, 0) +} + +func (s *Create_routeContext) BROKER_INSTANCE() antlr.TerminalNode { + return s.GetToken(TSqlParserBROKER_INSTANCE, 0) +} + +func (s *Create_routeContext) LIFETIME() antlr.TerminalNode { + return s.GetToken(TSqlParserLIFETIME, 0) +} + +func (s *Create_routeContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Create_routeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_routeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_routeContext) MIRROR_ADDRESS() antlr.TerminalNode { + return s.GetToken(TSqlParserMIRROR_ADDRESS, 0) +} + +func (s *Create_routeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_routeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_routeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_route(s) + } +} + +func (s *Create_routeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_route(s) + } +} + +func (s *Create_routeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_route(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_route() (localctx ICreate_routeContext) { + localctx = NewCreate_routeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 382, TSqlParserRULE_create_route) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4834) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4835) + p.Match(TSqlParserROUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4836) + + var _x = p.Id_() + + localctx.(*Create_routeContext).route_name = _x + } + p.SetState(4839) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(4837) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4838) + + var _x = p.Id_() + + localctx.(*Create_routeContext).owner_name = _x + } + + } + { + p.SetState(4841) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4848) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 499, p.GetParserRuleContext()) == 1 { + p.SetState(4843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4842) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4845) + p.Match(TSqlParserSERVICE_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4846) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4847) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_routeContext).route_service_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4856) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 501, p.GetParserRuleContext()) == 1 { + p.SetState(4851) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4850) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4853) + p.Match(TSqlParserBROKER_INSTANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4854) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4855) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_routeContext).broker_instance_identifier = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4864) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 503, p.GetParserRuleContext()) == 1 { + p.SetState(4859) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4858) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4861) + p.Match(TSqlParserLIFETIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4862) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4863) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4867) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4866) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4869) + p.Match(TSqlParserADDRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4870) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4871) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4876) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4872) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4873) + p.Match(TSqlParserMIRROR_ADDRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4874) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4875) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_ruleContext is an interface to support dynamic dispatch. +type ICreate_ruleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetRule_name returns the rule_name rule contexts. + GetRule_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetRule_name sets the rule_name rule contexts. + SetRule_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + RULE() antlr.TerminalNode + AS() antlr.TerminalNode + Search_condition() ISearch_conditionContext + AllId_() []IId_Context + Id_(i int) IId_Context + DOT() antlr.TerminalNode + + // IsCreate_ruleContext differentiates from other interfaces. + IsCreate_ruleContext() +} + +type Create_ruleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + rule_name IId_Context +} + +func NewEmptyCreate_ruleContext() *Create_ruleContext { + var p = new(Create_ruleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_rule + return p +} + +func InitEmptyCreate_ruleContext(p *Create_ruleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_rule +} + +func (*Create_ruleContext) IsCreate_ruleContext() {} + +func NewCreate_ruleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_ruleContext { + var p = new(Create_ruleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_rule + + return p +} + +func (s *Create_ruleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_ruleContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Create_ruleContext) GetRule_name() IId_Context { return s.rule_name } + +func (s *Create_ruleContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Create_ruleContext) SetRule_name(v IId_Context) { s.rule_name = v } + +func (s *Create_ruleContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_ruleContext) RULE() antlr.TerminalNode { + return s.GetToken(TSqlParserRULE, 0) +} + +func (s *Create_ruleContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Create_ruleContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Create_ruleContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_ruleContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_ruleContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Create_ruleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_ruleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_ruleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_rule(s) + } +} + +func (s *Create_ruleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_rule(s) + } +} + +func (s *Create_ruleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_rule(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_rule() (localctx ICreate_ruleContext) { + localctx = NewCreate_ruleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 384, TSqlParserRULE_create_rule) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4878) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4879) + p.Match(TSqlParserRULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4883) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 506, p.GetParserRuleContext()) == 1 { + { + p.SetState(4880) + + var _x = p.Id_() + + localctx.(*Create_ruleContext).schema_name = _x + } + { + p.SetState(4881) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4885) + + var _x = p.Id_() + + localctx.(*Create_ruleContext).rule_name = _x + } + { + p.SetState(4886) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4887) + p.search_condition(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_schema_sqlContext is an interface to support dynamic dispatch. +type IAlter_schema_sqlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + AllSCHEMA() []antlr.TerminalNode + SCHEMA(i int) antlr.TerminalNode + TRANSFER() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + DOUBLE_COLON() antlr.TerminalNode + DOT() antlr.TerminalNode + OBJECT() antlr.TerminalNode + TYPE() antlr.TerminalNode + XML() antlr.TerminalNode + COLLECTION() antlr.TerminalNode + + // IsAlter_schema_sqlContext differentiates from other interfaces. + IsAlter_schema_sqlContext() +} + +type Alter_schema_sqlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context +} + +func NewEmptyAlter_schema_sqlContext() *Alter_schema_sqlContext { + var p = new(Alter_schema_sqlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_schema_sql + return p +} + +func InitEmptyAlter_schema_sqlContext(p *Alter_schema_sqlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_schema_sql +} + +func (*Alter_schema_sqlContext) IsAlter_schema_sqlContext() {} + +func NewAlter_schema_sqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_schema_sqlContext { + var p = new(Alter_schema_sqlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_schema_sql + + return p +} + +func (s *Alter_schema_sqlContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_schema_sqlContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Alter_schema_sqlContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Alter_schema_sqlContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_schema_sqlContext) AllSCHEMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSCHEMA) +} + +func (s *Alter_schema_sqlContext) SCHEMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, i) +} + +func (s *Alter_schema_sqlContext) TRANSFER() antlr.TerminalNode { + return s.GetToken(TSqlParserTRANSFER, 0) +} + +func (s *Alter_schema_sqlContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_schema_sqlContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_schema_sqlContext) DOUBLE_COLON() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_COLON, 0) +} + +func (s *Alter_schema_sqlContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Alter_schema_sqlContext) OBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT, 0) +} + +func (s *Alter_schema_sqlContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *Alter_schema_sqlContext) XML() antlr.TerminalNode { + return s.GetToken(TSqlParserXML, 0) +} + +func (s *Alter_schema_sqlContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLECTION, 0) +} + +func (s *Alter_schema_sqlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_schema_sqlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_schema_sqlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_schema_sql(s) + } +} + +func (s *Alter_schema_sqlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_schema_sql(s) + } +} + +func (s *Alter_schema_sqlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_schema_sql(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_schema_sql() (localctx IAlter_schema_sqlContext) { + localctx = NewAlter_schema_sqlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 386, TSqlParserRULE_alter_schema_sql) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4889) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4890) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4891) + + var _x = p.Id_() + + localctx.(*Alter_schema_sqlContext).schema_name = _x + } + { + p.SetState(4892) + p.Match(TSqlParserTRANSFER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4901) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 508, p.GetParserRuleContext()) == 1 { + p.SetState(4898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserOBJECT: + { + p.SetState(4893) + p.Match(TSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTYPE: + { + p.SetState(4894) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserXML: + { + p.SetState(4895) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4896) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4897) + p.Match(TSqlParserCOLLECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(4900) + p.Match(TSqlParserDOUBLE_COLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4903) + p.Id_() + } + p.SetState(4906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserDOT { + { + p.SetState(4904) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4905) + p.Id_() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_schemaContext is an interface to support dynamic dispatch. +type ICreate_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // GetObject_name returns the object_name rule contexts. + GetObject_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // SetObject_name sets the object_name rule contexts. + SetObject_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + AllSCHEMA() []antlr.TerminalNode + SCHEMA(i int) antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllCreate_table() []ICreate_tableContext + Create_table(i int) ICreate_tableContext + AllCreate_view() []ICreate_viewContext + Create_view(i int) ICreate_viewContext + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + AllREVOKE() []antlr.TerminalNode + REVOKE(i int) antlr.TerminalNode + AllFROM() []antlr.TerminalNode + FROM(i int) antlr.TerminalNode + AllGRANT() []antlr.TerminalNode + GRANT(i int) antlr.TerminalNode + AllDENY() []antlr.TerminalNode + DENY(i int) antlr.TerminalNode + AllSELECT() []antlr.TerminalNode + SELECT(i int) antlr.TerminalNode + AllINSERT() []antlr.TerminalNode + INSERT(i int) antlr.TerminalNode + AllDELETE() []antlr.TerminalNode + DELETE(i int) antlr.TerminalNode + AllUPDATE() []antlr.TerminalNode + UPDATE(i int) antlr.TerminalNode + AllDOUBLE_COLON() []antlr.TerminalNode + DOUBLE_COLON(i int) antlr.TerminalNode + + // IsCreate_schemaContext differentiates from other interfaces. + IsCreate_schemaContext() +} + +type Create_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + owner_name IId_Context + object_name IId_Context +} + +func NewEmptyCreate_schemaContext() *Create_schemaContext { + var p = new(Create_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_schema + return p +} + +func InitEmptyCreate_schemaContext(p *Create_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_schema +} + +func (*Create_schemaContext) IsCreate_schemaContext() {} + +func NewCreate_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_schemaContext { + var p = new(Create_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_schema + + return p +} + +func (s *Create_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_schemaContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Create_schemaContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Create_schemaContext) GetObject_name() IId_Context { return s.object_name } + +func (s *Create_schemaContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Create_schemaContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Create_schemaContext) SetObject_name(v IId_Context) { s.object_name = v } + +func (s *Create_schemaContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_schemaContext) AllSCHEMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSCHEMA) +} + +func (s *Create_schemaContext) SCHEMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, i) +} + +func (s *Create_schemaContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_schemaContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_schemaContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_schemaContext) AllCreate_table() []ICreate_tableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreate_tableContext); ok { + len++ + } + } + + tst := make([]ICreate_tableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreate_tableContext); ok { + tst[i] = t.(ICreate_tableContext) + i++ + } + } + + return tst +} + +func (s *Create_schemaContext) Create_table(i int) ICreate_tableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_tableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreate_tableContext) +} + +func (s *Create_schemaContext) AllCreate_view() []ICreate_viewContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreate_viewContext); ok { + len++ + } + } + + tst := make([]ICreate_viewContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreate_viewContext); ok { + tst[i] = t.(ICreate_viewContext) + i++ + } + } + + return tst +} + +func (s *Create_schemaContext) Create_view(i int) ICreate_viewContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_viewContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreate_viewContext) +} + +func (s *Create_schemaContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Create_schemaContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Create_schemaContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTO) +} + +func (s *Create_schemaContext) TO(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTO, i) +} + +func (s *Create_schemaContext) AllREVOKE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserREVOKE) +} + +func (s *Create_schemaContext) REVOKE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserREVOKE, i) +} + +func (s *Create_schemaContext) AllFROM() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFROM) +} + +func (s *Create_schemaContext) FROM(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, i) +} + +func (s *Create_schemaContext) AllGRANT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserGRANT) +} + +func (s *Create_schemaContext) GRANT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserGRANT, i) +} + +func (s *Create_schemaContext) AllDENY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDENY) +} + +func (s *Create_schemaContext) DENY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDENY, i) +} + +func (s *Create_schemaContext) AllSELECT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSELECT) +} + +func (s *Create_schemaContext) SELECT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSELECT, i) +} + +func (s *Create_schemaContext) AllINSERT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserINSERT) +} + +func (s *Create_schemaContext) INSERT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserINSERT, i) +} + +func (s *Create_schemaContext) AllDELETE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDELETE) +} + +func (s *Create_schemaContext) DELETE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDELETE, i) +} + +func (s *Create_schemaContext) AllUPDATE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserUPDATE) +} + +func (s *Create_schemaContext) UPDATE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserUPDATE, i) +} + +func (s *Create_schemaContext) AllDOUBLE_COLON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOUBLE_COLON) +} + +func (s *Create_schemaContext) DOUBLE_COLON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_COLON, i) +} + +func (s *Create_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_schema(s) + } +} + +func (s *Create_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_schema(s) + } +} + +func (s *Create_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_schema() (localctx ICreate_schemaContext) { + localctx = NewCreate_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 388, TSqlParserRULE_create_schema) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4908) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4909) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4917) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 510, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4910) + + var _x = p.Id_() + + localctx.(*Create_schemaContext).schema_name = _x + } + + case 2: + { + p.SetState(4911) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4912) + + var _x = p.Id_() + + localctx.(*Create_schemaContext).owner_name = _x + } + + case 3: + { + p.SetState(4913) + + var _x = p.Id_() + + localctx.(*Create_schemaContext).schema_name = _x + } + { + p.SetState(4914) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4915) + + var _x = p.Id_() + + localctx.(*Create_schemaContext).owner_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(4945) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 514, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(4943) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 513, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4919) + p.Create_table() + } + + case 2: + { + p.SetState(4920) + p.Create_view() + } + + case 3: + { + p.SetState(4921) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDENY || _la == TSqlParserGRANT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4922) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDELETE || _la == TSqlParserINSERT || _la == TSqlParserSELECT || _la == TSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4923) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4926) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSCHEMA { + { + p.SetState(4924) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4925) + p.Match(TSqlParserDOUBLE_COLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4928) + + var _x = p.Id_() + + localctx.(*Create_schemaContext).object_name = _x + } + { + p.SetState(4929) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4930) + + var _x = p.Id_() + + localctx.(*Create_schemaContext).owner_name = _x + } + + case 4: + { + p.SetState(4932) + p.Match(TSqlParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4933) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDELETE || _la == TSqlParserINSERT || _la == TSqlParserSELECT || _la == TSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4934) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4937) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSCHEMA { + { + p.SetState(4935) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4936) + p.Match(TSqlParserDOUBLE_COLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4939) + + var _x = p.Id_() + + localctx.(*Create_schemaContext).object_name = _x + } + { + p.SetState(4940) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4941) + + var _x = p.Id_() + + localctx.(*Create_schemaContext).owner_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(4947) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 514, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_schema_azure_sql_dw_and_pdwContext is an interface to support dynamic dispatch. +type ICreate_schema_azure_sql_dw_and_pdwContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AUTHORIZATION() antlr.TerminalNode + + // IsCreate_schema_azure_sql_dw_and_pdwContext differentiates from other interfaces. + IsCreate_schema_azure_sql_dw_and_pdwContext() +} + +type Create_schema_azure_sql_dw_and_pdwContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + owner_name IId_Context +} + +func NewEmptyCreate_schema_azure_sql_dw_and_pdwContext() *Create_schema_azure_sql_dw_and_pdwContext { + var p = new(Create_schema_azure_sql_dw_and_pdwContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_schema_azure_sql_dw_and_pdw + return p +} + +func InitEmptyCreate_schema_azure_sql_dw_and_pdwContext(p *Create_schema_azure_sql_dw_and_pdwContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_schema_azure_sql_dw_and_pdw +} + +func (*Create_schema_azure_sql_dw_and_pdwContext) IsCreate_schema_azure_sql_dw_and_pdwContext() {} + +func NewCreate_schema_azure_sql_dw_and_pdwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_schema_azure_sql_dw_and_pdwContext { + var p = new(Create_schema_azure_sql_dw_and_pdwContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_schema_azure_sql_dw_and_pdw + + return p +} + +func (s *Create_schema_azure_sql_dw_and_pdwContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_schema_azure_sql_dw_and_pdwContext) GetSchema_name() IId_Context { + return s.schema_name +} + +func (s *Create_schema_azure_sql_dw_and_pdwContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Create_schema_azure_sql_dw_and_pdwContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Create_schema_azure_sql_dw_and_pdwContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Create_schema_azure_sql_dw_and_pdwContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_schema_azure_sql_dw_and_pdwContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Create_schema_azure_sql_dw_and_pdwContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_schema_azure_sql_dw_and_pdwContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_schema_azure_sql_dw_and_pdwContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_schema_azure_sql_dw_and_pdwContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_schema_azure_sql_dw_and_pdwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_schema_azure_sql_dw_and_pdwContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_schema_azure_sql_dw_and_pdw(s) + } +} + +func (s *Create_schema_azure_sql_dw_and_pdwContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_schema_azure_sql_dw_and_pdw(s) + } +} + +func (s *Create_schema_azure_sql_dw_and_pdwContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_schema_azure_sql_dw_and_pdw(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_schema_azure_sql_dw_and_pdw() (localctx ICreate_schema_azure_sql_dw_and_pdwContext) { + localctx = NewCreate_schema_azure_sql_dw_and_pdwContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 390, TSqlParserRULE_create_schema_azure_sql_dw_and_pdw) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4948) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4949) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4950) + + var _x = p.Id_() + + localctx.(*Create_schema_azure_sql_dw_and_pdwContext).schema_name = _x + } + p.SetState(4953) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(4951) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4952) + + var _x = p.Id_() + + localctx.(*Create_schema_azure_sql_dw_and_pdwContext).owner_name = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_schema_azure_sql_dw_and_pdwContext is an interface to support dynamic dispatch. +type IAlter_schema_azure_sql_dw_and_pdwContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + TRANSFER() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + OBJECT() antlr.TerminalNode + DOUBLE_COLON() antlr.TerminalNode + DOT() antlr.TerminalNode + ID() antlr.TerminalNode + + // IsAlter_schema_azure_sql_dw_and_pdwContext differentiates from other interfaces. + IsAlter_schema_azure_sql_dw_and_pdwContext() +} + +type Alter_schema_azure_sql_dw_and_pdwContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context +} + +func NewEmptyAlter_schema_azure_sql_dw_and_pdwContext() *Alter_schema_azure_sql_dw_and_pdwContext { + var p = new(Alter_schema_azure_sql_dw_and_pdwContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_schema_azure_sql_dw_and_pdw + return p +} + +func InitEmptyAlter_schema_azure_sql_dw_and_pdwContext(p *Alter_schema_azure_sql_dw_and_pdwContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_schema_azure_sql_dw_and_pdw +} + +func (*Alter_schema_azure_sql_dw_and_pdwContext) IsAlter_schema_azure_sql_dw_and_pdwContext() {} + +func NewAlter_schema_azure_sql_dw_and_pdwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_schema_azure_sql_dw_and_pdwContext { + var p = new(Alter_schema_azure_sql_dw_and_pdwContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_schema_azure_sql_dw_and_pdw + + return p +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) TRANSFER() antlr.TerminalNode { + return s.GetToken(TSqlParserTRANSFER, 0) +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) OBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT, 0) +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) DOUBLE_COLON() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_COLON, 0) +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) ID() antlr.TerminalNode { + return s.GetToken(TSqlParserID, 0) +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_schema_azure_sql_dw_and_pdw(s) + } +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_schema_azure_sql_dw_and_pdw(s) + } +} + +func (s *Alter_schema_azure_sql_dw_and_pdwContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_schema_azure_sql_dw_and_pdw(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_schema_azure_sql_dw_and_pdw() (localctx IAlter_schema_azure_sql_dw_and_pdwContext) { + localctx = NewAlter_schema_azure_sql_dw_and_pdwContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 392, TSqlParserRULE_alter_schema_azure_sql_dw_and_pdw) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4955) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4956) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4957) + + var _x = p.Id_() + + localctx.(*Alter_schema_azure_sql_dw_and_pdwContext).schema_name = _x + } + { + p.SetState(4958) + p.Match(TSqlParserTRANSFER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4961) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 516, p.GetParserRuleContext()) == 1 { + { + p.SetState(4959) + p.Match(TSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4960) + p.Match(TSqlParserDOUBLE_COLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4963) + p.Id_() + } + p.SetState(4966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserDOT { + { + p.SetState(4964) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4965) + p.Match(TSqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_search_property_listContext is an interface to support dynamic dispatch. +type ICreate_search_property_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNew_list_name returns the new_list_name rule contexts. + GetNew_list_name() IId_Context + + // GetDatabase_name returns the database_name rule contexts. + GetDatabase_name() IId_Context + + // GetSource_list_name returns the source_list_name rule contexts. + GetSource_list_name() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // SetNew_list_name sets the new_list_name rule contexts. + SetNew_list_name(IId_Context) + + // SetDatabase_name sets the database_name rule contexts. + SetDatabase_name(IId_Context) + + // SetSource_list_name sets the source_list_name rule contexts. + SetSource_list_name(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + SEARCH() antlr.TerminalNode + PROPERTY() antlr.TerminalNode + LIST() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + FROM() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + DOT() antlr.TerminalNode + + // IsCreate_search_property_listContext differentiates from other interfaces. + IsCreate_search_property_listContext() +} + +type Create_search_property_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + new_list_name IId_Context + database_name IId_Context + source_list_name IId_Context + owner_name IId_Context +} + +func NewEmptyCreate_search_property_listContext() *Create_search_property_listContext { + var p = new(Create_search_property_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_search_property_list + return p +} + +func InitEmptyCreate_search_property_listContext(p *Create_search_property_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_search_property_list +} + +func (*Create_search_property_listContext) IsCreate_search_property_listContext() {} + +func NewCreate_search_property_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_search_property_listContext { + var p = new(Create_search_property_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_search_property_list + + return p +} + +func (s *Create_search_property_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_search_property_listContext) GetNew_list_name() IId_Context { return s.new_list_name } + +func (s *Create_search_property_listContext) GetDatabase_name() IId_Context { return s.database_name } + +func (s *Create_search_property_listContext) GetSource_list_name() IId_Context { + return s.source_list_name +} + +func (s *Create_search_property_listContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Create_search_property_listContext) SetNew_list_name(v IId_Context) { s.new_list_name = v } + +func (s *Create_search_property_listContext) SetDatabase_name(v IId_Context) { s.database_name = v } + +func (s *Create_search_property_listContext) SetSource_list_name(v IId_Context) { + s.source_list_name = v +} + +func (s *Create_search_property_listContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Create_search_property_listContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_search_property_listContext) SEARCH() antlr.TerminalNode { + return s.GetToken(TSqlParserSEARCH, 0) +} + +func (s *Create_search_property_listContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserPROPERTY, 0) +} + +func (s *Create_search_property_listContext) LIST() antlr.TerminalNode { + return s.GetToken(TSqlParserLIST, 0) +} + +func (s *Create_search_property_listContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_search_property_listContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_search_property_listContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Create_search_property_listContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_search_property_listContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Create_search_property_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_search_property_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_search_property_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_search_property_list(s) + } +} + +func (s *Create_search_property_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_search_property_list(s) + } +} + +func (s *Create_search_property_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_search_property_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_search_property_list() (localctx ICreate_search_property_listContext) { + localctx = NewCreate_search_property_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 394, TSqlParserRULE_create_search_property_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4968) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4969) + p.Match(TSqlParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4970) + p.Match(TSqlParserPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4971) + p.Match(TSqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4972) + + var _x = p.Id_() + + localctx.(*Create_search_property_listContext).new_list_name = _x + } + p.SetState(4980) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFROM { + { + p.SetState(4973) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4977) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 518, p.GetParserRuleContext()) == 1 { + { + p.SetState(4974) + + var _x = p.Id_() + + localctx.(*Create_search_property_listContext).database_name = _x + } + { + p.SetState(4975) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4979) + + var _x = p.Id_() + + localctx.(*Create_search_property_listContext).source_list_name = _x + } + + } + p.SetState(4984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(4982) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4983) + + var _x = p.Id_() + + localctx.(*Create_search_property_listContext).owner_name = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_security_policyContext is an interface to support dynamic dispatch. +type ICreate_security_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetSecurity_policy_name returns the security_policy_name rule contexts. + GetSecurity_policy_name() IId_Context + + // GetTvf_schema_name returns the tvf_schema_name rule contexts. + GetTvf_schema_name() IId_Context + + // GetSecurity_predicate_function_name returns the security_predicate_function_name rule contexts. + GetSecurity_predicate_function_name() IId_Context + + // GetColumn_name_or_arguments returns the column_name_or_arguments rule contexts. + GetColumn_name_or_arguments() IId_Context + + // GetTable_schema_name returns the table_schema_name rule contexts. + GetTable_schema_name() IId_Context + + // GetName returns the name rule contexts. + GetName() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetSecurity_policy_name sets the security_policy_name rule contexts. + SetSecurity_policy_name(IId_Context) + + // SetTvf_schema_name sets the tvf_schema_name rule contexts. + SetTvf_schema_name(IId_Context) + + // SetSecurity_predicate_function_name sets the security_predicate_function_name rule contexts. + SetSecurity_predicate_function_name(IId_Context) + + // SetColumn_name_or_arguments sets the column_name_or_arguments rule contexts. + SetColumn_name_or_arguments(IId_Context) + + // SetTable_schema_name sets the table_schema_name rule contexts. + SetTable_schema_name(IId_Context) + + // SetName sets the name rule contexts. + SetName(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + SECURITY() antlr.TerminalNode + POLICY() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllADD() []antlr.TerminalNode + ADD(i int) antlr.TerminalNode + AllPREDICATE() []antlr.TerminalNode + PREDICATE(i int) antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + STATE() antlr.TerminalNode + EQUAL() antlr.TerminalNode + NOT() antlr.TerminalNode + FOR() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + AllOFF() []antlr.TerminalNode + OFF(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllAFTER() []antlr.TerminalNode + AFTER(i int) antlr.TerminalNode + AllBEFORE() []antlr.TerminalNode + BEFORE(i int) antlr.TerminalNode + SCHEMABINDING() antlr.TerminalNode + AllFILTER() []antlr.TerminalNode + FILTER(i int) antlr.TerminalNode + AllBLOCK() []antlr.TerminalNode + BLOCK(i int) antlr.TerminalNode + AllINSERT() []antlr.TerminalNode + INSERT(i int) antlr.TerminalNode + AllUPDATE() []antlr.TerminalNode + UPDATE(i int) antlr.TerminalNode + AllDELETE() []antlr.TerminalNode + DELETE(i int) antlr.TerminalNode + + // IsCreate_security_policyContext differentiates from other interfaces. + IsCreate_security_policyContext() +} + +type Create_security_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + security_policy_name IId_Context + tvf_schema_name IId_Context + security_predicate_function_name IId_Context + column_name_or_arguments IId_Context + table_schema_name IId_Context + name IId_Context +} + +func NewEmptyCreate_security_policyContext() *Create_security_policyContext { + var p = new(Create_security_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_security_policy + return p +} + +func InitEmptyCreate_security_policyContext(p *Create_security_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_security_policy +} + +func (*Create_security_policyContext) IsCreate_security_policyContext() {} + +func NewCreate_security_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_security_policyContext { + var p = new(Create_security_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_security_policy + + return p +} + +func (s *Create_security_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_security_policyContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Create_security_policyContext) GetSecurity_policy_name() IId_Context { + return s.security_policy_name +} + +func (s *Create_security_policyContext) GetTvf_schema_name() IId_Context { return s.tvf_schema_name } + +func (s *Create_security_policyContext) GetSecurity_predicate_function_name() IId_Context { + return s.security_predicate_function_name +} + +func (s *Create_security_policyContext) GetColumn_name_or_arguments() IId_Context { + return s.column_name_or_arguments +} + +func (s *Create_security_policyContext) GetTable_schema_name() IId_Context { + return s.table_schema_name +} + +func (s *Create_security_policyContext) GetName() IId_Context { return s.name } + +func (s *Create_security_policyContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Create_security_policyContext) SetSecurity_policy_name(v IId_Context) { + s.security_policy_name = v +} + +func (s *Create_security_policyContext) SetTvf_schema_name(v IId_Context) { s.tvf_schema_name = v } + +func (s *Create_security_policyContext) SetSecurity_predicate_function_name(v IId_Context) { + s.security_predicate_function_name = v +} + +func (s *Create_security_policyContext) SetColumn_name_or_arguments(v IId_Context) { + s.column_name_or_arguments = v +} + +func (s *Create_security_policyContext) SetTable_schema_name(v IId_Context) { s.table_schema_name = v } + +func (s *Create_security_policyContext) SetName(v IId_Context) { s.name = v } + +func (s *Create_security_policyContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_security_policyContext) SECURITY() antlr.TerminalNode { + return s.GetToken(TSqlParserSECURITY, 0) +} + +func (s *Create_security_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(TSqlParserPOLICY, 0) +} + +func (s *Create_security_policyContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_security_policyContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_security_policyContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Create_security_policyContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Create_security_policyContext) AllADD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserADD) +} + +func (s *Create_security_policyContext) ADD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserADD, i) +} + +func (s *Create_security_policyContext) AllPREDICATE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserPREDICATE) +} + +func (s *Create_security_policyContext) PREDICATE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserPREDICATE, i) +} + +func (s *Create_security_policyContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Create_security_policyContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Create_security_policyContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Create_security_policyContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Create_security_policyContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Create_security_policyContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Create_security_policyContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_security_policyContext) STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATE, 0) +} + +func (s *Create_security_policyContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_security_policyContext) NOT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, 0) +} + +func (s *Create_security_policyContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_security_policyContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLICATION, 0) +} + +func (s *Create_security_policyContext) AllOFF() []antlr.TerminalNode { + return s.GetTokens(TSqlParserOFF) +} + +func (s *Create_security_policyContext) OFF(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, i) +} + +func (s *Create_security_policyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_security_policyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_security_policyContext) AllAFTER() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAFTER) +} + +func (s *Create_security_policyContext) AFTER(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAFTER, i) +} + +func (s *Create_security_policyContext) AllBEFORE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBEFORE) +} + +func (s *Create_security_policyContext) BEFORE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBEFORE, i) +} + +func (s *Create_security_policyContext) SCHEMABINDING() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMABINDING, 0) +} + +func (s *Create_security_policyContext) AllFILTER() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFILTER) +} + +func (s *Create_security_policyContext) FILTER(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFILTER, i) +} + +func (s *Create_security_policyContext) AllBLOCK() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBLOCK) +} + +func (s *Create_security_policyContext) BLOCK(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBLOCK, i) +} + +func (s *Create_security_policyContext) AllINSERT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserINSERT) +} + +func (s *Create_security_policyContext) INSERT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserINSERT, i) +} + +func (s *Create_security_policyContext) AllUPDATE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserUPDATE) +} + +func (s *Create_security_policyContext) UPDATE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserUPDATE, i) +} + +func (s *Create_security_policyContext) AllDELETE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDELETE) +} + +func (s *Create_security_policyContext) DELETE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDELETE, i) +} + +func (s *Create_security_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_security_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_security_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_security_policy(s) + } +} + +func (s *Create_security_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_security_policy(s) + } +} + +func (s *Create_security_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_security_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_security_policy() (localctx ICreate_security_policyContext) { + localctx = NewCreate_security_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 396, TSqlParserRULE_create_security_policy) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4986) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4987) + p.Match(TSqlParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4988) + p.Match(TSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4992) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 521, p.GetParserRuleContext()) == 1 { + { + p.SetState(4989) + + var _x = p.Id_() + + localctx.(*Create_security_policyContext).schema_name = _x + } + { + p.SetState(4990) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4994) + + var _x = p.Id_() + + localctx.(*Create_security_policyContext).security_policy_name = _x + } + p.SetState(5035) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(4996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(4995) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4998) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5000) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserBLOCK || _la == TSqlParserFILTER { + { + p.SetState(4999) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserBLOCK || _la == TSqlParserFILTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5002) + p.Match(TSqlParserPREDICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5003) + + var _x = p.Id_() + + localctx.(*Create_security_policyContext).tvf_schema_name = _x + } + { + p.SetState(5004) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5005) + + var _x = p.Id_() + + localctx.(*Create_security_policyContext).security_predicate_function_name = _x + } + { + p.SetState(5006) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5011) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&562949975835135) != 0) { + p.SetState(5008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5007) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5010) + + var _x = p.Id_() + + localctx.(*Create_security_policyContext).column_name_or_arguments = _x + } + + p.SetState(5013) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5015) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5016) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5017) + + var _x = p.Id_() + + localctx.(*Create_security_policyContext).table_schema_name = _x + } + { + p.SetState(5018) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5019) + + var _x = p.Id_() + + localctx.(*Create_security_policyContext).name = _x + } + p.SetState(5032) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 529, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(5030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 528, p.GetParserRuleContext()) { + case 1: + p.SetState(5021) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5020) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5023) + p.Match(TSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5024) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserINSERT || _la == TSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + p.SetState(5026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5025) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5028) + p.Match(TSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5029) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDELETE || _la == TSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(5034) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 529, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5037) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 530, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(5049) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 532, p.GetParserRuleContext()) == 1 { + { + p.SetState(5039) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5040) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5041) + p.Match(TSqlParserSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5042) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5043) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(5046) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSCHEMABINDING { + { + p.SetState(5044) + p.Match(TSqlParserSCHEMABINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5045) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5048) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserNOT { + { + p.SetState(5051) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5052) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5053) + p.Match(TSqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_sequenceContext is an interface to support dynamic dispatch. +type IAlter_sequenceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSequnce_increment returns the sequnce_increment token. + GetSequnce_increment() antlr.Token + + // SetSequnce_increment sets the sequnce_increment token. + SetSequnce_increment(antlr.Token) + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetSequence_name returns the sequence_name rule contexts. + GetSequence_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetSequence_name sets the sequence_name rule contexts. + SetSequence_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + DOT() antlr.TerminalNode + RESTART() antlr.TerminalNode + INCREMENT() antlr.TerminalNode + BY() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + AllNO() []antlr.TerminalNode + NO(i int) antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + CYCLE() antlr.TerminalNode + CACHE() antlr.TerminalNode + WITH() antlr.TerminalNode + + // IsAlter_sequenceContext differentiates from other interfaces. + IsAlter_sequenceContext() +} + +type Alter_sequenceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + sequence_name IId_Context + sequnce_increment antlr.Token +} + +func NewEmptyAlter_sequenceContext() *Alter_sequenceContext { + var p = new(Alter_sequenceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_sequence + return p +} + +func InitEmptyAlter_sequenceContext(p *Alter_sequenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_sequence +} + +func (*Alter_sequenceContext) IsAlter_sequenceContext() {} + +func NewAlter_sequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_sequenceContext { + var p = new(Alter_sequenceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_sequence + + return p +} + +func (s *Alter_sequenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_sequenceContext) GetSequnce_increment() antlr.Token { return s.sequnce_increment } + +func (s *Alter_sequenceContext) SetSequnce_increment(v antlr.Token) { s.sequnce_increment = v } + +func (s *Alter_sequenceContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Alter_sequenceContext) GetSequence_name() IId_Context { return s.sequence_name } + +func (s *Alter_sequenceContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Alter_sequenceContext) SetSequence_name(v IId_Context) { s.sequence_name = v } + +func (s *Alter_sequenceContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_sequenceContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(TSqlParserSEQUENCE, 0) +} + +func (s *Alter_sequenceContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_sequenceContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_sequenceContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Alter_sequenceContext) RESTART() antlr.TerminalNode { + return s.GetToken(TSqlParserRESTART, 0) +} + +func (s *Alter_sequenceContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(TSqlParserINCREMENT, 0) +} + +func (s *Alter_sequenceContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Alter_sequenceContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserMINVALUE, 0) +} + +func (s *Alter_sequenceContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Alter_sequenceContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Alter_sequenceContext) AllNO() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNO) +} + +func (s *Alter_sequenceContext) NO(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNO, i) +} + +func (s *Alter_sequenceContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXVALUE, 0) +} + +func (s *Alter_sequenceContext) CYCLE() antlr.TerminalNode { + return s.GetToken(TSqlParserCYCLE, 0) +} + +func (s *Alter_sequenceContext) CACHE() antlr.TerminalNode { + return s.GetToken(TSqlParserCACHE, 0) +} + +func (s *Alter_sequenceContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_sequenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_sequenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_sequenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_sequence(s) + } +} + +func (s *Alter_sequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_sequence(s) + } +} + +func (s *Alter_sequenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_sequence(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_sequence() (localctx IAlter_sequenceContext) { + localctx = NewAlter_sequenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 398, TSqlParserRULE_alter_sequence) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5056) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5057) + p.Match(TSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5061) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 534, p.GetParserRuleContext()) == 1 { + { + p.SetState(5058) + + var _x = p.Id_() + + localctx.(*Alter_sequenceContext).schema_name = _x + } + { + p.SetState(5059) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5063) + + var _x = p.Id_() + + localctx.(*Alter_sequenceContext).sequence_name = _x + } + p.SetState(5069) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 536, p.GetParserRuleContext()) == 1 { + { + p.SetState(5064) + p.Match(TSqlParserRESTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5067) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 535, p.GetParserRuleContext()) == 1 { + { + p.SetState(5065) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5066) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5074) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 537, p.GetParserRuleContext()) == 1 { + { + p.SetState(5071) + p.Match(TSqlParserINCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5072) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5073) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_sequenceContext).sequnce_increment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5080) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 538, p.GetParserRuleContext()) == 1 { + { + p.SetState(5076) + p.Match(TSqlParserMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5077) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 538, p.GetParserRuleContext()) == 2 { + { + p.SetState(5078) + p.Match(TSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5079) + p.Match(TSqlParserMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5086) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 539, p.GetParserRuleContext()) == 1 { + { + p.SetState(5082) + p.Match(TSqlParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5083) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 539, p.GetParserRuleContext()) == 2 { + { + p.SetState(5084) + p.Match(TSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5085) + p.Match(TSqlParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5091) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 540, p.GetParserRuleContext()) == 1 { + { + p.SetState(5088) + p.Match(TSqlParserCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 540, p.GetParserRuleContext()) == 2 { + { + p.SetState(5089) + p.Match(TSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5090) + p.Match(TSqlParserCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5097) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 541, p.GetParserRuleContext()) == 1 { + { + p.SetState(5093) + p.Match(TSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5094) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 541, p.GetParserRuleContext()) == 2 { + { + p.SetState(5095) + p.Match(TSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5096) + p.Match(TSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_sequenceContext is an interface to support dynamic dispatch. +type ICreate_sequenceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetSequence_name returns the sequence_name rule contexts. + GetSequence_name() IId_Context + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetSequence_name sets the sequence_name rule contexts. + SetSequence_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + DOT() antlr.TerminalNode + AS() antlr.TerminalNode + Data_type() IData_typeContext + START() antlr.TerminalNode + WITH() antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + INCREMENT() antlr.TerminalNode + BY() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + AllNO() []antlr.TerminalNode + NO(i int) antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + CYCLE() antlr.TerminalNode + CACHE() antlr.TerminalNode + AllMINUS() []antlr.TerminalNode + MINUS(i int) antlr.TerminalNode + + // IsCreate_sequenceContext differentiates from other interfaces. + IsCreate_sequenceContext() +} + +type Create_sequenceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IId_Context + sequence_name IId_Context +} + +func NewEmptyCreate_sequenceContext() *Create_sequenceContext { + var p = new(Create_sequenceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_sequence + return p +} + +func InitEmptyCreate_sequenceContext(p *Create_sequenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_sequence +} + +func (*Create_sequenceContext) IsCreate_sequenceContext() {} + +func NewCreate_sequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_sequenceContext { + var p = new(Create_sequenceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_sequence + + return p +} + +func (s *Create_sequenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_sequenceContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Create_sequenceContext) GetSequence_name() IId_Context { return s.sequence_name } + +func (s *Create_sequenceContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Create_sequenceContext) SetSequence_name(v IId_Context) { s.sequence_name = v } + +func (s *Create_sequenceContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_sequenceContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(TSqlParserSEQUENCE, 0) +} + +func (s *Create_sequenceContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_sequenceContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_sequenceContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Create_sequenceContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Create_sequenceContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Create_sequenceContext) START() antlr.TerminalNode { + return s.GetToken(TSqlParserSTART, 0) +} + +func (s *Create_sequenceContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_sequenceContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Create_sequenceContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Create_sequenceContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(TSqlParserINCREMENT, 0) +} + +func (s *Create_sequenceContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Create_sequenceContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserMINVALUE, 0) +} + +func (s *Create_sequenceContext) AllNO() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNO) +} + +func (s *Create_sequenceContext) NO(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNO, i) +} + +func (s *Create_sequenceContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXVALUE, 0) +} + +func (s *Create_sequenceContext) CYCLE() antlr.TerminalNode { + return s.GetToken(TSqlParserCYCLE, 0) +} + +func (s *Create_sequenceContext) CACHE() antlr.TerminalNode { + return s.GetToken(TSqlParserCACHE, 0) +} + +func (s *Create_sequenceContext) AllMINUS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMINUS) +} + +func (s *Create_sequenceContext) MINUS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMINUS, i) +} + +func (s *Create_sequenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_sequenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_sequenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_sequence(s) + } +} + +func (s *Create_sequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_sequence(s) + } +} + +func (s *Create_sequenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_sequence(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_sequence() (localctx ICreate_sequenceContext) { + localctx = NewCreate_sequenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 400, TSqlParserRULE_create_sequence) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5099) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5100) + p.Match(TSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5104) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 542, p.GetParserRuleContext()) == 1 { + { + p.SetState(5101) + + var _x = p.Id_() + + localctx.(*Create_sequenceContext).schema_name = _x + } + { + p.SetState(5102) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5106) + + var _x = p.Id_() + + localctx.(*Create_sequenceContext).sequence_name = _x + } + p.SetState(5109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(5107) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5108) + p.Data_type() + } + + } + p.SetState(5114) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 544, p.GetParserRuleContext()) == 1 { + { + p.SetState(5111) + p.Match(TSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5112) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5113) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5122) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 546, p.GetParserRuleContext()) == 1 { + { + p.SetState(5116) + p.Match(TSqlParserINCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5117) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5119) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMINUS { + { + p.SetState(5118) + p.Match(TSqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5121) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5133) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 549, p.GetParserRuleContext()) == 1 { + { + p.SetState(5124) + p.Match(TSqlParserMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserDECIMAL || _la == TSqlParserMINUS { + p.SetState(5126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMINUS { + { + p.SetState(5125) + p.Match(TSqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5128) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 549, p.GetParserRuleContext()) == 2 { + { + p.SetState(5131) + p.Match(TSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5132) + p.Match(TSqlParserMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5144) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 552, p.GetParserRuleContext()) == 1 { + { + p.SetState(5135) + p.Match(TSqlParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserDECIMAL || _la == TSqlParserMINUS { + p.SetState(5137) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMINUS { + { + p.SetState(5136) + p.Match(TSqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5139) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 552, p.GetParserRuleContext()) == 2 { + { + p.SetState(5142) + p.Match(TSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5143) + p.Match(TSqlParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5149) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 553, p.GetParserRuleContext()) == 1 { + { + p.SetState(5146) + p.Match(TSqlParserCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 553, p.GetParserRuleContext()) == 2 { + { + p.SetState(5147) + p.Match(TSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5148) + p.Match(TSqlParserCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5157) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 555, p.GetParserRuleContext()) == 1 { + { + p.SetState(5151) + p.Match(TSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserDECIMAL { + { + p.SetState(5152) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 555, p.GetParserRuleContext()) == 2 { + { + p.SetState(5155) + p.Match(TSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5156) + p.Match(TSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_server_auditContext is an interface to support dynamic dispatch. +type IAlter_server_auditContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFilepath returns the filepath token. + GetFilepath() antlr.Token + + // GetMax_rollover_files returns the max_rollover_files token. + GetMax_rollover_files() antlr.Token + + // GetMax_files returns the max_files token. + GetMax_files() antlr.Token + + // GetQueue_delay returns the queue_delay token. + GetQueue_delay() antlr.Token + + // SetFilepath sets the filepath token. + SetFilepath(antlr.Token) + + // SetMax_rollover_files sets the max_rollover_files token. + SetMax_rollover_files(antlr.Token) + + // SetMax_files sets the max_files token. + SetMax_files(antlr.Token) + + // SetQueue_delay sets the queue_delay token. + SetQueue_delay(antlr.Token) + + // GetAudit_name returns the audit_name rule contexts. + GetAudit_name() IId_Context + + // GetEvent_field_name returns the event_field_name rule contexts. + GetEvent_field_name() IId_Context + + // GetNew_audit_name returns the new_audit_name rule contexts. + GetNew_audit_name() IId_Context + + // SetAudit_name sets the audit_name rule contexts. + SetAudit_name(IId_Context) + + // SetEvent_field_name sets the event_field_name rule contexts. + SetEvent_field_name(IId_Context) + + // SetNew_audit_name sets the new_audit_name rule contexts. + SetNew_audit_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + SERVER() antlr.TerminalNode + AUDIT() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + REMOVE() antlr.TerminalNode + WHERE() antlr.TerminalNode + MODIFY() antlr.TerminalNode + NAME() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + TO() antlr.TerminalNode + WITH() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + FILE() antlr.TerminalNode + APPLICATION_LOG() antlr.TerminalNode + SECURITY_LOG() antlr.TerminalNode + AllQUEUE_DELAY() []antlr.TerminalNode + QUEUE_DELAY(i int) antlr.TerminalNode + AllON_FAILURE() []antlr.TerminalNode + ON_FAILURE(i int) antlr.TerminalNode + AllSTATE() []antlr.TerminalNode + STATE(i int) antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AND() antlr.TerminalNode + OR() antlr.TerminalNode + AllCONTINUE() []antlr.TerminalNode + CONTINUE(i int) antlr.TerminalNode + AllSHUTDOWN() []antlr.TerminalNode + SHUTDOWN(i int) antlr.TerminalNode + AllFAIL_OPERATION() []antlr.TerminalNode + FAIL_OPERATION(i int) antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllOFF() []antlr.TerminalNode + OFF(i int) antlr.TerminalNode + GREATER() antlr.TerminalNode + LESS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + NOT() antlr.TerminalNode + EXCLAMATION() antlr.TerminalNode + AllFILEPATH() []antlr.TerminalNode + FILEPATH(i int) antlr.TerminalNode + AllMAXSIZE() []antlr.TerminalNode + MAXSIZE(i int) antlr.TerminalNode + AllMAX_ROLLOVER_FILES() []antlr.TerminalNode + MAX_ROLLOVER_FILES(i int) antlr.TerminalNode + AllMAX_FILES() []antlr.TerminalNode + MAX_FILES(i int) antlr.TerminalNode + AllRESERVE_DISK_SPACE() []antlr.TerminalNode + RESERVE_DISK_SPACE(i int) antlr.TerminalNode + AllUNLIMITED() []antlr.TerminalNode + UNLIMITED(i int) antlr.TerminalNode + AllMB() []antlr.TerminalNode + MB(i int) antlr.TerminalNode + AllGB() []antlr.TerminalNode + GB(i int) antlr.TerminalNode + AllTB() []antlr.TerminalNode + TB(i int) antlr.TerminalNode + + // IsAlter_server_auditContext differentiates from other interfaces. + IsAlter_server_auditContext() +} + +type Alter_server_auditContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + audit_name IId_Context + filepath antlr.Token + max_rollover_files antlr.Token + max_files antlr.Token + queue_delay antlr.Token + event_field_name IId_Context + new_audit_name IId_Context +} + +func NewEmptyAlter_server_auditContext() *Alter_server_auditContext { + var p = new(Alter_server_auditContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_server_audit + return p +} + +func InitEmptyAlter_server_auditContext(p *Alter_server_auditContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_server_audit +} + +func (*Alter_server_auditContext) IsAlter_server_auditContext() {} + +func NewAlter_server_auditContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_server_auditContext { + var p = new(Alter_server_auditContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_server_audit + + return p +} + +func (s *Alter_server_auditContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_server_auditContext) GetFilepath() antlr.Token { return s.filepath } + +func (s *Alter_server_auditContext) GetMax_rollover_files() antlr.Token { return s.max_rollover_files } + +func (s *Alter_server_auditContext) GetMax_files() antlr.Token { return s.max_files } + +func (s *Alter_server_auditContext) GetQueue_delay() antlr.Token { return s.queue_delay } + +func (s *Alter_server_auditContext) SetFilepath(v antlr.Token) { s.filepath = v } + +func (s *Alter_server_auditContext) SetMax_rollover_files(v antlr.Token) { s.max_rollover_files = v } + +func (s *Alter_server_auditContext) SetMax_files(v antlr.Token) { s.max_files = v } + +func (s *Alter_server_auditContext) SetQueue_delay(v antlr.Token) { s.queue_delay = v } + +func (s *Alter_server_auditContext) GetAudit_name() IId_Context { return s.audit_name } + +func (s *Alter_server_auditContext) GetEvent_field_name() IId_Context { return s.event_field_name } + +func (s *Alter_server_auditContext) GetNew_audit_name() IId_Context { return s.new_audit_name } + +func (s *Alter_server_auditContext) SetAudit_name(v IId_Context) { s.audit_name = v } + +func (s *Alter_server_auditContext) SetEvent_field_name(v IId_Context) { s.event_field_name = v } + +func (s *Alter_server_auditContext) SetNew_audit_name(v IId_Context) { s.new_audit_name = v } + +func (s *Alter_server_auditContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_server_auditContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Alter_server_auditContext) AUDIT() antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT, 0) +} + +func (s *Alter_server_auditContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_server_auditContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_server_auditContext) REMOVE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOVE, 0) +} + +func (s *Alter_server_auditContext) WHERE() antlr.TerminalNode { + return s.GetToken(TSqlParserWHERE, 0) +} + +func (s *Alter_server_auditContext) MODIFY() antlr.TerminalNode { + return s.GetToken(TSqlParserMODIFY, 0) +} + +func (s *Alter_server_auditContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *Alter_server_auditContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_server_auditContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_server_auditContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Alter_server_auditContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_server_auditContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Alter_server_auditContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Alter_server_auditContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Alter_server_auditContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Alter_server_auditContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Alter_server_auditContext) APPLICATION_LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLICATION_LOG, 0) +} + +func (s *Alter_server_auditContext) SECURITY_LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserSECURITY_LOG, 0) +} + +func (s *Alter_server_auditContext) AllQUEUE_DELAY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserQUEUE_DELAY) +} + +func (s *Alter_server_auditContext) QUEUE_DELAY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserQUEUE_DELAY, i) +} + +func (s *Alter_server_auditContext) AllON_FAILURE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON_FAILURE) +} + +func (s *Alter_server_auditContext) ON_FAILURE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON_FAILURE, i) +} + +func (s *Alter_server_auditContext) AllSTATE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTATE) +} + +func (s *Alter_server_auditContext) STATE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTATE, i) +} + +func (s *Alter_server_auditContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Alter_server_auditContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Alter_server_auditContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Alter_server_auditContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Alter_server_auditContext) AND() antlr.TerminalNode { + return s.GetToken(TSqlParserAND, 0) +} + +func (s *Alter_server_auditContext) OR() antlr.TerminalNode { + return s.GetToken(TSqlParserOR, 0) +} + +func (s *Alter_server_auditContext) AllCONTINUE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCONTINUE) +} + +func (s *Alter_server_auditContext) CONTINUE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCONTINUE, i) +} + +func (s *Alter_server_auditContext) AllSHUTDOWN() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSHUTDOWN) +} + +func (s *Alter_server_auditContext) SHUTDOWN(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSHUTDOWN, i) +} + +func (s *Alter_server_auditContext) AllFAIL_OPERATION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFAIL_OPERATION) +} + +func (s *Alter_server_auditContext) FAIL_OPERATION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFAIL_OPERATION, i) +} + +func (s *Alter_server_auditContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Alter_server_auditContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Alter_server_auditContext) AllOFF() []antlr.TerminalNode { + return s.GetTokens(TSqlParserOFF) +} + +func (s *Alter_server_auditContext) OFF(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, i) +} + +func (s *Alter_server_auditContext) GREATER() antlr.TerminalNode { + return s.GetToken(TSqlParserGREATER, 0) +} + +func (s *Alter_server_auditContext) LESS() antlr.TerminalNode { + return s.GetToken(TSqlParserLESS, 0) +} + +func (s *Alter_server_auditContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_server_auditContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_server_auditContext) NOT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, 0) +} + +func (s *Alter_server_auditContext) EXCLAMATION() antlr.TerminalNode { + return s.GetToken(TSqlParserEXCLAMATION, 0) +} + +func (s *Alter_server_auditContext) AllFILEPATH() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFILEPATH) +} + +func (s *Alter_server_auditContext) FILEPATH(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFILEPATH, i) +} + +func (s *Alter_server_auditContext) AllMAXSIZE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMAXSIZE) +} + +func (s *Alter_server_auditContext) MAXSIZE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMAXSIZE, i) +} + +func (s *Alter_server_auditContext) AllMAX_ROLLOVER_FILES() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMAX_ROLLOVER_FILES) +} + +func (s *Alter_server_auditContext) MAX_ROLLOVER_FILES(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_ROLLOVER_FILES, i) +} + +func (s *Alter_server_auditContext) AllMAX_FILES() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMAX_FILES) +} + +func (s *Alter_server_auditContext) MAX_FILES(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_FILES, i) +} + +func (s *Alter_server_auditContext) AllRESERVE_DISK_SPACE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRESERVE_DISK_SPACE) +} + +func (s *Alter_server_auditContext) RESERVE_DISK_SPACE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRESERVE_DISK_SPACE, i) +} + +func (s *Alter_server_auditContext) AllUNLIMITED() []antlr.TerminalNode { + return s.GetTokens(TSqlParserUNLIMITED) +} + +func (s *Alter_server_auditContext) UNLIMITED(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserUNLIMITED, i) +} + +func (s *Alter_server_auditContext) AllMB() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMB) +} + +func (s *Alter_server_auditContext) MB(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMB, i) +} + +func (s *Alter_server_auditContext) AllGB() []antlr.TerminalNode { + return s.GetTokens(TSqlParserGB) +} + +func (s *Alter_server_auditContext) GB(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserGB, i) +} + +func (s *Alter_server_auditContext) AllTB() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTB) +} + +func (s *Alter_server_auditContext) TB(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTB, i) +} + +func (s *Alter_server_auditContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_server_auditContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_server_auditContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_server_audit(s) + } +} + +func (s *Alter_server_auditContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_server_audit(s) + } +} + +func (s *Alter_server_auditContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_server_audit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_server_audit() (localctx IAlter_server_auditContext) { + localctx = NewAlter_server_auditContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 402, TSqlParserRULE_alter_server_audit) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5159) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5160) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5161) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5162) + + var _x = p.Id_() + + localctx.(*Alter_server_auditContext).audit_name = _x + } + p.SetState(5294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 580, p.GetParserRuleContext()) { + case 1: + p.SetState(5210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserTO { + { + p.SetState(5163) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFILE: + { + p.SetState(5164) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(5165) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserFILEPATH || ((int64((_la-553)) & ^0x3f) == 0 && ((int64(1)<<(_la-553))&33025) != 0) || _la == TSqlParserRESERVE_DISK_SPACE || _la == TSqlParserCOMMA { + p.SetState(5200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 562, p.GetParserRuleContext()) { + case 1: + p.SetState(5167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5166) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5169) + p.Match(TSqlParserFILEPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5170) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5171) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_server_auditContext).filepath = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(5173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5172) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5175) + p.Match(TSqlParserMAXSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5176) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5180) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(5177) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5178) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserGB || _la == TSqlParserMB || _la == TSqlParserTB) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserUNLIMITED: + { + p.SetState(5179) + p.Match(TSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 3: + p.SetState(5183) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5182) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5185) + p.Match(TSqlParserMAX_ROLLOVER_FILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5186) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5187) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Alter_server_auditContext).max_rollover_files = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserUNLIMITED || _la == TSqlParserDECIMAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Alter_server_auditContext).max_rollover_files = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 4: + p.SetState(5189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5188) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5191) + p.Match(TSqlParserMAX_FILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5192) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5193) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_server_auditContext).max_files = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.SetState(5195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5194) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5197) + p.Match(TSqlParserRESERVE_DISK_SPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5198) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5199) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(5204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5205) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserAPPLICATION_LOG: + { + p.SetState(5206) + p.Match(TSqlParserAPPLICATION_LOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSECURITY_LOG: + { + p.SetState(5207) + p.Match(TSqlParserSECURITY_LOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(5238) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 571, p.GetParserRuleContext()) == 1 { + { + p.SetState(5212) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5213) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5234) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserON_FAILURE || _la == TSqlParserQUEUE_DELAY || _la == TSqlParserSTATE || _la == TSqlParserCOMMA { + p.SetState(5232) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 569, p.GetParserRuleContext()) { + case 1: + p.SetState(5215) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5214) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5217) + p.Match(TSqlParserQUEUE_DELAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5218) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5219) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_server_auditContext).queue_delay = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(5221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5220) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5223) + p.Match(TSqlParserON_FAILURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5224) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5225) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCONTINUE || _la == TSqlParserFAIL_OPERATION || _la == TSqlParserSHUTDOWN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 3: + p.SetState(5227) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5226) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5229) + p.Match(TSqlParserSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5230) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5231) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(5236) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5237) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWHERE { + { + p.SetState(5240) + p.Match(TSqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5284) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 578, p.GetParserRuleContext()) { + case 1: + p.SetState(5242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5241) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(5245) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserNOT { + { + p.SetState(5244) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + { + p.SetState(5247) + + var _x = p.Id_() + + localctx.(*Alter_server_auditContext).event_field_name = _x + } + p.SetState(5259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 574, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5248) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(5249) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5250) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(5251) + p.Match(TSqlParserEXCLAMATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5252) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(5253) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(5254) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5255) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(5256) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + { + p.SetState(5257) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5258) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(5261) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDECIMAL || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + p.SetState(5264) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5263) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5266) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAND || _la == TSqlParserOR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(5268) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserNOT { + { + p.SetState(5267) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 577, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5270) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(5271) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5272) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(5273) + p.Match(TSqlParserEXCLAMATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5274) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(5275) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(5276) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5277) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(5278) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + { + p.SetState(5279) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5280) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(5283) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDECIMAL || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + + case 2: + { + p.SetState(5288) + p.Match(TSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5289) + p.Match(TSqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(5290) + p.Match(TSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5291) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5292) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5293) + + var _x = p.Id_() + + localctx.(*Alter_server_auditContext).new_audit_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_server_auditContext is an interface to support dynamic dispatch. +type ICreate_server_auditContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFilepath returns the filepath token. + GetFilepath() antlr.Token + + // GetMax_rollover_files returns the max_rollover_files token. + GetMax_rollover_files() antlr.Token + + // GetMax_files returns the max_files token. + GetMax_files() antlr.Token + + // GetQueue_delay returns the queue_delay token. + GetQueue_delay() antlr.Token + + // SetFilepath sets the filepath token. + SetFilepath(antlr.Token) + + // SetMax_rollover_files sets the max_rollover_files token. + SetMax_rollover_files(antlr.Token) + + // SetMax_files sets the max_files token. + SetMax_files(antlr.Token) + + // SetQueue_delay sets the queue_delay token. + SetQueue_delay(antlr.Token) + + // GetAudit_name returns the audit_name rule contexts. + GetAudit_name() IId_Context + + // GetAudit_guid returns the audit_guid rule contexts. + GetAudit_guid() IId_Context + + // GetEvent_field_name returns the event_field_name rule contexts. + GetEvent_field_name() IId_Context + + // GetNew_audit_name returns the new_audit_name rule contexts. + GetNew_audit_name() IId_Context + + // SetAudit_name sets the audit_name rule contexts. + SetAudit_name(IId_Context) + + // SetAudit_guid sets the audit_guid rule contexts. + SetAudit_guid(IId_Context) + + // SetEvent_field_name sets the event_field_name rule contexts. + SetEvent_field_name(IId_Context) + + // SetNew_audit_name sets the new_audit_name rule contexts. + SetNew_audit_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + SERVER() antlr.TerminalNode + AUDIT() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + REMOVE() antlr.TerminalNode + WHERE() antlr.TerminalNode + MODIFY() antlr.TerminalNode + NAME() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + TO() antlr.TerminalNode + WITH() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + FILE() antlr.TerminalNode + APPLICATION_LOG() antlr.TerminalNode + SECURITY_LOG() antlr.TerminalNode + AllQUEUE_DELAY() []antlr.TerminalNode + QUEUE_DELAY(i int) antlr.TerminalNode + AllON_FAILURE() []antlr.TerminalNode + ON_FAILURE(i int) antlr.TerminalNode + AllSTATE() []antlr.TerminalNode + STATE(i int) antlr.TerminalNode + AllAUDIT_GUID() []antlr.TerminalNode + AUDIT_GUID(i int) antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AND() antlr.TerminalNode + OR() antlr.TerminalNode + AllCONTINUE() []antlr.TerminalNode + CONTINUE(i int) antlr.TerminalNode + AllSHUTDOWN() []antlr.TerminalNode + SHUTDOWN(i int) antlr.TerminalNode + AllFAIL_OPERATION() []antlr.TerminalNode + FAIL_OPERATION(i int) antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllOFF() []antlr.TerminalNode + OFF(i int) antlr.TerminalNode + GREATER() antlr.TerminalNode + LESS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + NOT() antlr.TerminalNode + EXCLAMATION() antlr.TerminalNode + AllFILEPATH() []antlr.TerminalNode + FILEPATH(i int) antlr.TerminalNode + AllMAXSIZE() []antlr.TerminalNode + MAXSIZE(i int) antlr.TerminalNode + AllMAX_ROLLOVER_FILES() []antlr.TerminalNode + MAX_ROLLOVER_FILES(i int) antlr.TerminalNode + AllMAX_FILES() []antlr.TerminalNode + MAX_FILES(i int) antlr.TerminalNode + AllRESERVE_DISK_SPACE() []antlr.TerminalNode + RESERVE_DISK_SPACE(i int) antlr.TerminalNode + AllUNLIMITED() []antlr.TerminalNode + UNLIMITED(i int) antlr.TerminalNode + AllMB() []antlr.TerminalNode + MB(i int) antlr.TerminalNode + AllGB() []antlr.TerminalNode + GB(i int) antlr.TerminalNode + AllTB() []antlr.TerminalNode + TB(i int) antlr.TerminalNode + + // IsCreate_server_auditContext differentiates from other interfaces. + IsCreate_server_auditContext() +} + +type Create_server_auditContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + audit_name IId_Context + filepath antlr.Token + max_rollover_files antlr.Token + max_files antlr.Token + queue_delay antlr.Token + audit_guid IId_Context + event_field_name IId_Context + new_audit_name IId_Context +} + +func NewEmptyCreate_server_auditContext() *Create_server_auditContext { + var p = new(Create_server_auditContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_server_audit + return p +} + +func InitEmptyCreate_server_auditContext(p *Create_server_auditContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_server_audit +} + +func (*Create_server_auditContext) IsCreate_server_auditContext() {} + +func NewCreate_server_auditContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_server_auditContext { + var p = new(Create_server_auditContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_server_audit + + return p +} + +func (s *Create_server_auditContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_server_auditContext) GetFilepath() antlr.Token { return s.filepath } + +func (s *Create_server_auditContext) GetMax_rollover_files() antlr.Token { return s.max_rollover_files } + +func (s *Create_server_auditContext) GetMax_files() antlr.Token { return s.max_files } + +func (s *Create_server_auditContext) GetQueue_delay() antlr.Token { return s.queue_delay } + +func (s *Create_server_auditContext) SetFilepath(v antlr.Token) { s.filepath = v } + +func (s *Create_server_auditContext) SetMax_rollover_files(v antlr.Token) { s.max_rollover_files = v } + +func (s *Create_server_auditContext) SetMax_files(v antlr.Token) { s.max_files = v } + +func (s *Create_server_auditContext) SetQueue_delay(v antlr.Token) { s.queue_delay = v } + +func (s *Create_server_auditContext) GetAudit_name() IId_Context { return s.audit_name } + +func (s *Create_server_auditContext) GetAudit_guid() IId_Context { return s.audit_guid } + +func (s *Create_server_auditContext) GetEvent_field_name() IId_Context { return s.event_field_name } + +func (s *Create_server_auditContext) GetNew_audit_name() IId_Context { return s.new_audit_name } + +func (s *Create_server_auditContext) SetAudit_name(v IId_Context) { s.audit_name = v } + +func (s *Create_server_auditContext) SetAudit_guid(v IId_Context) { s.audit_guid = v } + +func (s *Create_server_auditContext) SetEvent_field_name(v IId_Context) { s.event_field_name = v } + +func (s *Create_server_auditContext) SetNew_audit_name(v IId_Context) { s.new_audit_name = v } + +func (s *Create_server_auditContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_server_auditContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Create_server_auditContext) AUDIT() antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT, 0) +} + +func (s *Create_server_auditContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_server_auditContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_server_auditContext) REMOVE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOVE, 0) +} + +func (s *Create_server_auditContext) WHERE() antlr.TerminalNode { + return s.GetToken(TSqlParserWHERE, 0) +} + +func (s *Create_server_auditContext) MODIFY() antlr.TerminalNode { + return s.GetToken(TSqlParserMODIFY, 0) +} + +func (s *Create_server_auditContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *Create_server_auditContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_server_auditContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_server_auditContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Create_server_auditContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_server_auditContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Create_server_auditContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Create_server_auditContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Create_server_auditContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Create_server_auditContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Create_server_auditContext) APPLICATION_LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLICATION_LOG, 0) +} + +func (s *Create_server_auditContext) SECURITY_LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserSECURITY_LOG, 0) +} + +func (s *Create_server_auditContext) AllQUEUE_DELAY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserQUEUE_DELAY) +} + +func (s *Create_server_auditContext) QUEUE_DELAY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserQUEUE_DELAY, i) +} + +func (s *Create_server_auditContext) AllON_FAILURE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON_FAILURE) +} + +func (s *Create_server_auditContext) ON_FAILURE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON_FAILURE, i) +} + +func (s *Create_server_auditContext) AllSTATE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTATE) +} + +func (s *Create_server_auditContext) STATE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTATE, i) +} + +func (s *Create_server_auditContext) AllAUDIT_GUID() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAUDIT_GUID) +} + +func (s *Create_server_auditContext) AUDIT_GUID(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT_GUID, i) +} + +func (s *Create_server_auditContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Create_server_auditContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Create_server_auditContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Create_server_auditContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Create_server_auditContext) AND() antlr.TerminalNode { + return s.GetToken(TSqlParserAND, 0) +} + +func (s *Create_server_auditContext) OR() antlr.TerminalNode { + return s.GetToken(TSqlParserOR, 0) +} + +func (s *Create_server_auditContext) AllCONTINUE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCONTINUE) +} + +func (s *Create_server_auditContext) CONTINUE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCONTINUE, i) +} + +func (s *Create_server_auditContext) AllSHUTDOWN() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSHUTDOWN) +} + +func (s *Create_server_auditContext) SHUTDOWN(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSHUTDOWN, i) +} + +func (s *Create_server_auditContext) AllFAIL_OPERATION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFAIL_OPERATION) +} + +func (s *Create_server_auditContext) FAIL_OPERATION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFAIL_OPERATION, i) +} + +func (s *Create_server_auditContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Create_server_auditContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Create_server_auditContext) AllOFF() []antlr.TerminalNode { + return s.GetTokens(TSqlParserOFF) +} + +func (s *Create_server_auditContext) OFF(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, i) +} + +func (s *Create_server_auditContext) GREATER() antlr.TerminalNode { + return s.GetToken(TSqlParserGREATER, 0) +} + +func (s *Create_server_auditContext) LESS() antlr.TerminalNode { + return s.GetToken(TSqlParserLESS, 0) +} + +func (s *Create_server_auditContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_server_auditContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_server_auditContext) NOT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, 0) +} + +func (s *Create_server_auditContext) EXCLAMATION() antlr.TerminalNode { + return s.GetToken(TSqlParserEXCLAMATION, 0) +} + +func (s *Create_server_auditContext) AllFILEPATH() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFILEPATH) +} + +func (s *Create_server_auditContext) FILEPATH(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFILEPATH, i) +} + +func (s *Create_server_auditContext) AllMAXSIZE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMAXSIZE) +} + +func (s *Create_server_auditContext) MAXSIZE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMAXSIZE, i) +} + +func (s *Create_server_auditContext) AllMAX_ROLLOVER_FILES() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMAX_ROLLOVER_FILES) +} + +func (s *Create_server_auditContext) MAX_ROLLOVER_FILES(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_ROLLOVER_FILES, i) +} + +func (s *Create_server_auditContext) AllMAX_FILES() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMAX_FILES) +} + +func (s *Create_server_auditContext) MAX_FILES(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_FILES, i) +} + +func (s *Create_server_auditContext) AllRESERVE_DISK_SPACE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRESERVE_DISK_SPACE) +} + +func (s *Create_server_auditContext) RESERVE_DISK_SPACE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRESERVE_DISK_SPACE, i) +} + +func (s *Create_server_auditContext) AllUNLIMITED() []antlr.TerminalNode { + return s.GetTokens(TSqlParserUNLIMITED) +} + +func (s *Create_server_auditContext) UNLIMITED(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserUNLIMITED, i) +} + +func (s *Create_server_auditContext) AllMB() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMB) +} + +func (s *Create_server_auditContext) MB(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMB, i) +} + +func (s *Create_server_auditContext) AllGB() []antlr.TerminalNode { + return s.GetTokens(TSqlParserGB) +} + +func (s *Create_server_auditContext) GB(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserGB, i) +} + +func (s *Create_server_auditContext) AllTB() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTB) +} + +func (s *Create_server_auditContext) TB(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTB, i) +} + +func (s *Create_server_auditContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_server_auditContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_server_auditContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_server_audit(s) + } +} + +func (s *Create_server_auditContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_server_audit(s) + } +} + +func (s *Create_server_auditContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_server_audit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_server_audit() (localctx ICreate_server_auditContext) { + localctx = NewCreate_server_auditContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 404, TSqlParserRULE_create_server_audit) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5296) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5297) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5298) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5299) + + var _x = p.Id_() + + localctx.(*Create_server_auditContext).audit_name = _x + } + p.SetState(5437) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 606, p.GetParserRuleContext()) { + case 1: + p.SetState(5347) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserTO { + { + p.SetState(5300) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFILE: + { + p.SetState(5301) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(5302) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserFILEPATH || ((int64((_la-553)) & ^0x3f) == 0 && ((int64(1)<<(_la-553))&33025) != 0) || _la == TSqlParserRESERVE_DISK_SPACE || _la == TSqlParserCOMMA { + p.SetState(5337) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 587, p.GetParserRuleContext()) { + case 1: + p.SetState(5304) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5303) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5306) + p.Match(TSqlParserFILEPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5307) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5308) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_server_auditContext).filepath = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(5310) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5309) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5312) + p.Match(TSqlParserMAXSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5313) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5317) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(5314) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5315) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserGB || _la == TSqlParserMB || _la == TSqlParserTB) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserUNLIMITED: + { + p.SetState(5316) + p.Match(TSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 3: + p.SetState(5320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5319) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5322) + p.Match(TSqlParserMAX_ROLLOVER_FILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5323) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5324) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Create_server_auditContext).max_rollover_files = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserUNLIMITED || _la == TSqlParserDECIMAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Create_server_auditContext).max_rollover_files = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 4: + p.SetState(5326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5325) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5328) + p.Match(TSqlParserMAX_FILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5329) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5330) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_server_auditContext).max_files = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.SetState(5332) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5331) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5334) + p.Match(TSqlParserRESERVE_DISK_SPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5335) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5336) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(5341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5342) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserAPPLICATION_LOG: + { + p.SetState(5343) + p.Match(TSqlParserAPPLICATION_LOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSECURITY_LOG: + { + p.SetState(5344) + p.Match(TSqlParserSECURITY_LOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(5381) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 597, p.GetParserRuleContext()) == 1 { + { + p.SetState(5349) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5350) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserAUDIT_GUID || _la == TSqlParserON_FAILURE || _la == TSqlParserQUEUE_DELAY || _la == TSqlParserSTATE || _la == TSqlParserCOMMA { + p.SetState(5375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 595, p.GetParserRuleContext()) { + case 1: + p.SetState(5352) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5351) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5354) + p.Match(TSqlParserQUEUE_DELAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5355) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5356) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_server_auditContext).queue_delay = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(5358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5357) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5360) + p.Match(TSqlParserON_FAILURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5361) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5362) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCONTINUE || _la == TSqlParserFAIL_OPERATION || _la == TSqlParserSHUTDOWN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 3: + p.SetState(5364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5363) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5366) + p.Match(TSqlParserSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5367) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5368) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 4: + p.SetState(5370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5369) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5372) + p.Match(TSqlParserAUDIT_GUID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5373) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5374) + + var _x = p.Id_() + + localctx.(*Create_server_auditContext).audit_guid = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(5379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5380) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5429) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWHERE { + { + p.SetState(5383) + p.Match(TSqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 604, p.GetParserRuleContext()) { + case 1: + p.SetState(5385) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5384) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(5388) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserNOT { + { + p.SetState(5387) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + { + p.SetState(5390) + + var _x = p.Id_() + + localctx.(*Create_server_auditContext).event_field_name = _x + } + p.SetState(5402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 600, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5391) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(5392) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5393) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(5394) + p.Match(TSqlParserEXCLAMATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5395) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(5396) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(5397) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5398) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(5399) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + { + p.SetState(5400) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5401) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(5404) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDECIMAL || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + p.SetState(5407) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5406) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5409) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAND || _la == TSqlParserOR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(5411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserNOT { + { + p.SetState(5410) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 603, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5413) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(5414) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5415) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(5416) + p.Match(TSqlParserEXCLAMATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5417) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(5418) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(5419) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5420) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(5421) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + { + p.SetState(5422) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5423) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(5426) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDECIMAL || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + + case 2: + { + p.SetState(5431) + p.Match(TSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5432) + p.Match(TSqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(5433) + p.Match(TSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5434) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5435) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5436) + + var _x = p.Id_() + + localctx.(*Create_server_auditContext).new_audit_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_server_audit_specificationContext is an interface to support dynamic dispatch. +type IAlter_server_audit_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAudit_specification_name returns the audit_specification_name rule contexts. + GetAudit_specification_name() IId_Context + + // GetAudit_name returns the audit_name rule contexts. + GetAudit_name() IId_Context + + // GetAudit_action_group_name returns the audit_action_group_name rule contexts. + GetAudit_action_group_name() IId_Context + + // SetAudit_specification_name sets the audit_specification_name rule contexts. + SetAudit_specification_name(IId_Context) + + // SetAudit_name sets the audit_name rule contexts. + SetAudit_name(IId_Context) + + // SetAudit_action_group_name sets the audit_action_group_name rule contexts. + SetAudit_action_group_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + AllSERVER() []antlr.TerminalNode + SERVER(i int) antlr.TerminalNode + AllAUDIT() []antlr.TerminalNode + AUDIT(i int) antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + FOR() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + STATE() antlr.TerminalNode + EQUAL() antlr.TerminalNode + AllADD() []antlr.TerminalNode + ADD(i int) antlr.TerminalNode + AllDROP() []antlr.TerminalNode + DROP(i int) antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsAlter_server_audit_specificationContext differentiates from other interfaces. + IsAlter_server_audit_specificationContext() +} + +type Alter_server_audit_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + audit_specification_name IId_Context + audit_name IId_Context + audit_action_group_name IId_Context +} + +func NewEmptyAlter_server_audit_specificationContext() *Alter_server_audit_specificationContext { + var p = new(Alter_server_audit_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_server_audit_specification + return p +} + +func InitEmptyAlter_server_audit_specificationContext(p *Alter_server_audit_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_server_audit_specification +} + +func (*Alter_server_audit_specificationContext) IsAlter_server_audit_specificationContext() {} + +func NewAlter_server_audit_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_server_audit_specificationContext { + var p = new(Alter_server_audit_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_server_audit_specification + + return p +} + +func (s *Alter_server_audit_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_server_audit_specificationContext) GetAudit_specification_name() IId_Context { + return s.audit_specification_name +} + +func (s *Alter_server_audit_specificationContext) GetAudit_name() IId_Context { return s.audit_name } + +func (s *Alter_server_audit_specificationContext) GetAudit_action_group_name() IId_Context { + return s.audit_action_group_name +} + +func (s *Alter_server_audit_specificationContext) SetAudit_specification_name(v IId_Context) { + s.audit_specification_name = v +} + +func (s *Alter_server_audit_specificationContext) SetAudit_name(v IId_Context) { s.audit_name = v } + +func (s *Alter_server_audit_specificationContext) SetAudit_action_group_name(v IId_Context) { + s.audit_action_group_name = v +} + +func (s *Alter_server_audit_specificationContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_server_audit_specificationContext) AllSERVER() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSERVER) +} + +func (s *Alter_server_audit_specificationContext) SERVER(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, i) +} + +func (s *Alter_server_audit_specificationContext) AllAUDIT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAUDIT) +} + +func (s *Alter_server_audit_specificationContext) AUDIT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT, i) +} + +func (s *Alter_server_audit_specificationContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserSPECIFICATION, 0) +} + +func (s *Alter_server_audit_specificationContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_server_audit_specificationContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_server_audit_specificationContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Alter_server_audit_specificationContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Alter_server_audit_specificationContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Alter_server_audit_specificationContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Alter_server_audit_specificationContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Alter_server_audit_specificationContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_server_audit_specificationContext) STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATE, 0) +} + +func (s *Alter_server_audit_specificationContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_server_audit_specificationContext) AllADD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserADD) +} + +func (s *Alter_server_audit_specificationContext) ADD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserADD, i) +} + +func (s *Alter_server_audit_specificationContext) AllDROP() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDROP) +} + +func (s *Alter_server_audit_specificationContext) DROP(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, i) +} + +func (s *Alter_server_audit_specificationContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Alter_server_audit_specificationContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Alter_server_audit_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_server_audit_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_server_audit_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_server_audit_specification(s) + } +} + +func (s *Alter_server_audit_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_server_audit_specification(s) + } +} + +func (s *Alter_server_audit_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_server_audit_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_server_audit_specification() (localctx IAlter_server_audit_specificationContext) { + localctx = NewAlter_server_audit_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 406, TSqlParserRULE_alter_server_audit_specification) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5439) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5440) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5441) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5442) + p.Match(TSqlParserSPECIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5443) + + var _x = p.Id_() + + localctx.(*Alter_server_audit_specificationContext).audit_specification_name = _x + } + p.SetState(5448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR { + { + p.SetState(5444) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5445) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5446) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5447) + + var _x = p.Id_() + + localctx.(*Alter_server_audit_specificationContext).audit_name = _x + } + + } + p.SetState(5457) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 608, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5450) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserADD || _la == TSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5451) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5452) + + var _x = p.Id_() + + localctx.(*Alter_server_audit_specificationContext).audit_action_group_name = _x + } + { + p.SetState(5453) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5459) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 608, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(5466) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 609, p.GetParserRuleContext()) == 1 { + { + p.SetState(5460) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5461) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5462) + p.Match(TSqlParserSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5463) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5464) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5465) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_server_audit_specificationContext is an interface to support dynamic dispatch. +type ICreate_server_audit_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAudit_specification_name returns the audit_specification_name rule contexts. + GetAudit_specification_name() IId_Context + + // GetAudit_name returns the audit_name rule contexts. + GetAudit_name() IId_Context + + // GetAudit_action_group_name returns the audit_action_group_name rule contexts. + GetAudit_action_group_name() IId_Context + + // SetAudit_specification_name sets the audit_specification_name rule contexts. + SetAudit_specification_name(IId_Context) + + // SetAudit_name sets the audit_name rule contexts. + SetAudit_name(IId_Context) + + // SetAudit_action_group_name sets the audit_action_group_name rule contexts. + SetAudit_action_group_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + AllSERVER() []antlr.TerminalNode + SERVER(i int) antlr.TerminalNode + AllAUDIT() []antlr.TerminalNode + AUDIT(i int) antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + FOR() antlr.TerminalNode + AllADD() []antlr.TerminalNode + ADD(i int) antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + STATE() antlr.TerminalNode + EQUAL() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsCreate_server_audit_specificationContext differentiates from other interfaces. + IsCreate_server_audit_specificationContext() +} + +type Create_server_audit_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + audit_specification_name IId_Context + audit_name IId_Context + audit_action_group_name IId_Context +} + +func NewEmptyCreate_server_audit_specificationContext() *Create_server_audit_specificationContext { + var p = new(Create_server_audit_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_server_audit_specification + return p +} + +func InitEmptyCreate_server_audit_specificationContext(p *Create_server_audit_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_server_audit_specification +} + +func (*Create_server_audit_specificationContext) IsCreate_server_audit_specificationContext() {} + +func NewCreate_server_audit_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_server_audit_specificationContext { + var p = new(Create_server_audit_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_server_audit_specification + + return p +} + +func (s *Create_server_audit_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_server_audit_specificationContext) GetAudit_specification_name() IId_Context { + return s.audit_specification_name +} + +func (s *Create_server_audit_specificationContext) GetAudit_name() IId_Context { return s.audit_name } + +func (s *Create_server_audit_specificationContext) GetAudit_action_group_name() IId_Context { + return s.audit_action_group_name +} + +func (s *Create_server_audit_specificationContext) SetAudit_specification_name(v IId_Context) { + s.audit_specification_name = v +} + +func (s *Create_server_audit_specificationContext) SetAudit_name(v IId_Context) { s.audit_name = v } + +func (s *Create_server_audit_specificationContext) SetAudit_action_group_name(v IId_Context) { + s.audit_action_group_name = v +} + +func (s *Create_server_audit_specificationContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_server_audit_specificationContext) AllSERVER() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSERVER) +} + +func (s *Create_server_audit_specificationContext) SERVER(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, i) +} + +func (s *Create_server_audit_specificationContext) AllAUDIT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAUDIT) +} + +func (s *Create_server_audit_specificationContext) AUDIT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT, i) +} + +func (s *Create_server_audit_specificationContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserSPECIFICATION, 0) +} + +func (s *Create_server_audit_specificationContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_server_audit_specificationContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_server_audit_specificationContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_server_audit_specificationContext) AllADD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserADD) +} + +func (s *Create_server_audit_specificationContext) ADD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserADD, i) +} + +func (s *Create_server_audit_specificationContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Create_server_audit_specificationContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Create_server_audit_specificationContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Create_server_audit_specificationContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Create_server_audit_specificationContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_server_audit_specificationContext) STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATE, 0) +} + +func (s *Create_server_audit_specificationContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_server_audit_specificationContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Create_server_audit_specificationContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Create_server_audit_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_server_audit_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_server_audit_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_server_audit_specification(s) + } +} + +func (s *Create_server_audit_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_server_audit_specification(s) + } +} + +func (s *Create_server_audit_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_server_audit_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_server_audit_specification() (localctx ICreate_server_audit_specificationContext) { + localctx = NewCreate_server_audit_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 408, TSqlParserRULE_create_server_audit_specification) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5468) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5469) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5470) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5471) + p.Match(TSqlParserSPECIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5472) + + var _x = p.Id_() + + localctx.(*Create_server_audit_specificationContext).audit_specification_name = _x + } + p.SetState(5477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR { + { + p.SetState(5473) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5474) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5475) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5476) + + var _x = p.Id_() + + localctx.(*Create_server_audit_specificationContext).audit_name = _x + } + + } + p.SetState(5486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 611, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5479) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5480) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5481) + + var _x = p.Id_() + + localctx.(*Create_server_audit_specificationContext).audit_action_group_name = _x + } + { + p.SetState(5482) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5488) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 611, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(5495) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 612, p.GetParserRuleContext()) == 1 { + { + p.SetState(5489) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5490) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5491) + p.Match(TSqlParserSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5492) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5493) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5494) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_server_configurationContext is an interface to support dynamic dispatch. +type IAlter_server_configurationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SERVER() antlr.TerminalNode + CONFIGURATION() antlr.TerminalNode + AllSET() []antlr.TerminalNode + SET(i int) antlr.TerminalNode + PROCESS() antlr.TerminalNode + AFFINITY() antlr.TerminalNode + DIAGNOSTICS() antlr.TerminalNode + LOG() antlr.TerminalNode + FAILOVER() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + PROPERTY() antlr.TerminalNode + HADR() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + BUFFER() antlr.TerminalNode + POOL() antlr.TerminalNode + EXTENSION() antlr.TerminalNode + SOFTNUMA() antlr.TerminalNode + STRING() antlr.TerminalNode + LOCAL() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + CPU() antlr.TerminalNode + NUMANODE() antlr.TerminalNode + PATH() antlr.TerminalNode + MAX_SIZE() antlr.TerminalNode + MAX_FILES() antlr.TerminalNode + VERBOSELOGGING() antlr.TerminalNode + SQLDUMPERFLAGS() antlr.TerminalNode + SQLDUMPERPATH() antlr.TerminalNode + SQLDUMPERTIMEOUT() antlr.TerminalNode + FAILURECONDITIONLEVEL() antlr.TerminalNode + HEALTHCHECKTIMEOUT() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + FILENAME() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SIZE() antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + KB() antlr.TerminalNode + MB() antlr.TerminalNode + GB() antlr.TerminalNode + AUTO() antlr.TerminalNode + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + + // IsAlter_server_configurationContext differentiates from other interfaces. + IsAlter_server_configurationContext() +} + +type Alter_server_configurationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_server_configurationContext() *Alter_server_configurationContext { + var p = new(Alter_server_configurationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_server_configuration + return p +} + +func InitEmptyAlter_server_configurationContext(p *Alter_server_configurationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_server_configuration +} + +func (*Alter_server_configurationContext) IsAlter_server_configurationContext() {} + +func NewAlter_server_configurationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_server_configurationContext { + var p = new(Alter_server_configurationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_server_configuration + + return p +} + +func (s *Alter_server_configurationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_server_configurationContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_server_configurationContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Alter_server_configurationContext) CONFIGURATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONFIGURATION, 0) +} + +func (s *Alter_server_configurationContext) AllSET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSET) +} + +func (s *Alter_server_configurationContext) SET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSET, i) +} + +func (s *Alter_server_configurationContext) PROCESS() antlr.TerminalNode { + return s.GetToken(TSqlParserPROCESS, 0) +} + +func (s *Alter_server_configurationContext) AFFINITY() antlr.TerminalNode { + return s.GetToken(TSqlParserAFFINITY, 0) +} + +func (s *Alter_server_configurationContext) DIAGNOSTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserDIAGNOSTICS, 0) +} + +func (s *Alter_server_configurationContext) LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserLOG, 0) +} + +func (s *Alter_server_configurationContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(TSqlParserFAILOVER, 0) +} + +func (s *Alter_server_configurationContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(TSqlParserCLUSTER, 0) +} + +func (s *Alter_server_configurationContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserPROPERTY, 0) +} + +func (s *Alter_server_configurationContext) HADR() antlr.TerminalNode { + return s.GetToken(TSqlParserHADR, 0) +} + +func (s *Alter_server_configurationContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTEXT, 0) +} + +func (s *Alter_server_configurationContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_server_configurationContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_server_configurationContext) BUFFER() antlr.TerminalNode { + return s.GetToken(TSqlParserBUFFER, 0) +} + +func (s *Alter_server_configurationContext) POOL() antlr.TerminalNode { + return s.GetToken(TSqlParserPOOL, 0) +} + +func (s *Alter_server_configurationContext) EXTENSION() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTENSION, 0) +} + +func (s *Alter_server_configurationContext) SOFTNUMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSOFTNUMA, 0) +} + +func (s *Alter_server_configurationContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Alter_server_configurationContext) LOCAL() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL, 0) +} + +func (s *Alter_server_configurationContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Alter_server_configurationContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Alter_server_configurationContext) CPU() antlr.TerminalNode { + return s.GetToken(TSqlParserCPU, 0) +} + +func (s *Alter_server_configurationContext) NUMANODE() antlr.TerminalNode { + return s.GetToken(TSqlParserNUMANODE, 0) +} + +func (s *Alter_server_configurationContext) PATH() antlr.TerminalNode { + return s.GetToken(TSqlParserPATH, 0) +} + +func (s *Alter_server_configurationContext) MAX_SIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_SIZE, 0) +} + +func (s *Alter_server_configurationContext) MAX_FILES() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_FILES, 0) +} + +func (s *Alter_server_configurationContext) VERBOSELOGGING() antlr.TerminalNode { + return s.GetToken(TSqlParserVERBOSELOGGING, 0) +} + +func (s *Alter_server_configurationContext) SQLDUMPERFLAGS() antlr.TerminalNode { + return s.GetToken(TSqlParserSQLDUMPERFLAGS, 0) +} + +func (s *Alter_server_configurationContext) SQLDUMPERPATH() antlr.TerminalNode { + return s.GetToken(TSqlParserSQLDUMPERPATH, 0) +} + +func (s *Alter_server_configurationContext) SQLDUMPERTIMEOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserSQLDUMPERTIMEOUT, 0) +} + +func (s *Alter_server_configurationContext) FAILURECONDITIONLEVEL() antlr.TerminalNode { + return s.GetToken(TSqlParserFAILURECONDITIONLEVEL, 0) +} + +func (s *Alter_server_configurationContext) HEALTHCHECKTIMEOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserHEALTHCHECKTIMEOUT, 0) +} + +func (s *Alter_server_configurationContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Alter_server_configurationContext) FILENAME() antlr.TerminalNode { + return s.GetToken(TSqlParserFILENAME, 0) +} + +func (s *Alter_server_configurationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_server_configurationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_server_configurationContext) SIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserSIZE, 0) +} + +func (s *Alter_server_configurationContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Alter_server_configurationContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Alter_server_configurationContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Alter_server_configurationContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Alter_server_configurationContext) KB() antlr.TerminalNode { + return s.GetToken(TSqlParserKB, 0) +} + +func (s *Alter_server_configurationContext) MB() antlr.TerminalNode { + return s.GetToken(TSqlParserMB, 0) +} + +func (s *Alter_server_configurationContext) GB() antlr.TerminalNode { + return s.GetToken(TSqlParserGB, 0) +} + +func (s *Alter_server_configurationContext) AUTO() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO, 0) +} + +func (s *Alter_server_configurationContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTO) +} + +func (s *Alter_server_configurationContext) TO(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTO, i) +} + +func (s *Alter_server_configurationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_server_configurationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_server_configurationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_server_configuration(s) + } +} + +func (s *Alter_server_configurationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_server_configuration(s) + } +} + +func (s *Alter_server_configurationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_server_configuration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_server_configuration() (localctx IAlter_server_configurationContext) { + localctx = NewAlter_server_configurationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 410, TSqlParserRULE_alter_server_configuration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5497) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5498) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5499) + p.Match(TSqlParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5500) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(5606) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPROCESS: + { + p.SetState(5501) + p.Match(TSqlParserPROCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5502) + p.Match(TSqlParserAFFINITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCPU: + { + p.SetState(5503) + p.Match(TSqlParserCPU) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5504) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAUTO: + { + p.SetState(5505) + p.Match(TSqlParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL, TSqlParserCOMMA: + p.SetState(5516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserDECIMAL || _la == TSqlParserCOMMA { + p.SetState(5516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 615, p.GetParserRuleContext()) { + case 1: + p.SetState(5507) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5506) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5509) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(5511) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5510) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5513) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5514) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5515) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(5518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserNUMANODE: + { + p.SetState(5522) + p.Match(TSqlParserNUMANODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5523) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserDECIMAL || _la == TSqlParserCOMMA { + p.SetState(5534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 620, p.GetParserRuleContext()) { + case 1: + p.SetState(5525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5524) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5527) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(5529) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5528) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5531) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5532) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5533) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(5536) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserDIAGNOSTICS: + { + p.SetState(5540) + p.Match(TSqlParserDIAGNOSTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5541) + p.Match(TSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserON: + { + p.SetState(5542) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserOFF: + { + p.SetState(5543) + p.Match(TSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPATH: + { + p.SetState(5544) + p.Match(TSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5545) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5546) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDEFAULT || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserMAX_SIZE: + { + p.SetState(5547) + p.Match(TSqlParserMAX_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5548) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5552) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(5549) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5550) + p.Match(TSqlParserMB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDEFAULT: + { + p.SetState(5551) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserMAX_FILES: + { + p.SetState(5554) + p.Match(TSqlParserMAX_FILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5555) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5556) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDEFAULT || _la == TSqlParserDECIMAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserFAILOVER: + { + p.SetState(5559) + p.Match(TSqlParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5560) + p.Match(TSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5561) + p.Match(TSqlParserPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5579) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserVERBOSELOGGING: + { + p.SetState(5562) + p.Match(TSqlParserVERBOSELOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5563) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5564) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDEFAULT || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserSQLDUMPERFLAGS: + { + p.SetState(5565) + p.Match(TSqlParserSQLDUMPERFLAGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5566) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5567) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDEFAULT || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserSQLDUMPERPATH: + { + p.SetState(5568) + p.Match(TSqlParserSQLDUMPERPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5569) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5570) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDEFAULT || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserSQLDUMPERTIMEOUT: + { + p.SetState(5571) + p.Match(TSqlParserSQLDUMPERTIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5572) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDEFAULT || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserFAILURECONDITIONLEVEL: + { + p.SetState(5573) + p.Match(TSqlParserFAILURECONDITIONLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5574) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5575) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDEFAULT || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserHEALTHCHECKTIMEOUT: + { + p.SetState(5576) + p.Match(TSqlParserHEALTHCHECKTIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5577) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5578) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDEFAULT || _la == TSqlParserDECIMAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserHADR: + { + p.SetState(5581) + p.Match(TSqlParserHADR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5582) + p.Match(TSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5583) + p.Match(TSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5584) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5585) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOCAL || _la == TSqlParserSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserBUFFER: + { + p.SetState(5586) + p.Match(TSqlParserBUFFER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5587) + p.Match(TSqlParserPOOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5588) + p.Match(TSqlParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserON: + { + p.SetState(5589) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5590) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5591) + p.Match(TSqlParserFILENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5592) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5593) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5594) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5595) + p.Match(TSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5596) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5597) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5598) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserGB || _la == TSqlParserKB || _la == TSqlParserMB) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5599) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserOFF: + { + p.SetState(5600) + p.Match(TSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserSET: + { + p.SetState(5603) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5604) + p.Match(TSqlParserSOFTNUMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5605) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_server_roleContext is an interface to support dynamic dispatch. +type IAlter_server_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetServer_role_name returns the server_role_name rule contexts. + GetServer_role_name() IId_Context + + // GetServer_principal returns the server_principal rule contexts. + GetServer_principal() IId_Context + + // GetNew_server_role_name returns the new_server_role_name rule contexts. + GetNew_server_role_name() IId_Context + + // SetServer_role_name sets the server_role_name rule contexts. + SetServer_role_name(IId_Context) + + // SetServer_principal sets the server_principal rule contexts. + SetServer_principal(IId_Context) + + // SetNew_server_role_name sets the new_server_role_name rule contexts. + SetNew_server_role_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + SERVER() antlr.TerminalNode + ROLE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + MEMBER() antlr.TerminalNode + WITH() antlr.TerminalNode + NAME() antlr.TerminalNode + EQUAL() antlr.TerminalNode + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsAlter_server_roleContext differentiates from other interfaces. + IsAlter_server_roleContext() +} + +type Alter_server_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + server_role_name IId_Context + server_principal IId_Context + new_server_role_name IId_Context +} + +func NewEmptyAlter_server_roleContext() *Alter_server_roleContext { + var p = new(Alter_server_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_server_role + return p +} + +func InitEmptyAlter_server_roleContext(p *Alter_server_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_server_role +} + +func (*Alter_server_roleContext) IsAlter_server_roleContext() {} + +func NewAlter_server_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_server_roleContext { + var p = new(Alter_server_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_server_role + + return p +} + +func (s *Alter_server_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_server_roleContext) GetServer_role_name() IId_Context { return s.server_role_name } + +func (s *Alter_server_roleContext) GetServer_principal() IId_Context { return s.server_principal } + +func (s *Alter_server_roleContext) GetNew_server_role_name() IId_Context { + return s.new_server_role_name +} + +func (s *Alter_server_roleContext) SetServer_role_name(v IId_Context) { s.server_role_name = v } + +func (s *Alter_server_roleContext) SetServer_principal(v IId_Context) { s.server_principal = v } + +func (s *Alter_server_roleContext) SetNew_server_role_name(v IId_Context) { s.new_server_role_name = v } + +func (s *Alter_server_roleContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_server_roleContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Alter_server_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Alter_server_roleContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_server_roleContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_server_roleContext) MEMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserMEMBER, 0) +} + +func (s *Alter_server_roleContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_server_roleContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *Alter_server_roleContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_server_roleContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_server_roleContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Alter_server_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_server_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_server_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_server_role(s) + } +} + +func (s *Alter_server_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_server_role(s) + } +} + +func (s *Alter_server_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_server_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_server_role() (localctx IAlter_server_roleContext) { + localctx = NewAlter_server_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 412, TSqlParserRULE_alter_server_role) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5608) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5609) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5610) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5611) + + var _x = p.Id_() + + localctx.(*Alter_server_roleContext).server_role_name = _x + } + p.SetState(5619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserADD, TSqlParserDROP: + { + p.SetState(5612) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserADD || _la == TSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5613) + p.Match(TSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5614) + + var _x = p.Id_() + + localctx.(*Alter_server_roleContext).server_principal = _x + } + + case TSqlParserWITH: + { + p.SetState(5615) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5616) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5617) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5618) + + var _x = p.Id_() + + localctx.(*Alter_server_roleContext).new_server_role_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_server_roleContext is an interface to support dynamic dispatch. +type ICreate_server_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetServer_role returns the server_role rule contexts. + GetServer_role() IId_Context + + // GetServer_principal returns the server_principal rule contexts. + GetServer_principal() IId_Context + + // SetServer_role sets the server_role rule contexts. + SetServer_role(IId_Context) + + // SetServer_principal sets the server_principal rule contexts. + SetServer_principal(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + SERVER() antlr.TerminalNode + ROLE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AUTHORIZATION() antlr.TerminalNode + + // IsCreate_server_roleContext differentiates from other interfaces. + IsCreate_server_roleContext() +} + +type Create_server_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + server_role IId_Context + server_principal IId_Context +} + +func NewEmptyCreate_server_roleContext() *Create_server_roleContext { + var p = new(Create_server_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_server_role + return p +} + +func InitEmptyCreate_server_roleContext(p *Create_server_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_server_role +} + +func (*Create_server_roleContext) IsCreate_server_roleContext() {} + +func NewCreate_server_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_server_roleContext { + var p = new(Create_server_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_server_role + + return p +} + +func (s *Create_server_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_server_roleContext) GetServer_role() IId_Context { return s.server_role } + +func (s *Create_server_roleContext) GetServer_principal() IId_Context { return s.server_principal } + +func (s *Create_server_roleContext) SetServer_role(v IId_Context) { s.server_role = v } + +func (s *Create_server_roleContext) SetServer_principal(v IId_Context) { s.server_principal = v } + +func (s *Create_server_roleContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_server_roleContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Create_server_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Create_server_roleContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_server_roleContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_server_roleContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_server_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_server_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_server_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_server_role(s) + } +} + +func (s *Create_server_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_server_role(s) + } +} + +func (s *Create_server_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_server_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_server_role() (localctx ICreate_server_roleContext) { + localctx = NewCreate_server_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 414, TSqlParserRULE_create_server_role) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5621) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5622) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5623) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5624) + + var _x = p.Id_() + + localctx.(*Create_server_roleContext).server_role = _x + } + p.SetState(5627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(5625) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5626) + + var _x = p.Id_() + + localctx.(*Create_server_roleContext).server_principal = _x + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_server_role_pdwContext is an interface to support dynamic dispatch. +type IAlter_server_role_pdwContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetServer_role_name returns the server_role_name rule contexts. + GetServer_role_name() IId_Context + + // GetLogin returns the login rule contexts. + GetLogin() IId_Context + + // SetServer_role_name sets the server_role_name rule contexts. + SetServer_role_name(IId_Context) + + // SetLogin sets the login rule contexts. + SetLogin(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + SERVER() antlr.TerminalNode + ROLE() antlr.TerminalNode + MEMBER() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsAlter_server_role_pdwContext differentiates from other interfaces. + IsAlter_server_role_pdwContext() +} + +type Alter_server_role_pdwContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + server_role_name IId_Context + login IId_Context +} + +func NewEmptyAlter_server_role_pdwContext() *Alter_server_role_pdwContext { + var p = new(Alter_server_role_pdwContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_server_role_pdw + return p +} + +func InitEmptyAlter_server_role_pdwContext(p *Alter_server_role_pdwContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_server_role_pdw +} + +func (*Alter_server_role_pdwContext) IsAlter_server_role_pdwContext() {} + +func NewAlter_server_role_pdwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_server_role_pdwContext { + var p = new(Alter_server_role_pdwContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_server_role_pdw + + return p +} + +func (s *Alter_server_role_pdwContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_server_role_pdwContext) GetServer_role_name() IId_Context { return s.server_role_name } + +func (s *Alter_server_role_pdwContext) GetLogin() IId_Context { return s.login } + +func (s *Alter_server_role_pdwContext) SetServer_role_name(v IId_Context) { s.server_role_name = v } + +func (s *Alter_server_role_pdwContext) SetLogin(v IId_Context) { s.login = v } + +func (s *Alter_server_role_pdwContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_server_role_pdwContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Alter_server_role_pdwContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Alter_server_role_pdwContext) MEMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserMEMBER, 0) +} + +func (s *Alter_server_role_pdwContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_server_role_pdwContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_server_role_pdwContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_server_role_pdwContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Alter_server_role_pdwContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_server_role_pdwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_server_role_pdwContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_server_role_pdw(s) + } +} + +func (s *Alter_server_role_pdwContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_server_role_pdw(s) + } +} + +func (s *Alter_server_role_pdwContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_server_role_pdw(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_server_role_pdw() (localctx IAlter_server_role_pdwContext) { + localctx = NewAlter_server_role_pdwContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 416, TSqlParserRULE_alter_server_role_pdw) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5629) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5630) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5631) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5632) + + var _x = p.Id_() + + localctx.(*Alter_server_role_pdwContext).server_role_name = _x + } + { + p.SetState(5633) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserADD || _la == TSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5634) + p.Match(TSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5635) + + var _x = p.Id_() + + localctx.(*Alter_server_role_pdwContext).login = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_serviceContext is an interface to support dynamic dispatch. +type IAlter_serviceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetModified_service_name returns the modified_service_name rule contexts. + GetModified_service_name() IId_Context + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetQueue_name returns the queue_name rule contexts. + GetQueue_name() IId_Context + + // SetModified_service_name sets the modified_service_name rule contexts. + SetModified_service_name(IId_Context) + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetQueue_name sets the queue_name rule contexts. + SetQueue_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + SERVICE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ON() antlr.TerminalNode + QUEUE() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllOpt_arg_clause() []IOpt_arg_clauseContext + Opt_arg_clause(i int) IOpt_arg_clauseContext + RR_BRACKET() antlr.TerminalNode + DOT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_serviceContext differentiates from other interfaces. + IsAlter_serviceContext() +} + +type Alter_serviceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + modified_service_name IId_Context + schema_name IId_Context + queue_name IId_Context +} + +func NewEmptyAlter_serviceContext() *Alter_serviceContext { + var p = new(Alter_serviceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_service + return p +} + +func InitEmptyAlter_serviceContext(p *Alter_serviceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_service +} + +func (*Alter_serviceContext) IsAlter_serviceContext() {} + +func NewAlter_serviceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_serviceContext { + var p = new(Alter_serviceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_service + + return p +} + +func (s *Alter_serviceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_serviceContext) GetModified_service_name() IId_Context { return s.modified_service_name } + +func (s *Alter_serviceContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Alter_serviceContext) GetQueue_name() IId_Context { return s.queue_name } + +func (s *Alter_serviceContext) SetModified_service_name(v IId_Context) { s.modified_service_name = v } + +func (s *Alter_serviceContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Alter_serviceContext) SetQueue_name(v IId_Context) { s.queue_name = v } + +func (s *Alter_serviceContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_serviceContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *Alter_serviceContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_serviceContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_serviceContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Alter_serviceContext) QUEUE() antlr.TerminalNode { + return s.GetToken(TSqlParserQUEUE, 0) +} + +func (s *Alter_serviceContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Alter_serviceContext) AllOpt_arg_clause() []IOpt_arg_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOpt_arg_clauseContext); ok { + len++ + } + } + + tst := make([]IOpt_arg_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOpt_arg_clauseContext); ok { + tst[i] = t.(IOpt_arg_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_serviceContext) Opt_arg_clause(i int) IOpt_arg_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_arg_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOpt_arg_clauseContext) +} + +func (s *Alter_serviceContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Alter_serviceContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Alter_serviceContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_serviceContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_serviceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_serviceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_serviceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_service(s) + } +} + +func (s *Alter_serviceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_service(s) + } +} + +func (s *Alter_serviceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_service(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_service() (localctx IAlter_serviceContext) { + localctx = NewAlter_serviceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 418, TSqlParserRULE_alter_service) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5637) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5638) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5639) + + var _x = p.Id_() + + localctx.(*Alter_serviceContext).modified_service_name = _x + } + p.SetState(5648) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(5640) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5641) + p.Match(TSqlParserQUEUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5645) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 630, p.GetParserRuleContext()) == 1 { + { + p.SetState(5642) + + var _x = p.Id_() + + localctx.(*Alter_serviceContext).schema_name = _x + } + { + p.SetState(5643) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5647) + + var _x = p.Id_() + + localctx.(*Alter_serviceContext).queue_name = _x + } + + } + p.SetState(5661) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 633, p.GetParserRuleContext()) == 1 { + { + p.SetState(5650) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5651) + p.Opt_arg_clause() + } + p.SetState(5656) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(5652) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5653) + p.Opt_arg_clause() + } + + p.SetState(5658) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5659) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_arg_clauseContext is an interface to support dynamic dispatch. +type IOpt_arg_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetModified_contract_name returns the modified_contract_name rule contexts. + GetModified_contract_name() IId_Context + + // SetModified_contract_name sets the modified_contract_name rule contexts. + SetModified_contract_name(IId_Context) + + // Getter signatures + CONTRACT() antlr.TerminalNode + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + Id_() IId_Context + + // IsOpt_arg_clauseContext differentiates from other interfaces. + IsOpt_arg_clauseContext() +} + +type Opt_arg_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + modified_contract_name IId_Context +} + +func NewEmptyOpt_arg_clauseContext() *Opt_arg_clauseContext { + var p = new(Opt_arg_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_opt_arg_clause + return p +} + +func InitEmptyOpt_arg_clauseContext(p *Opt_arg_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_opt_arg_clause +} + +func (*Opt_arg_clauseContext) IsOpt_arg_clauseContext() {} + +func NewOpt_arg_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_arg_clauseContext { + var p = new(Opt_arg_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_opt_arg_clause + + return p +} + +func (s *Opt_arg_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_arg_clauseContext) GetModified_contract_name() IId_Context { + return s.modified_contract_name +} + +func (s *Opt_arg_clauseContext) SetModified_contract_name(v IId_Context) { + s.modified_contract_name = v +} + +func (s *Opt_arg_clauseContext) CONTRACT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTRACT, 0) +} + +func (s *Opt_arg_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Opt_arg_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Opt_arg_clauseContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Opt_arg_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_arg_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_arg_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOpt_arg_clause(s) + } +} + +func (s *Opt_arg_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOpt_arg_clause(s) + } +} + +func (s *Opt_arg_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOpt_arg_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Opt_arg_clause() (localctx IOpt_arg_clauseContext) { + localctx = NewOpt_arg_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 420, TSqlParserRULE_opt_arg_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5663) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserADD || _la == TSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5664) + p.Match(TSqlParserCONTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5665) + + var _x = p.Id_() + + localctx.(*Opt_arg_clauseContext).modified_contract_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_serviceContext is an interface to support dynamic dispatch. +type ICreate_serviceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCreate_service_name returns the create_service_name rule contexts. + GetCreate_service_name() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetQueue_name returns the queue_name rule contexts. + GetQueue_name() IId_Context + + // SetCreate_service_name sets the create_service_name rule contexts. + SetCreate_service_name(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetQueue_name sets the queue_name rule contexts. + SetQueue_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + SERVICE() antlr.TerminalNode + ON() antlr.TerminalNode + QUEUE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AUTHORIZATION() antlr.TerminalNode + DOT() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_serviceContext differentiates from other interfaces. + IsCreate_serviceContext() +} + +type Create_serviceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + create_service_name IId_Context + owner_name IId_Context + schema_name IId_Context + queue_name IId_Context +} + +func NewEmptyCreate_serviceContext() *Create_serviceContext { + var p = new(Create_serviceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_service + return p +} + +func InitEmptyCreate_serviceContext(p *Create_serviceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_service +} + +func (*Create_serviceContext) IsCreate_serviceContext() {} + +func NewCreate_serviceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_serviceContext { + var p = new(Create_serviceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_service + + return p +} + +func (s *Create_serviceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_serviceContext) GetCreate_service_name() IId_Context { return s.create_service_name } + +func (s *Create_serviceContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Create_serviceContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Create_serviceContext) GetQueue_name() IId_Context { return s.queue_name } + +func (s *Create_serviceContext) SetCreate_service_name(v IId_Context) { s.create_service_name = v } + +func (s *Create_serviceContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Create_serviceContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Create_serviceContext) SetQueue_name(v IId_Context) { s.queue_name = v } + +func (s *Create_serviceContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_serviceContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *Create_serviceContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Create_serviceContext) QUEUE() antlr.TerminalNode { + return s.GetToken(TSqlParserQUEUE, 0) +} + +func (s *Create_serviceContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_serviceContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_serviceContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_serviceContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Create_serviceContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_serviceContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_serviceContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDEFAULT) +} + +func (s *Create_serviceContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, i) +} + +func (s *Create_serviceContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_serviceContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_serviceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_serviceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_serviceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_service(s) + } +} + +func (s *Create_serviceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_service(s) + } +} + +func (s *Create_serviceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_service(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_service() (localctx ICreate_serviceContext) { + localctx = NewCreate_serviceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 422, TSqlParserRULE_create_service) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5667) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5668) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5669) + + var _x = p.Id_() + + localctx.(*Create_serviceContext).create_service_name = _x + } + p.SetState(5672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(5670) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5671) + + var _x = p.Id_() + + localctx.(*Create_serviceContext).owner_name = _x + } + + } + { + p.SetState(5674) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5675) + p.Match(TSqlParserQUEUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5679) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 635, p.GetParserRuleContext()) == 1 { + { + p.SetState(5676) + + var _x = p.Id_() + + localctx.(*Create_serviceContext).schema_name = _x + } + { + p.SetState(5677) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5681) + + var _x = p.Id_() + + localctx.(*Create_serviceContext).queue_name = _x + } + p.SetState(5695) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 639, p.GetParserRuleContext()) == 1 { + { + p.SetState(5682) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212729921) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&562949975835135) != 0) { + p.SetState(5684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5683) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(5686) + p.Id_() + } + + case TSqlParserDEFAULT: + { + p.SetState(5687) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5692) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5694) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_service_master_keyContext is an interface to support dynamic dispatch. +type IAlter_service_master_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAcold_account_name returns the acold_account_name token. + GetAcold_account_name() antlr.Token + + // GetOld_password returns the old_password token. + GetOld_password() antlr.Token + + // GetNew_account_name returns the new_account_name token. + GetNew_account_name() antlr.Token + + // GetNew_password returns the new_password token. + GetNew_password() antlr.Token + + // SetAcold_account_name sets the acold_account_name token. + SetAcold_account_name(antlr.Token) + + // SetOld_password sets the old_password token. + SetOld_password(antlr.Token) + + // SetNew_account_name sets the new_account_name token. + SetNew_account_name(antlr.Token) + + // SetNew_password sets the new_password token. + SetNew_password(antlr.Token) + + // Getter signatures + ALTER() antlr.TerminalNode + SERVICE() antlr.TerminalNode + MASTER() antlr.TerminalNode + KEY() antlr.TerminalNode + REGENERATE() antlr.TerminalNode + WITH() antlr.TerminalNode + FORCE() antlr.TerminalNode + OLD_ACCOUNT() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + OLD_PASSWORD() antlr.TerminalNode + NEW_ACCOUNT() antlr.TerminalNode + NEW_PASSWORD() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + + // IsAlter_service_master_keyContext differentiates from other interfaces. + IsAlter_service_master_keyContext() +} + +type Alter_service_master_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + acold_account_name antlr.Token + old_password antlr.Token + new_account_name antlr.Token + new_password antlr.Token +} + +func NewEmptyAlter_service_master_keyContext() *Alter_service_master_keyContext { + var p = new(Alter_service_master_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_service_master_key + return p +} + +func InitEmptyAlter_service_master_keyContext(p *Alter_service_master_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_service_master_key +} + +func (*Alter_service_master_keyContext) IsAlter_service_master_keyContext() {} + +func NewAlter_service_master_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_service_master_keyContext { + var p = new(Alter_service_master_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_service_master_key + + return p +} + +func (s *Alter_service_master_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_service_master_keyContext) GetAcold_account_name() antlr.Token { + return s.acold_account_name +} + +func (s *Alter_service_master_keyContext) GetOld_password() antlr.Token { return s.old_password } + +func (s *Alter_service_master_keyContext) GetNew_account_name() antlr.Token { + return s.new_account_name +} + +func (s *Alter_service_master_keyContext) GetNew_password() antlr.Token { return s.new_password } + +func (s *Alter_service_master_keyContext) SetAcold_account_name(v antlr.Token) { + s.acold_account_name = v +} + +func (s *Alter_service_master_keyContext) SetOld_password(v antlr.Token) { s.old_password = v } + +func (s *Alter_service_master_keyContext) SetNew_account_name(v antlr.Token) { s.new_account_name = v } + +func (s *Alter_service_master_keyContext) SetNew_password(v antlr.Token) { s.new_password = v } + +func (s *Alter_service_master_keyContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_service_master_keyContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *Alter_service_master_keyContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *Alter_service_master_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Alter_service_master_keyContext) REGENERATE() antlr.TerminalNode { + return s.GetToken(TSqlParserREGENERATE, 0) +} + +func (s *Alter_service_master_keyContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_service_master_keyContext) FORCE() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCE, 0) +} + +func (s *Alter_service_master_keyContext) OLD_ACCOUNT() antlr.TerminalNode { + return s.GetToken(TSqlParserOLD_ACCOUNT, 0) +} + +func (s *Alter_service_master_keyContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_service_master_keyContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_service_master_keyContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Alter_service_master_keyContext) OLD_PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserOLD_PASSWORD, 0) +} + +func (s *Alter_service_master_keyContext) NEW_ACCOUNT() antlr.TerminalNode { + return s.GetToken(TSqlParserNEW_ACCOUNT, 0) +} + +func (s *Alter_service_master_keyContext) NEW_PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserNEW_PASSWORD, 0) +} + +func (s *Alter_service_master_keyContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Alter_service_master_keyContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Alter_service_master_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_service_master_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_service_master_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_service_master_key(s) + } +} + +func (s *Alter_service_master_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_service_master_key(s) + } +} + +func (s *Alter_service_master_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_service_master_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_service_master_key() (localctx IAlter_service_master_keyContext) { + localctx = NewAlter_service_master_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 424, TSqlParserRULE_alter_service_master_key) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5697) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5698) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5699) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5700) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5722) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFORCE, TSqlParserREGENERATE: + p.SetState(5702) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFORCE { + { + p.SetState(5701) + p.Match(TSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5704) + p.Match(TSqlParserREGENERATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserWITH: + { + p.SetState(5705) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5720) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 641, p.GetParserRuleContext()) == 1 { + { + p.SetState(5706) + p.Match(TSqlParserOLD_ACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5707) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5708) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_service_master_keyContext).acold_account_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5709) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5710) + p.Match(TSqlParserOLD_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5711) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5712) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_service_master_keyContext).old_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 641, p.GetParserRuleContext()) == 2 { + { + p.SetState(5713) + p.Match(TSqlParserNEW_ACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5714) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5715) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_service_master_keyContext).new_account_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5716) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5717) + p.Match(TSqlParserNEW_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5718) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5719) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_service_master_keyContext).new_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_symmetric_keyContext is an interface to support dynamic dispatch. +type IAlter_symmetric_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // GetKey_name returns the key_name rule contexts. + GetKey_name() IId_Context + + // GetCertificate_name returns the certificate_name rule contexts. + GetCertificate_name() IId_Context + + // GetSymmetric_key_name returns the symmetric_key_name rule contexts. + GetSymmetric_key_name() IId_Context + + // GetAsym_key_name returns the Asym_key_name rule contexts. + GetAsym_key_name() IId_Context + + // SetKey_name sets the key_name rule contexts. + SetKey_name(IId_Context) + + // SetCertificate_name sets the certificate_name rule contexts. + SetCertificate_name(IId_Context) + + // SetSymmetric_key_name sets the symmetric_key_name rule contexts. + SetSymmetric_key_name(IId_Context) + + // SetAsym_key_name sets the Asym_key_name rule contexts. + SetAsym_key_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + AllSYMMETRIC() []antlr.TerminalNode + SYMMETRIC(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ENCRYPTION() antlr.TerminalNode + BY() antlr.TerminalNode + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + EQUAL() antlr.TerminalNode + ASYMMETRIC() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsAlter_symmetric_keyContext differentiates from other interfaces. + IsAlter_symmetric_keyContext() +} + +type Alter_symmetric_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + key_name IId_Context + certificate_name IId_Context + password antlr.Token + symmetric_key_name IId_Context + Asym_key_name IId_Context +} + +func NewEmptyAlter_symmetric_keyContext() *Alter_symmetric_keyContext { + var p = new(Alter_symmetric_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_symmetric_key + return p +} + +func InitEmptyAlter_symmetric_keyContext(p *Alter_symmetric_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_symmetric_key +} + +func (*Alter_symmetric_keyContext) IsAlter_symmetric_keyContext() {} + +func NewAlter_symmetric_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_symmetric_keyContext { + var p = new(Alter_symmetric_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_symmetric_key + + return p +} + +func (s *Alter_symmetric_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_symmetric_keyContext) GetPassword() antlr.Token { return s.password } + +func (s *Alter_symmetric_keyContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Alter_symmetric_keyContext) GetKey_name() IId_Context { return s.key_name } + +func (s *Alter_symmetric_keyContext) GetCertificate_name() IId_Context { return s.certificate_name } + +func (s *Alter_symmetric_keyContext) GetSymmetric_key_name() IId_Context { return s.symmetric_key_name } + +func (s *Alter_symmetric_keyContext) GetAsym_key_name() IId_Context { return s.Asym_key_name } + +func (s *Alter_symmetric_keyContext) SetKey_name(v IId_Context) { s.key_name = v } + +func (s *Alter_symmetric_keyContext) SetCertificate_name(v IId_Context) { s.certificate_name = v } + +func (s *Alter_symmetric_keyContext) SetSymmetric_key_name(v IId_Context) { s.symmetric_key_name = v } + +func (s *Alter_symmetric_keyContext) SetAsym_key_name(v IId_Context) { s.Asym_key_name = v } + +func (s *Alter_symmetric_keyContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_symmetric_keyContext) AllSYMMETRIC() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSYMMETRIC) +} + +func (s *Alter_symmetric_keyContext) SYMMETRIC(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSYMMETRIC, i) +} + +func (s *Alter_symmetric_keyContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserKEY) +} + +func (s *Alter_symmetric_keyContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, i) +} + +func (s *Alter_symmetric_keyContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_symmetric_keyContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_symmetric_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Alter_symmetric_keyContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Alter_symmetric_keyContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_symmetric_keyContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Alter_symmetric_keyContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Alter_symmetric_keyContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Alter_symmetric_keyContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_symmetric_keyContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, 0) +} + +func (s *Alter_symmetric_keyContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Alter_symmetric_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_symmetric_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_symmetric_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_symmetric_key(s) + } +} + +func (s *Alter_symmetric_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_symmetric_key(s) + } +} + +func (s *Alter_symmetric_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_symmetric_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_symmetric_key() (localctx IAlter_symmetric_keyContext) { + localctx = NewAlter_symmetric_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 426, TSqlParserRULE_alter_symmetric_key) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5724) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5725) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5726) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5727) + + var _x = p.Id_() + + localctx.(*Alter_symmetric_keyContext).key_name = _x + } + + { + p.SetState(5728) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserADD || _la == TSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5729) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5730) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCERTIFICATE: + { + p.SetState(5731) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5732) + + var _x = p.Id_() + + localctx.(*Alter_symmetric_keyContext).certificate_name = _x + } + + case TSqlParserPASSWORD: + { + p.SetState(5733) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5734) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5735) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Alter_symmetric_keyContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSYMMETRIC: + { + p.SetState(5736) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5737) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5738) + + var _x = p.Id_() + + localctx.(*Alter_symmetric_keyContext).symmetric_key_name = _x + } + + case TSqlParserASYMMETRIC: + { + p.SetState(5739) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5740) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5741) + + var _x = p.Id_() + + localctx.(*Alter_symmetric_keyContext).Asym_key_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_synonymContext is an interface to support dynamic dispatch. +type ICreate_synonymContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name_1 returns the schema_name_1 rule contexts. + GetSchema_name_1() IId_Context + + // GetSynonym_name returns the synonym_name rule contexts. + GetSynonym_name() IId_Context + + // GetServer_name returns the server_name rule contexts. + GetServer_name() IId_Context + + // GetDatabase_name returns the database_name rule contexts. + GetDatabase_name() IId_Context + + // GetSchema_name_2 returns the schema_name_2 rule contexts. + GetSchema_name_2() IId_Context + + // GetObject_name returns the object_name rule contexts. + GetObject_name() IId_Context + + // GetDatabase_or_schema2 returns the database_or_schema2 rule contexts. + GetDatabase_or_schema2() IId_Context + + // GetSchema_id_2_or_object_name returns the schema_id_2_or_object_name rule contexts. + GetSchema_id_2_or_object_name() IId_Context + + // SetSchema_name_1 sets the schema_name_1 rule contexts. + SetSchema_name_1(IId_Context) + + // SetSynonym_name sets the synonym_name rule contexts. + SetSynonym_name(IId_Context) + + // SetServer_name sets the server_name rule contexts. + SetServer_name(IId_Context) + + // SetDatabase_name sets the database_name rule contexts. + SetDatabase_name(IId_Context) + + // SetSchema_name_2 sets the schema_name_2 rule contexts. + SetSchema_name_2(IId_Context) + + // SetObject_name sets the object_name rule contexts. + SetObject_name(IId_Context) + + // SetDatabase_or_schema2 sets the database_or_schema2 rule contexts. + SetDatabase_or_schema2(IId_Context) + + // SetSchema_id_2_or_object_name sets the schema_id_2_or_object_name rule contexts. + SetSchema_id_2_or_object_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + FOR() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsCreate_synonymContext differentiates from other interfaces. + IsCreate_synonymContext() +} + +type Create_synonymContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name_1 IId_Context + synonym_name IId_Context + server_name IId_Context + database_name IId_Context + schema_name_2 IId_Context + object_name IId_Context + database_or_schema2 IId_Context + schema_id_2_or_object_name IId_Context +} + +func NewEmptyCreate_synonymContext() *Create_synonymContext { + var p = new(Create_synonymContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_synonym + return p +} + +func InitEmptyCreate_synonymContext(p *Create_synonymContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_synonym +} + +func (*Create_synonymContext) IsCreate_synonymContext() {} + +func NewCreate_synonymContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_synonymContext { + var p = new(Create_synonymContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_synonym + + return p +} + +func (s *Create_synonymContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_synonymContext) GetSchema_name_1() IId_Context { return s.schema_name_1 } + +func (s *Create_synonymContext) GetSynonym_name() IId_Context { return s.synonym_name } + +func (s *Create_synonymContext) GetServer_name() IId_Context { return s.server_name } + +func (s *Create_synonymContext) GetDatabase_name() IId_Context { return s.database_name } + +func (s *Create_synonymContext) GetSchema_name_2() IId_Context { return s.schema_name_2 } + +func (s *Create_synonymContext) GetObject_name() IId_Context { return s.object_name } + +func (s *Create_synonymContext) GetDatabase_or_schema2() IId_Context { return s.database_or_schema2 } + +func (s *Create_synonymContext) GetSchema_id_2_or_object_name() IId_Context { + return s.schema_id_2_or_object_name +} + +func (s *Create_synonymContext) SetSchema_name_1(v IId_Context) { s.schema_name_1 = v } + +func (s *Create_synonymContext) SetSynonym_name(v IId_Context) { s.synonym_name = v } + +func (s *Create_synonymContext) SetServer_name(v IId_Context) { s.server_name = v } + +func (s *Create_synonymContext) SetDatabase_name(v IId_Context) { s.database_name = v } + +func (s *Create_synonymContext) SetSchema_name_2(v IId_Context) { s.schema_name_2 = v } + +func (s *Create_synonymContext) SetObject_name(v IId_Context) { s.object_name = v } + +func (s *Create_synonymContext) SetDatabase_or_schema2(v IId_Context) { s.database_or_schema2 = v } + +func (s *Create_synonymContext) SetSchema_id_2_or_object_name(v IId_Context) { + s.schema_id_2_or_object_name = v +} + +func (s *Create_synonymContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_synonymContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(TSqlParserSYNONYM, 0) +} + +func (s *Create_synonymContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_synonymContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_synonymContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_synonymContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Create_synonymContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Create_synonymContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_synonymContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_synonymContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_synonym(s) + } +} + +func (s *Create_synonymContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_synonym(s) + } +} + +func (s *Create_synonymContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_synonym(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_synonym() (localctx ICreate_synonymContext) { + localctx = NewCreate_synonymContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 428, TSqlParserRULE_create_synonym) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5744) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5745) + p.Match(TSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5749) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 644, p.GetParserRuleContext()) == 1 { + { + p.SetState(5746) + + var _x = p.Id_() + + localctx.(*Create_synonymContext).schema_name_1 = _x + } + { + p.SetState(5747) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5751) + + var _x = p.Id_() + + localctx.(*Create_synonymContext).synonym_name = _x + } + { + p.SetState(5752) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5779) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 650, p.GetParserRuleContext()) { + case 1: + p.SetState(5756) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 645, p.GetParserRuleContext()) == 1 { + { + p.SetState(5753) + + var _x = p.Id_() + + localctx.(*Create_synonymContext).server_name = _x + } + { + p.SetState(5754) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5761) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 646, p.GetParserRuleContext()) == 1 { + { + p.SetState(5758) + + var _x = p.Id_() + + localctx.(*Create_synonymContext).database_name = _x + } + { + p.SetState(5759) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5766) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 647, p.GetParserRuleContext()) == 1 { + { + p.SetState(5763) + + var _x = p.Id_() + + localctx.(*Create_synonymContext).schema_name_2 = _x + } + { + p.SetState(5764) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5768) + + var _x = p.Id_() + + localctx.(*Create_synonymContext).object_name = _x + } + + case 2: + p.SetState(5772) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 648, p.GetParserRuleContext()) == 1 { + { + p.SetState(5769) + + var _x = p.Id_() + + localctx.(*Create_synonymContext).database_or_schema2 = _x + } + { + p.SetState(5770) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5777) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 649, p.GetParserRuleContext()) == 1 { + { + p.SetState(5774) + + var _x = p.Id_() + + localctx.(*Create_synonymContext).schema_id_2_or_object_name = _x + } + { + p.SetState(5775) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_userContext is an interface to support dynamic dispatch. +type IAlter_userContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLcid returns the lcid token. + GetLcid() antlr.Token + + // SetLcid sets the lcid token. + SetLcid(antlr.Token) + + // GetUsername returns the username rule contexts. + GetUsername() IId_Context + + // GetNewusername returns the newusername rule contexts. + GetNewusername() IId_Context + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetLoginame returns the loginame rule contexts. + GetLoginame() IId_Context + + // GetLanguage_name_or_alias returns the language_name_or_alias rule contexts. + GetLanguage_name_or_alias() IId_Context + + // SetUsername sets the username rule contexts. + SetUsername(IId_Context) + + // SetNewusername sets the newusername rule contexts. + SetNewusername(IId_Context) + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetLoginame sets the loginame rule contexts. + SetLoginame(IId_Context) + + // SetLanguage_name_or_alias sets the language_name_or_alias rule contexts. + SetLanguage_name_or_alias(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + USER() antlr.TerminalNode + WITH() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllNAME() []antlr.TerminalNode + NAME(i int) antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllDEFAULT_SCHEMA() []antlr.TerminalNode + DEFAULT_SCHEMA(i int) antlr.TerminalNode + AllLOGIN() []antlr.TerminalNode + LOGIN(i int) antlr.TerminalNode + AllPASSWORD() []antlr.TerminalNode + PASSWORD(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllDEFAULT_LANGUAGE() []antlr.TerminalNode + DEFAULT_LANGUAGE(i int) antlr.TerminalNode + AllALLOW_ENCRYPTED_VALUE_MODIFICATIONS() []antlr.TerminalNode + ALLOW_ENCRYPTED_VALUE_MODIFICATIONS(i int) antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllOFF() []antlr.TerminalNode + OFF(i int) antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + AllNONE() []antlr.TerminalNode + NONE(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllOLD_PASSWORD() []antlr.TerminalNode + OLD_PASSWORD(i int) antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + + // IsAlter_userContext differentiates from other interfaces. + IsAlter_userContext() +} + +type Alter_userContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + username IId_Context + newusername IId_Context + schema_name IId_Context + loginame IId_Context + lcid antlr.Token + language_name_or_alias IId_Context +} + +func NewEmptyAlter_userContext() *Alter_userContext { + var p = new(Alter_userContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_user + return p +} + +func InitEmptyAlter_userContext(p *Alter_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_user +} + +func (*Alter_userContext) IsAlter_userContext() {} + +func NewAlter_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_userContext { + var p = new(Alter_userContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_user + + return p +} + +func (s *Alter_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_userContext) GetLcid() antlr.Token { return s.lcid } + +func (s *Alter_userContext) SetLcid(v antlr.Token) { s.lcid = v } + +func (s *Alter_userContext) GetUsername() IId_Context { return s.username } + +func (s *Alter_userContext) GetNewusername() IId_Context { return s.newusername } + +func (s *Alter_userContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Alter_userContext) GetLoginame() IId_Context { return s.loginame } + +func (s *Alter_userContext) GetLanguage_name_or_alias() IId_Context { return s.language_name_or_alias } + +func (s *Alter_userContext) SetUsername(v IId_Context) { s.username = v } + +func (s *Alter_userContext) SetNewusername(v IId_Context) { s.newusername = v } + +func (s *Alter_userContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Alter_userContext) SetLoginame(v IId_Context) { s.loginame = v } + +func (s *Alter_userContext) SetLanguage_name_or_alias(v IId_Context) { s.language_name_or_alias = v } + +func (s *Alter_userContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_userContext) USER() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER, 0) +} + +func (s *Alter_userContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_userContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_userContext) AllNAME() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNAME) +} + +func (s *Alter_userContext) NAME(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, i) +} + +func (s *Alter_userContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_userContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_userContext) AllDEFAULT_SCHEMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDEFAULT_SCHEMA) +} + +func (s *Alter_userContext) DEFAULT_SCHEMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_SCHEMA, i) +} + +func (s *Alter_userContext) AllLOGIN() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOGIN) +} + +func (s *Alter_userContext) LOGIN(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, i) +} + +func (s *Alter_userContext) AllPASSWORD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserPASSWORD) +} + +func (s *Alter_userContext) PASSWORD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, i) +} + +func (s *Alter_userContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Alter_userContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Alter_userContext) AllDEFAULT_LANGUAGE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDEFAULT_LANGUAGE) +} + +func (s *Alter_userContext) DEFAULT_LANGUAGE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_LANGUAGE, i) +} + +func (s *Alter_userContext) AllALLOW_ENCRYPTED_VALUE_MODIFICATIONS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS) +} + +func (s *Alter_userContext) ALLOW_ENCRYPTED_VALUE_MODIFICATIONS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, i) +} + +func (s *Alter_userContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Alter_userContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Alter_userContext) AllOFF() []antlr.TerminalNode { + return s.GetTokens(TSqlParserOFF) +} + +func (s *Alter_userContext) OFF(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, i) +} + +func (s *Alter_userContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNULL_) +} + +func (s *Alter_userContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_, i) +} + +func (s *Alter_userContext) AllNONE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNONE) +} + +func (s *Alter_userContext) NONE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, i) +} + +func (s *Alter_userContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_userContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_userContext) AllOLD_PASSWORD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserOLD_PASSWORD) +} + +func (s *Alter_userContext) OLD_PASSWORD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserOLD_PASSWORD, i) +} + +func (s *Alter_userContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Alter_userContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Alter_userContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_userContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_userContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_user(s) + } +} + +func (s *Alter_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_user(s) + } +} + +func (s *Alter_userContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_user(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_user() (localctx IAlter_userContext) { + localctx = NewAlter_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 430, TSqlParserRULE_alter_user) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5781) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5782) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5783) + + var _x = p.Id_() + + localctx.(*Alter_userContext).username = _x + } + { + p.SetState(5784) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5835) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(5835) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 660, p.GetParserRuleContext()) { + case 1: + p.SetState(5786) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5785) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5788) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5789) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5790) + + var _x = p.Id_() + + localctx.(*Alter_userContext).newusername = _x + } + + case 2: + p.SetState(5792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5791) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5794) + p.Match(TSqlParserDEFAULT_SCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5795) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5798) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(5796) + + var _x = p.Id_() + + localctx.(*Alter_userContext).schema_name = _x + } + + case TSqlParserNULL_: + { + p.SetState(5797) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 3: + p.SetState(5801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5800) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5803) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5804) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5805) + + var _x = p.Id_() + + localctx.(*Alter_userContext).loginame = _x + } + + case 4: + p.SetState(5807) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5806) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5809) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5810) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5811) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(5812) + p.Match(TSqlParserOLD_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5813) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5814) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5817) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 656, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 5: + p.SetState(5820) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5819) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5822) + p.Match(TSqlParserDEFAULT_LANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5823) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5827) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 658, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5824) + p.Match(TSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(5825) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_userContext).lcid = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(5826) + + var _x = p.Id_() + + localctx.(*Alter_userContext).language_name_or_alias = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 6: + p.SetState(5830) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5829) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5832) + p.Match(TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5833) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5834) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5837) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 661, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_userContext is an interface to support dynamic dispatch. +type ICreate_userContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // GetUser_name returns the user_name rule contexts. + GetUser_name() IId_Context + + // GetLogin_name returns the login_name rule contexts. + GetLogin_name() IId_Context + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetWindows_principal returns the windows_principal rule contexts. + GetWindows_principal() IId_Context + + // GetLanguage_name_or_alias returns the language_name_or_alias rule contexts. + GetLanguage_name_or_alias() IId_Context + + // GetAzure_Active_Directory_principal returns the Azure_Active_Directory_principal rule contexts. + GetAzure_Active_Directory_principal() IId_Context + + // GetCert_name returns the cert_name rule contexts. + GetCert_name() IId_Context + + // GetAsym_key_name returns the asym_key_name rule contexts. + GetAsym_key_name() IId_Context + + // SetUser_name sets the user_name rule contexts. + SetUser_name(IId_Context) + + // SetLogin_name sets the login_name rule contexts. + SetLogin_name(IId_Context) + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetWindows_principal sets the windows_principal rule contexts. + SetWindows_principal(IId_Context) + + // SetLanguage_name_or_alias sets the language_name_or_alias rule contexts. + SetLanguage_name_or_alias(IId_Context) + + // SetAzure_Active_Directory_principal sets the Azure_Active_Directory_principal rule contexts. + SetAzure_Active_Directory_principal(IId_Context) + + // SetCert_name sets the cert_name rule contexts. + SetCert_name(IId_Context) + + // SetAsym_key_name sets the asym_key_name rule contexts. + SetAsym_key_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + USER() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + LOGIN() antlr.TerminalNode + WITH() antlr.TerminalNode + FOR() antlr.TerminalNode + FROM() antlr.TerminalNode + AllDEFAULT_SCHEMA() []antlr.TerminalNode + DEFAULT_SCHEMA(i int) antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllALLOW_ENCRYPTED_VALUE_MODIFICATIONS() []antlr.TerminalNode + ALLOW_ENCRYPTED_VALUE_MODIFICATIONS(i int) antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllOFF() []antlr.TerminalNode + OFF(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + PASSWORD() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + STRING() antlr.TerminalNode + AllDEFAULT_LANGUAGE() []antlr.TerminalNode + DEFAULT_LANGUAGE(i int) antlr.TerminalNode + AllSID() []antlr.TerminalNode + SID(i int) antlr.TerminalNode + AllBINARY() []antlr.TerminalNode + BINARY(i int) antlr.TerminalNode + AllNONE() []antlr.TerminalNode + NONE(i int) antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + WITHOUT() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + ASYMMETRIC() antlr.TerminalNode + KEY() antlr.TerminalNode + + // IsCreate_userContext differentiates from other interfaces. + IsCreate_userContext() +} + +type Create_userContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + user_name IId_Context + login_name IId_Context + schema_name IId_Context + windows_principal IId_Context + language_name_or_alias IId_Context + password antlr.Token + Azure_Active_Directory_principal IId_Context + cert_name IId_Context + asym_key_name IId_Context +} + +func NewEmptyCreate_userContext() *Create_userContext { + var p = new(Create_userContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_user + return p +} + +func InitEmptyCreate_userContext(p *Create_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_user +} + +func (*Create_userContext) IsCreate_userContext() {} + +func NewCreate_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_userContext { + var p = new(Create_userContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_user + + return p +} + +func (s *Create_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_userContext) GetPassword() antlr.Token { return s.password } + +func (s *Create_userContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Create_userContext) GetUser_name() IId_Context { return s.user_name } + +func (s *Create_userContext) GetLogin_name() IId_Context { return s.login_name } + +func (s *Create_userContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Create_userContext) GetWindows_principal() IId_Context { return s.windows_principal } + +func (s *Create_userContext) GetLanguage_name_or_alias() IId_Context { return s.language_name_or_alias } + +func (s *Create_userContext) GetAzure_Active_Directory_principal() IId_Context { + return s.Azure_Active_Directory_principal +} + +func (s *Create_userContext) GetCert_name() IId_Context { return s.cert_name } + +func (s *Create_userContext) GetAsym_key_name() IId_Context { return s.asym_key_name } + +func (s *Create_userContext) SetUser_name(v IId_Context) { s.user_name = v } + +func (s *Create_userContext) SetLogin_name(v IId_Context) { s.login_name = v } + +func (s *Create_userContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Create_userContext) SetWindows_principal(v IId_Context) { s.windows_principal = v } + +func (s *Create_userContext) SetLanguage_name_or_alias(v IId_Context) { s.language_name_or_alias = v } + +func (s *Create_userContext) SetAzure_Active_Directory_principal(v IId_Context) { + s.Azure_Active_Directory_principal = v +} + +func (s *Create_userContext) SetCert_name(v IId_Context) { s.cert_name = v } + +func (s *Create_userContext) SetAsym_key_name(v IId_Context) { s.asym_key_name = v } + +func (s *Create_userContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_userContext) USER() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER, 0) +} + +func (s *Create_userContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_userContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_userContext) LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, 0) +} + +func (s *Create_userContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_userContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_userContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Create_userContext) AllDEFAULT_SCHEMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDEFAULT_SCHEMA) +} + +func (s *Create_userContext) DEFAULT_SCHEMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_SCHEMA, i) +} + +func (s *Create_userContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_userContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_userContext) AllALLOW_ENCRYPTED_VALUE_MODIFICATIONS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS) +} + +func (s *Create_userContext) ALLOW_ENCRYPTED_VALUE_MODIFICATIONS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, i) +} + +func (s *Create_userContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Create_userContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Create_userContext) AllOFF() []antlr.TerminalNode { + return s.GetTokens(TSqlParserOFF) +} + +func (s *Create_userContext) OFF(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, i) +} + +func (s *Create_userContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_userContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_userContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Create_userContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Create_userContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER, 0) +} + +func (s *Create_userContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_userContext) AllDEFAULT_LANGUAGE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDEFAULT_LANGUAGE) +} + +func (s *Create_userContext) DEFAULT_LANGUAGE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_LANGUAGE, i) +} + +func (s *Create_userContext) AllSID() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSID) +} + +func (s *Create_userContext) SID(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSID, i) +} + +func (s *Create_userContext) AllBINARY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBINARY) +} + +func (s *Create_userContext) BINARY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY, i) +} + +func (s *Create_userContext) AllNONE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNONE) +} + +func (s *Create_userContext) NONE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, i) +} + +func (s *Create_userContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Create_userContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Create_userContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserWITHOUT, 0) +} + +func (s *Create_userContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Create_userContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, 0) +} + +func (s *Create_userContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Create_userContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_userContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_userContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_user(s) + } +} + +func (s *Create_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_user(s) + } +} + +func (s *Create_userContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_user(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_user() (localctx ICreate_userContext) { + localctx = NewCreate_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 432, TSqlParserRULE_create_user) + var _la int + + var _alt int + + p.SetState(5985) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 689, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5839) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5840) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5841) + + var _x = p.Id_() + + localctx.(*Create_userContext).user_name = _x + } + p.SetState(5845) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR || _la == TSqlParserFROM { + { + p.SetState(5842) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFOR || _la == TSqlParserFROM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5843) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5844) + + var _x = p.Id_() + + localctx.(*Create_userContext).login_name = _x + } + + } + p.SetState(5865) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 667, p.GetParserRuleContext()) == 1 { + { + p.SetState(5847) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 666, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(5860) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 665, p.GetParserRuleContext()) { + case 1: + p.SetState(5849) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5848) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5851) + p.Match(TSqlParserDEFAULT_SCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5852) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5853) + + var _x = p.Id_() + + localctx.(*Create_userContext).schema_name = _x + } + + case 2: + p.SetState(5855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5854) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5857) + p.Match(TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5858) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5859) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(5864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 666, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5867) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5868) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 683, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5869) + + var _x = p.Id_() + + localctx.(*Create_userContext).windows_principal = _x + } + p.SetState(5904) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 675, p.GetParserRuleContext()) == 1 { + { + p.SetState(5870) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 674, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(5899) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 673, p.GetParserRuleContext()) { + case 1: + p.SetState(5872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5871) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5874) + p.Match(TSqlParserDEFAULT_SCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5875) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5876) + + var _x = p.Id_() + + localctx.(*Create_userContext).schema_name = _x + } + + case 2: + p.SetState(5878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5877) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5880) + p.Match(TSqlParserDEFAULT_LANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5881) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 670, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5882) + p.Match(TSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(5883) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(5884) + + var _x = p.Id_() + + localctx.(*Create_userContext).language_name_or_alias = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 3: + p.SetState(5888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5887) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5890) + p.Match(TSqlParserSID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5891) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5892) + p.Match(TSqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.SetState(5894) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5893) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5896) + p.Match(TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5897) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5898) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(5903) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 674, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(5906) + + var _x = p.Id_() + + localctx.(*Create_userContext).user_name = _x + } + { + p.SetState(5907) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5908) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5909) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5910) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_userContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5941) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 682, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(5939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 681, p.GetParserRuleContext()) { + case 1: + p.SetState(5912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5911) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5914) + p.Match(TSqlParserDEFAULT_SCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5915) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5916) + + var _x = p.Id_() + + localctx.(*Create_userContext).schema_name = _x + } + + case 2: + p.SetState(5918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5917) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5920) + p.Match(TSqlParserDEFAULT_LANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5921) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5925) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 678, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5922) + p.Match(TSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(5923) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(5924) + + var _x = p.Id_() + + localctx.(*Create_userContext).language_name_or_alias = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 3: + p.SetState(5928) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5927) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5930) + p.Match(TSqlParserSID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5931) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5932) + p.Match(TSqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.SetState(5934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5933) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5936) + p.Match(TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5937) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5938) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(5943) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 682, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 3: + { + p.SetState(5944) + + var _x = p.Id_() + + localctx.(*Create_userContext).Azure_Active_Directory_principal = _x + } + { + p.SetState(5945) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5946) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5947) + p.Match(TSqlParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5951) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5952) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5953) + + var _x = p.Id_() + + localctx.(*Create_userContext).user_name = _x + } + p.SetState(5980) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 688, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5954) + p.Match(TSqlParserWITHOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5955) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5970) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 687, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(5968) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 686, p.GetParserRuleContext()) { + case 1: + p.SetState(5957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5956) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5959) + p.Match(TSqlParserDEFAULT_SCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5960) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5961) + + var _x = p.Id_() + + localctx.(*Create_userContext).schema_name = _x + } + + case 2: + p.SetState(5963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(5962) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5965) + p.Match(TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5966) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5967) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(5972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 687, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + { + p.SetState(5973) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFOR || _la == TSqlParserFROM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5974) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5975) + + var _x = p.Id_() + + localctx.(*Create_userContext).cert_name = _x + } + + case 3: + { + p.SetState(5976) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFOR || _la == TSqlParserFROM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5977) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5978) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5979) + + var _x = p.Id_() + + localctx.(*Create_userContext).asym_key_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5982) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5983) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5984) + + var _x = p.Id_() + + localctx.(*Create_userContext).user_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_user_azure_sql_dwContext is an interface to support dynamic dispatch. +type ICreate_user_azure_sql_dwContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUser_name returns the user_name rule contexts. + GetUser_name() IId_Context + + // GetLogin_name returns the login_name rule contexts. + GetLogin_name() IId_Context + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetAzure_Active_Directory_principal returns the Azure_Active_Directory_principal rule contexts. + GetAzure_Active_Directory_principal() IId_Context + + // SetUser_name sets the user_name rule contexts. + SetUser_name(IId_Context) + + // SetLogin_name sets the login_name rule contexts. + SetLogin_name(IId_Context) + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetAzure_Active_Directory_principal sets the Azure_Active_Directory_principal rule contexts. + SetAzure_Active_Directory_principal(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + USER() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + LOGIN() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + WITH() antlr.TerminalNode + DEFAULT_SCHEMA() antlr.TerminalNode + EQUAL() antlr.TerminalNode + FOR() antlr.TerminalNode + FROM() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + + // IsCreate_user_azure_sql_dwContext differentiates from other interfaces. + IsCreate_user_azure_sql_dwContext() +} + +type Create_user_azure_sql_dwContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + user_name IId_Context + login_name IId_Context + schema_name IId_Context + Azure_Active_Directory_principal IId_Context +} + +func NewEmptyCreate_user_azure_sql_dwContext() *Create_user_azure_sql_dwContext { + var p = new(Create_user_azure_sql_dwContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_user_azure_sql_dw + return p +} + +func InitEmptyCreate_user_azure_sql_dwContext(p *Create_user_azure_sql_dwContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_user_azure_sql_dw +} + +func (*Create_user_azure_sql_dwContext) IsCreate_user_azure_sql_dwContext() {} + +func NewCreate_user_azure_sql_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_user_azure_sql_dwContext { + var p = new(Create_user_azure_sql_dwContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_user_azure_sql_dw + + return p +} + +func (s *Create_user_azure_sql_dwContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_user_azure_sql_dwContext) GetUser_name() IId_Context { return s.user_name } + +func (s *Create_user_azure_sql_dwContext) GetLogin_name() IId_Context { return s.login_name } + +func (s *Create_user_azure_sql_dwContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Create_user_azure_sql_dwContext) GetAzure_Active_Directory_principal() IId_Context { + return s.Azure_Active_Directory_principal +} + +func (s *Create_user_azure_sql_dwContext) SetUser_name(v IId_Context) { s.user_name = v } + +func (s *Create_user_azure_sql_dwContext) SetLogin_name(v IId_Context) { s.login_name = v } + +func (s *Create_user_azure_sql_dwContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Create_user_azure_sql_dwContext) SetAzure_Active_Directory_principal(v IId_Context) { + s.Azure_Active_Directory_principal = v +} + +func (s *Create_user_azure_sql_dwContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_user_azure_sql_dwContext) USER() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER, 0) +} + +func (s *Create_user_azure_sql_dwContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_user_azure_sql_dwContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_user_azure_sql_dwContext) LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, 0) +} + +func (s *Create_user_azure_sql_dwContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserWITHOUT, 0) +} + +func (s *Create_user_azure_sql_dwContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_user_azure_sql_dwContext) DEFAULT_SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_SCHEMA, 0) +} + +func (s *Create_user_azure_sql_dwContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_user_azure_sql_dwContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_user_azure_sql_dwContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Create_user_azure_sql_dwContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Create_user_azure_sql_dwContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER, 0) +} + +func (s *Create_user_azure_sql_dwContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_user_azure_sql_dwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_user_azure_sql_dwContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_user_azure_sql_dw(s) + } +} + +func (s *Create_user_azure_sql_dwContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_user_azure_sql_dw(s) + } +} + +func (s *Create_user_azure_sql_dwContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_user_azure_sql_dw(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_user_azure_sql_dw() (localctx ICreate_user_azure_sql_dwContext) { + localctx = NewCreate_user_azure_sql_dwContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 434, TSqlParserRULE_create_user_azure_sql_dw) + var _la int + + p.SetState(6015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 693, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5987) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5988) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5989) + + var _x = p.Id_() + + localctx.(*Create_user_azure_sql_dwContext).user_name = _x + } + p.SetState(5995) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 690, p.GetParserRuleContext()) == 1 { + { + p.SetState(5990) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFOR || _la == TSqlParserFROM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5991) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5992) + + var _x = p.Id_() + + localctx.(*Create_user_azure_sql_dwContext).login_name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 690, p.GetParserRuleContext()) == 2 { + { + p.SetState(5993) + p.Match(TSqlParserWITHOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5994) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6001) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 691, p.GetParserRuleContext()) == 1 { + { + p.SetState(5997) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5998) + p.Match(TSqlParserDEFAULT_SCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5999) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6000) + + var _x = p.Id_() + + localctx.(*Create_user_azure_sql_dwContext).schema_name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6003) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6004) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6005) + + var _x = p.Id_() + + localctx.(*Create_user_azure_sql_dwContext).Azure_Active_Directory_principal = _x + } + { + p.SetState(6006) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6007) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6008) + p.Match(TSqlParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6013) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 692, p.GetParserRuleContext()) == 1 { + { + p.SetState(6009) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6010) + p.Match(TSqlParserDEFAULT_SCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6011) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6012) + + var _x = p.Id_() + + localctx.(*Create_user_azure_sql_dwContext).schema_name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_user_azure_sqlContext is an interface to support dynamic dispatch. +type IAlter_user_azure_sqlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUsername returns the username rule contexts. + GetUsername() IId_Context + + // GetNewusername returns the newusername rule contexts. + GetNewusername() IId_Context + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetLoginame returns the loginame rule contexts. + GetLoginame() IId_Context + + // SetUsername sets the username rule contexts. + SetUsername(IId_Context) + + // SetNewusername sets the newusername rule contexts. + SetNewusername(IId_Context) + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetLoginame sets the loginame rule contexts. + SetLoginame(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + USER() antlr.TerminalNode + WITH() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllNAME() []antlr.TerminalNode + NAME(i int) antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllDEFAULT_SCHEMA() []antlr.TerminalNode + DEFAULT_SCHEMA(i int) antlr.TerminalNode + AllLOGIN() []antlr.TerminalNode + LOGIN(i int) antlr.TerminalNode + AllALLOW_ENCRYPTED_VALUE_MODIFICATIONS() []antlr.TerminalNode + ALLOW_ENCRYPTED_VALUE_MODIFICATIONS(i int) antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllOFF() []antlr.TerminalNode + OFF(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_user_azure_sqlContext differentiates from other interfaces. + IsAlter_user_azure_sqlContext() +} + +type Alter_user_azure_sqlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + username IId_Context + newusername IId_Context + schema_name IId_Context + loginame IId_Context +} + +func NewEmptyAlter_user_azure_sqlContext() *Alter_user_azure_sqlContext { + var p = new(Alter_user_azure_sqlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_user_azure_sql + return p +} + +func InitEmptyAlter_user_azure_sqlContext(p *Alter_user_azure_sqlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_user_azure_sql +} + +func (*Alter_user_azure_sqlContext) IsAlter_user_azure_sqlContext() {} + +func NewAlter_user_azure_sqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_user_azure_sqlContext { + var p = new(Alter_user_azure_sqlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_user_azure_sql + + return p +} + +func (s *Alter_user_azure_sqlContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_user_azure_sqlContext) GetUsername() IId_Context { return s.username } + +func (s *Alter_user_azure_sqlContext) GetNewusername() IId_Context { return s.newusername } + +func (s *Alter_user_azure_sqlContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Alter_user_azure_sqlContext) GetLoginame() IId_Context { return s.loginame } + +func (s *Alter_user_azure_sqlContext) SetUsername(v IId_Context) { s.username = v } + +func (s *Alter_user_azure_sqlContext) SetNewusername(v IId_Context) { s.newusername = v } + +func (s *Alter_user_azure_sqlContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Alter_user_azure_sqlContext) SetLoginame(v IId_Context) { s.loginame = v } + +func (s *Alter_user_azure_sqlContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_user_azure_sqlContext) USER() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER, 0) +} + +func (s *Alter_user_azure_sqlContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_user_azure_sqlContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_user_azure_sqlContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_user_azure_sqlContext) AllNAME() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNAME) +} + +func (s *Alter_user_azure_sqlContext) NAME(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, i) +} + +func (s *Alter_user_azure_sqlContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_user_azure_sqlContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_user_azure_sqlContext) AllDEFAULT_SCHEMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDEFAULT_SCHEMA) +} + +func (s *Alter_user_azure_sqlContext) DEFAULT_SCHEMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_SCHEMA, i) +} + +func (s *Alter_user_azure_sqlContext) AllLOGIN() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOGIN) +} + +func (s *Alter_user_azure_sqlContext) LOGIN(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, i) +} + +func (s *Alter_user_azure_sqlContext) AllALLOW_ENCRYPTED_VALUE_MODIFICATIONS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS) +} + +func (s *Alter_user_azure_sqlContext) ALLOW_ENCRYPTED_VALUE_MODIFICATIONS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, i) +} + +func (s *Alter_user_azure_sqlContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Alter_user_azure_sqlContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Alter_user_azure_sqlContext) AllOFF() []antlr.TerminalNode { + return s.GetTokens(TSqlParserOFF) +} + +func (s *Alter_user_azure_sqlContext) OFF(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, i) +} + +func (s *Alter_user_azure_sqlContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_user_azure_sqlContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_user_azure_sqlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_user_azure_sqlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_user_azure_sqlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_user_azure_sql(s) + } +} + +func (s *Alter_user_azure_sqlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_user_azure_sql(s) + } +} + +func (s *Alter_user_azure_sqlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_user_azure_sql(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_user_azure_sql() (localctx IAlter_user_azure_sqlContext) { + localctx = NewAlter_user_azure_sqlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 436, TSqlParserRULE_alter_user_azure_sql) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6017) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6018) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6019) + + var _x = p.Id_() + + localctx.(*Alter_user_azure_sqlContext).username = _x + } + { + p.SetState(6020) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(6045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 698, p.GetParserRuleContext()) { + case 1: + p.SetState(6022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6021) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6024) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6025) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6026) + + var _x = p.Id_() + + localctx.(*Alter_user_azure_sqlContext).newusername = _x + } + + case 2: + p.SetState(6028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6027) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6030) + p.Match(TSqlParserDEFAULT_SCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6031) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6032) + + var _x = p.Id_() + + localctx.(*Alter_user_azure_sqlContext).schema_name = _x + } + + case 3: + p.SetState(6034) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6033) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6036) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6037) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6038) + + var _x = p.Id_() + + localctx.(*Alter_user_azure_sqlContext).loginame = _x + } + + case 4: + p.SetState(6040) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6039) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6042) + p.Match(TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6043) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6044) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(6047) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 699, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_workload_groupContext is an interface to support dynamic dispatch. +type IAlter_workload_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRequest_max_memory_grant returns the request_max_memory_grant token. + GetRequest_max_memory_grant() antlr.Token + + // GetRequest_max_cpu_time_sec returns the request_max_cpu_time_sec token. + GetRequest_max_cpu_time_sec() antlr.Token + + // GetRequest_memory_grant_timeout_sec returns the request_memory_grant_timeout_sec token. + GetRequest_memory_grant_timeout_sec() antlr.Token + + // GetMax_dop returns the max_dop token. + GetMax_dop() antlr.Token + + // GetGroup_max_requests returns the group_max_requests token. + GetGroup_max_requests() antlr.Token + + // SetRequest_max_memory_grant sets the request_max_memory_grant token. + SetRequest_max_memory_grant(antlr.Token) + + // SetRequest_max_cpu_time_sec sets the request_max_cpu_time_sec token. + SetRequest_max_cpu_time_sec(antlr.Token) + + // SetRequest_memory_grant_timeout_sec sets the request_memory_grant_timeout_sec token. + SetRequest_memory_grant_timeout_sec(antlr.Token) + + // SetMax_dop sets the max_dop token. + SetMax_dop(antlr.Token) + + // SetGroup_max_requests sets the group_max_requests token. + SetGroup_max_requests(antlr.Token) + + // GetWorkload_group_group_name returns the workload_group_group_name rule contexts. + GetWorkload_group_group_name() IId_Context + + // GetWorkload_group_pool_name returns the workload_group_pool_name rule contexts. + GetWorkload_group_pool_name() IId_Context + + // SetWorkload_group_group_name sets the workload_group_group_name rule contexts. + SetWorkload_group_group_name(IId_Context) + + // SetWorkload_group_pool_name sets the workload_group_pool_name rule contexts. + SetWorkload_group_pool_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + WORKLOAD() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllDEFAULT_DOUBLE_QUOTE() []antlr.TerminalNode + DEFAULT_DOUBLE_QUOTE(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + USING() antlr.TerminalNode + AllIMPORTANCE() []antlr.TerminalNode + IMPORTANCE(i int) antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllREQUEST_MAX_MEMORY_GRANT_PERCENT() []antlr.TerminalNode + REQUEST_MAX_MEMORY_GRANT_PERCENT(i int) antlr.TerminalNode + AllREQUEST_MAX_CPU_TIME_SEC() []antlr.TerminalNode + REQUEST_MAX_CPU_TIME_SEC(i int) antlr.TerminalNode + AllREQUEST_MEMORY_GRANT_TIMEOUT_SEC() []antlr.TerminalNode + REQUEST_MEMORY_GRANT_TIMEOUT_SEC(i int) antlr.TerminalNode + AllMAX_DOP() []antlr.TerminalNode + MAX_DOP(i int) antlr.TerminalNode + AllGROUP_MAX_REQUESTS() []antlr.TerminalNode + GROUP_MAX_REQUESTS(i int) antlr.TerminalNode + AllLOW() []antlr.TerminalNode + LOW(i int) antlr.TerminalNode + AllMEDIUM() []antlr.TerminalNode + MEDIUM(i int) antlr.TerminalNode + AllHIGH() []antlr.TerminalNode + HIGH(i int) antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_workload_groupContext differentiates from other interfaces. + IsAlter_workload_groupContext() +} + +type Alter_workload_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + workload_group_group_name IId_Context + request_max_memory_grant antlr.Token + request_max_cpu_time_sec antlr.Token + request_memory_grant_timeout_sec antlr.Token + max_dop antlr.Token + group_max_requests antlr.Token + workload_group_pool_name IId_Context +} + +func NewEmptyAlter_workload_groupContext() *Alter_workload_groupContext { + var p = new(Alter_workload_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_workload_group + return p +} + +func InitEmptyAlter_workload_groupContext(p *Alter_workload_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_workload_group +} + +func (*Alter_workload_groupContext) IsAlter_workload_groupContext() {} + +func NewAlter_workload_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_workload_groupContext { + var p = new(Alter_workload_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_workload_group + + return p +} + +func (s *Alter_workload_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_workload_groupContext) GetRequest_max_memory_grant() antlr.Token { + return s.request_max_memory_grant +} + +func (s *Alter_workload_groupContext) GetRequest_max_cpu_time_sec() antlr.Token { + return s.request_max_cpu_time_sec +} + +func (s *Alter_workload_groupContext) GetRequest_memory_grant_timeout_sec() antlr.Token { + return s.request_memory_grant_timeout_sec +} + +func (s *Alter_workload_groupContext) GetMax_dop() antlr.Token { return s.max_dop } + +func (s *Alter_workload_groupContext) GetGroup_max_requests() antlr.Token { + return s.group_max_requests +} + +func (s *Alter_workload_groupContext) SetRequest_max_memory_grant(v antlr.Token) { + s.request_max_memory_grant = v +} + +func (s *Alter_workload_groupContext) SetRequest_max_cpu_time_sec(v antlr.Token) { + s.request_max_cpu_time_sec = v +} + +func (s *Alter_workload_groupContext) SetRequest_memory_grant_timeout_sec(v antlr.Token) { + s.request_memory_grant_timeout_sec = v +} + +func (s *Alter_workload_groupContext) SetMax_dop(v antlr.Token) { s.max_dop = v } + +func (s *Alter_workload_groupContext) SetGroup_max_requests(v antlr.Token) { s.group_max_requests = v } + +func (s *Alter_workload_groupContext) GetWorkload_group_group_name() IId_Context { + return s.workload_group_group_name +} + +func (s *Alter_workload_groupContext) GetWorkload_group_pool_name() IId_Context { + return s.workload_group_pool_name +} + +func (s *Alter_workload_groupContext) SetWorkload_group_group_name(v IId_Context) { + s.workload_group_group_name = v +} + +func (s *Alter_workload_groupContext) SetWorkload_group_pool_name(v IId_Context) { + s.workload_group_pool_name = v +} + +func (s *Alter_workload_groupContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_workload_groupContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(TSqlParserWORKLOAD, 0) +} + +func (s *Alter_workload_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *Alter_workload_groupContext) AllDEFAULT_DOUBLE_QUOTE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDEFAULT_DOUBLE_QUOTE) +} + +func (s *Alter_workload_groupContext) DEFAULT_DOUBLE_QUOTE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_DOUBLE_QUOTE, i) +} + +func (s *Alter_workload_groupContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_workload_groupContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_workload_groupContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_workload_groupContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Alter_workload_groupContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Alter_workload_groupContext) USING() antlr.TerminalNode { + return s.GetToken(TSqlParserUSING, 0) +} + +func (s *Alter_workload_groupContext) AllIMPORTANCE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserIMPORTANCE) +} + +func (s *Alter_workload_groupContext) IMPORTANCE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserIMPORTANCE, i) +} + +func (s *Alter_workload_groupContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_workload_groupContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_workload_groupContext) AllREQUEST_MAX_MEMORY_GRANT_PERCENT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT) +} + +func (s *Alter_workload_groupContext) REQUEST_MAX_MEMORY_GRANT_PERCENT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, i) +} + +func (s *Alter_workload_groupContext) AllREQUEST_MAX_CPU_TIME_SEC() []antlr.TerminalNode { + return s.GetTokens(TSqlParserREQUEST_MAX_CPU_TIME_SEC) +} + +func (s *Alter_workload_groupContext) REQUEST_MAX_CPU_TIME_SEC(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserREQUEST_MAX_CPU_TIME_SEC, i) +} + +func (s *Alter_workload_groupContext) AllREQUEST_MEMORY_GRANT_TIMEOUT_SEC() []antlr.TerminalNode { + return s.GetTokens(TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC) +} + +func (s *Alter_workload_groupContext) REQUEST_MEMORY_GRANT_TIMEOUT_SEC(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, i) +} + +func (s *Alter_workload_groupContext) AllMAX_DOP() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMAX_DOP) +} + +func (s *Alter_workload_groupContext) MAX_DOP(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_DOP, i) +} + +func (s *Alter_workload_groupContext) AllGROUP_MAX_REQUESTS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserGROUP_MAX_REQUESTS) +} + +func (s *Alter_workload_groupContext) GROUP_MAX_REQUESTS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP_MAX_REQUESTS, i) +} + +func (s *Alter_workload_groupContext) AllLOW() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOW) +} + +func (s *Alter_workload_groupContext) LOW(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOW, i) +} + +func (s *Alter_workload_groupContext) AllMEDIUM() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMEDIUM) +} + +func (s *Alter_workload_groupContext) MEDIUM(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMEDIUM, i) +} + +func (s *Alter_workload_groupContext) AllHIGH() []antlr.TerminalNode { + return s.GetTokens(TSqlParserHIGH) +} + +func (s *Alter_workload_groupContext) HIGH(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserHIGH, i) +} + +func (s *Alter_workload_groupContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Alter_workload_groupContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Alter_workload_groupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_workload_groupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_workload_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_workload_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_workload_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_workload_group(s) + } +} + +func (s *Alter_workload_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_workload_group(s) + } +} + +func (s *Alter_workload_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_workload_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_workload_group() (localctx IAlter_workload_groupContext) { + localctx = NewAlter_workload_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 438, TSqlParserRULE_alter_workload_group) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6049) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6050) + p.Match(TSqlParserWORKLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6051) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 700, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6052) + + var _x = p.Id_() + + localctx.(*Alter_workload_groupContext).workload_group_group_name = _x + } + + case 2: + { + p.SetState(6053) + p.Match(TSqlParserDEFAULT_DOUBLE_QUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(6087) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 705, p.GetParserRuleContext()) == 1 { + { + p.SetState(6056) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6057) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserGROUP_MAX_REQUESTS || _la == TSqlParserIMPORTANCE || _la == TSqlParserMAX_DOP || ((int64((_la-805)) & ^0x3f) == 0 && ((int64(1)<<(_la-805))&7) != 0) || _la == TSqlParserCOMMA { + p.SetState(6082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 703, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6058) + p.Match(TSqlParserIMPORTANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6059) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6060) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserHIGH || _la == TSqlParserLOW || _la == TSqlParserMEDIUM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + p.SetState(6062) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6061) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6064) + p.Match(TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6065) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6066) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_workload_groupContext).request_max_memory_grant = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.SetState(6068) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6067) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6070) + p.Match(TSqlParserREQUEST_MAX_CPU_TIME_SEC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6071) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6072) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_workload_groupContext).request_max_cpu_time_sec = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(6073) + p.Match(TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6074) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6075) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_workload_groupContext).request_memory_grant_timeout_sec = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(6076) + p.Match(TSqlParserMAX_DOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6077) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6078) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_workload_groupContext).max_dop = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(6079) + p.Match(TSqlParserGROUP_MAX_REQUESTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6080) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6081) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_workload_groupContext).group_max_requests = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(6084) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6086) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6094) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 707, p.GetParserRuleContext()) == 1 { + { + p.SetState(6089) + p.Match(TSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6092) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 706, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6090) + + var _x = p.Id_() + + localctx.(*Alter_workload_groupContext).workload_group_pool_name = _x + } + + case 2: + { + p.SetState(6091) + p.Match(TSqlParserDEFAULT_DOUBLE_QUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_workload_groupContext is an interface to support dynamic dispatch. +type ICreate_workload_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRequest_max_memory_grant returns the request_max_memory_grant token. + GetRequest_max_memory_grant() antlr.Token + + // GetRequest_max_cpu_time_sec returns the request_max_cpu_time_sec token. + GetRequest_max_cpu_time_sec() antlr.Token + + // GetRequest_memory_grant_timeout_sec returns the request_memory_grant_timeout_sec token. + GetRequest_memory_grant_timeout_sec() antlr.Token + + // GetMax_dop returns the max_dop token. + GetMax_dop() antlr.Token + + // GetGroup_max_requests returns the group_max_requests token. + GetGroup_max_requests() antlr.Token + + // SetRequest_max_memory_grant sets the request_max_memory_grant token. + SetRequest_max_memory_grant(antlr.Token) + + // SetRequest_max_cpu_time_sec sets the request_max_cpu_time_sec token. + SetRequest_max_cpu_time_sec(antlr.Token) + + // SetRequest_memory_grant_timeout_sec sets the request_memory_grant_timeout_sec token. + SetRequest_memory_grant_timeout_sec(antlr.Token) + + // SetMax_dop sets the max_dop token. + SetMax_dop(antlr.Token) + + // SetGroup_max_requests sets the group_max_requests token. + SetGroup_max_requests(antlr.Token) + + // GetWorkload_group_group_name returns the workload_group_group_name rule contexts. + GetWorkload_group_group_name() IId_Context + + // GetWorkload_group_pool_name returns the workload_group_pool_name rule contexts. + GetWorkload_group_pool_name() IId_Context + + // GetExternal_pool_name returns the external_pool_name rule contexts. + GetExternal_pool_name() IId_Context + + // SetWorkload_group_group_name sets the workload_group_group_name rule contexts. + SetWorkload_group_group_name(IId_Context) + + // SetWorkload_group_pool_name sets the workload_group_pool_name rule contexts. + SetWorkload_group_pool_name(IId_Context) + + // SetExternal_pool_name sets the external_pool_name rule contexts. + SetExternal_pool_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + WORKLOAD() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + USING() antlr.TerminalNode + AllIMPORTANCE() []antlr.TerminalNode + IMPORTANCE(i int) antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllREQUEST_MAX_MEMORY_GRANT_PERCENT() []antlr.TerminalNode + REQUEST_MAX_MEMORY_GRANT_PERCENT(i int) antlr.TerminalNode + AllREQUEST_MAX_CPU_TIME_SEC() []antlr.TerminalNode + REQUEST_MAX_CPU_TIME_SEC(i int) antlr.TerminalNode + AllREQUEST_MEMORY_GRANT_TIMEOUT_SEC() []antlr.TerminalNode + REQUEST_MEMORY_GRANT_TIMEOUT_SEC(i int) antlr.TerminalNode + AllMAX_DOP() []antlr.TerminalNode + MAX_DOP(i int) antlr.TerminalNode + AllGROUP_MAX_REQUESTS() []antlr.TerminalNode + GROUP_MAX_REQUESTS(i int) antlr.TerminalNode + AllDEFAULT_DOUBLE_QUOTE() []antlr.TerminalNode + DEFAULT_DOUBLE_QUOTE(i int) antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + AllLOW() []antlr.TerminalNode + LOW(i int) antlr.TerminalNode + AllMEDIUM() []antlr.TerminalNode + MEDIUM(i int) antlr.TerminalNode + AllHIGH() []antlr.TerminalNode + HIGH(i int) antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_workload_groupContext differentiates from other interfaces. + IsCreate_workload_groupContext() +} + +type Create_workload_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + workload_group_group_name IId_Context + request_max_memory_grant antlr.Token + request_max_cpu_time_sec antlr.Token + request_memory_grant_timeout_sec antlr.Token + max_dop antlr.Token + group_max_requests antlr.Token + workload_group_pool_name IId_Context + external_pool_name IId_Context +} + +func NewEmptyCreate_workload_groupContext() *Create_workload_groupContext { + var p = new(Create_workload_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_workload_group + return p +} + +func InitEmptyCreate_workload_groupContext(p *Create_workload_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_workload_group +} + +func (*Create_workload_groupContext) IsCreate_workload_groupContext() {} + +func NewCreate_workload_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_workload_groupContext { + var p = new(Create_workload_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_workload_group + + return p +} + +func (s *Create_workload_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_workload_groupContext) GetRequest_max_memory_grant() antlr.Token { + return s.request_max_memory_grant +} + +func (s *Create_workload_groupContext) GetRequest_max_cpu_time_sec() antlr.Token { + return s.request_max_cpu_time_sec +} + +func (s *Create_workload_groupContext) GetRequest_memory_grant_timeout_sec() antlr.Token { + return s.request_memory_grant_timeout_sec +} + +func (s *Create_workload_groupContext) GetMax_dop() antlr.Token { return s.max_dop } + +func (s *Create_workload_groupContext) GetGroup_max_requests() antlr.Token { + return s.group_max_requests +} + +func (s *Create_workload_groupContext) SetRequest_max_memory_grant(v antlr.Token) { + s.request_max_memory_grant = v +} + +func (s *Create_workload_groupContext) SetRequest_max_cpu_time_sec(v antlr.Token) { + s.request_max_cpu_time_sec = v +} + +func (s *Create_workload_groupContext) SetRequest_memory_grant_timeout_sec(v antlr.Token) { + s.request_memory_grant_timeout_sec = v +} + +func (s *Create_workload_groupContext) SetMax_dop(v antlr.Token) { s.max_dop = v } + +func (s *Create_workload_groupContext) SetGroup_max_requests(v antlr.Token) { s.group_max_requests = v } + +func (s *Create_workload_groupContext) GetWorkload_group_group_name() IId_Context { + return s.workload_group_group_name +} + +func (s *Create_workload_groupContext) GetWorkload_group_pool_name() IId_Context { + return s.workload_group_pool_name +} + +func (s *Create_workload_groupContext) GetExternal_pool_name() IId_Context { + return s.external_pool_name +} + +func (s *Create_workload_groupContext) SetWorkload_group_group_name(v IId_Context) { + s.workload_group_group_name = v +} + +func (s *Create_workload_groupContext) SetWorkload_group_pool_name(v IId_Context) { + s.workload_group_pool_name = v +} + +func (s *Create_workload_groupContext) SetExternal_pool_name(v IId_Context) { s.external_pool_name = v } + +func (s *Create_workload_groupContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_workload_groupContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(TSqlParserWORKLOAD, 0) +} + +func (s *Create_workload_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *Create_workload_groupContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_workload_groupContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_workload_groupContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_workload_groupContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_workload_groupContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_workload_groupContext) USING() antlr.TerminalNode { + return s.GetToken(TSqlParserUSING, 0) +} + +func (s *Create_workload_groupContext) AllIMPORTANCE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserIMPORTANCE) +} + +func (s *Create_workload_groupContext) IMPORTANCE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserIMPORTANCE, i) +} + +func (s *Create_workload_groupContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Create_workload_groupContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Create_workload_groupContext) AllREQUEST_MAX_MEMORY_GRANT_PERCENT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT) +} + +func (s *Create_workload_groupContext) REQUEST_MAX_MEMORY_GRANT_PERCENT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, i) +} + +func (s *Create_workload_groupContext) AllREQUEST_MAX_CPU_TIME_SEC() []antlr.TerminalNode { + return s.GetTokens(TSqlParserREQUEST_MAX_CPU_TIME_SEC) +} + +func (s *Create_workload_groupContext) REQUEST_MAX_CPU_TIME_SEC(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserREQUEST_MAX_CPU_TIME_SEC, i) +} + +func (s *Create_workload_groupContext) AllREQUEST_MEMORY_GRANT_TIMEOUT_SEC() []antlr.TerminalNode { + return s.GetTokens(TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC) +} + +func (s *Create_workload_groupContext) REQUEST_MEMORY_GRANT_TIMEOUT_SEC(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, i) +} + +func (s *Create_workload_groupContext) AllMAX_DOP() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMAX_DOP) +} + +func (s *Create_workload_groupContext) MAX_DOP(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_DOP, i) +} + +func (s *Create_workload_groupContext) AllGROUP_MAX_REQUESTS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserGROUP_MAX_REQUESTS) +} + +func (s *Create_workload_groupContext) GROUP_MAX_REQUESTS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP_MAX_REQUESTS, i) +} + +func (s *Create_workload_groupContext) AllDEFAULT_DOUBLE_QUOTE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDEFAULT_DOUBLE_QUOTE) +} + +func (s *Create_workload_groupContext) DEFAULT_DOUBLE_QUOTE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_DOUBLE_QUOTE, i) +} + +func (s *Create_workload_groupContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Create_workload_groupContext) AllLOW() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOW) +} + +func (s *Create_workload_groupContext) LOW(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOW, i) +} + +func (s *Create_workload_groupContext) AllMEDIUM() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMEDIUM) +} + +func (s *Create_workload_groupContext) MEDIUM(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMEDIUM, i) +} + +func (s *Create_workload_groupContext) AllHIGH() []antlr.TerminalNode { + return s.GetTokens(TSqlParserHIGH) +} + +func (s *Create_workload_groupContext) HIGH(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserHIGH, i) +} + +func (s *Create_workload_groupContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Create_workload_groupContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Create_workload_groupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_workload_groupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_workload_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_workload_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_workload_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_workload_group(s) + } +} + +func (s *Create_workload_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_workload_group(s) + } +} + +func (s *Create_workload_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_workload_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_workload_group() (localctx ICreate_workload_groupContext) { + localctx = NewCreate_workload_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 440, TSqlParserRULE_create_workload_group) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6096) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6097) + p.Match(TSqlParserWORKLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6098) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6099) + + var _x = p.Id_() + + localctx.(*Create_workload_groupContext).workload_group_group_name = _x + } + p.SetState(6131) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 712, p.GetParserRuleContext()) == 1 { + { + p.SetState(6100) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6101) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserGROUP_MAX_REQUESTS || _la == TSqlParserIMPORTANCE || _la == TSqlParserMAX_DOP || ((int64((_la-805)) & ^0x3f) == 0 && ((int64(1)<<(_la-805))&7) != 0) || _la == TSqlParserCOMMA { + p.SetState(6126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 710, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6102) + p.Match(TSqlParserIMPORTANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6103) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6104) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserHIGH || _la == TSqlParserLOW || _la == TSqlParserMEDIUM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + p.SetState(6106) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6105) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6108) + p.Match(TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6109) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6110) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_workload_groupContext).request_max_memory_grant = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.SetState(6112) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6111) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6114) + p.Match(TSqlParserREQUEST_MAX_CPU_TIME_SEC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6115) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6116) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_workload_groupContext).request_max_cpu_time_sec = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(6117) + p.Match(TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6118) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6119) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_workload_groupContext).request_memory_grant_timeout_sec = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(6120) + p.Match(TSqlParserMAX_DOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6121) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6122) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_workload_groupContext).max_dop = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(6123) + p.Match(TSqlParserGROUP_MAX_REQUESTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6124) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6125) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Create_workload_groupContext).group_max_requests = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(6128) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6130) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6146) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 716, p.GetParserRuleContext()) == 1 { + { + p.SetState(6133) + p.Match(TSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6136) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 713, p.GetParserRuleContext()) == 1 { + { + p.SetState(6134) + + var _x = p.Id_() + + localctx.(*Create_workload_groupContext).workload_group_pool_name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 713, p.GetParserRuleContext()) == 2 { + { + p.SetState(6135) + p.Match(TSqlParserDEFAULT_DOUBLE_QUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6144) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 715, p.GetParserRuleContext()) == 1 { + p.SetState(6139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6138) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6141) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6142) + + var _x = p.Id_() + + localctx.(*Create_workload_groupContext).external_pool_name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 715, p.GetParserRuleContext()) == 2 { + { + p.SetState(6143) + p.Match(TSqlParserDEFAULT_DOUBLE_QUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_xml_schema_collectionContext is an interface to support dynamic dispatch. +type ICreate_xml_schema_collectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRelational_schema returns the relational_schema rule contexts. + GetRelational_schema() IId_Context + + // GetSql_identifier returns the sql_identifier rule contexts. + GetSql_identifier() IId_Context + + // SetRelational_schema sets the relational_schema rule contexts. + SetRelational_schema(IId_Context) + + // SetSql_identifier sets the sql_identifier rule contexts. + SetSql_identifier(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + XML() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + COLLECTION() antlr.TerminalNode + AS() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + STRING() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + DOT() antlr.TerminalNode + + // IsCreate_xml_schema_collectionContext differentiates from other interfaces. + IsCreate_xml_schema_collectionContext() +} + +type Create_xml_schema_collectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + relational_schema IId_Context + sql_identifier IId_Context +} + +func NewEmptyCreate_xml_schema_collectionContext() *Create_xml_schema_collectionContext { + var p = new(Create_xml_schema_collectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_xml_schema_collection + return p +} + +func InitEmptyCreate_xml_schema_collectionContext(p *Create_xml_schema_collectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_xml_schema_collection +} + +func (*Create_xml_schema_collectionContext) IsCreate_xml_schema_collectionContext() {} + +func NewCreate_xml_schema_collectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_xml_schema_collectionContext { + var p = new(Create_xml_schema_collectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_xml_schema_collection + + return p +} + +func (s *Create_xml_schema_collectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_xml_schema_collectionContext) GetRelational_schema() IId_Context { + return s.relational_schema +} + +func (s *Create_xml_schema_collectionContext) GetSql_identifier() IId_Context { + return s.sql_identifier +} + +func (s *Create_xml_schema_collectionContext) SetRelational_schema(v IId_Context) { + s.relational_schema = v +} + +func (s *Create_xml_schema_collectionContext) SetSql_identifier(v IId_Context) { s.sql_identifier = v } + +func (s *Create_xml_schema_collectionContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_xml_schema_collectionContext) XML() antlr.TerminalNode { + return s.GetToken(TSqlParserXML, 0) +} + +func (s *Create_xml_schema_collectionContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Create_xml_schema_collectionContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLECTION, 0) +} + +func (s *Create_xml_schema_collectionContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Create_xml_schema_collectionContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_xml_schema_collectionContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_xml_schema_collectionContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_xml_schema_collectionContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Create_xml_schema_collectionContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Create_xml_schema_collectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_xml_schema_collectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_xml_schema_collectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_xml_schema_collection(s) + } +} + +func (s *Create_xml_schema_collectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_xml_schema_collection(s) + } +} + +func (s *Create_xml_schema_collectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_xml_schema_collection(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_xml_schema_collection() (localctx ICreate_xml_schema_collectionContext) { + localctx = NewCreate_xml_schema_collectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 442, TSqlParserRULE_create_xml_schema_collection) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6148) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6149) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6150) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6151) + p.Match(TSqlParserCOLLECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6155) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 717, p.GetParserRuleContext()) == 1 { + { + p.SetState(6152) + + var _x = p.Id_() + + localctx.(*Create_xml_schema_collectionContext).relational_schema = _x + } + { + p.SetState(6153) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6157) + + var _x = p.Id_() + + localctx.(*Create_xml_schema_collectionContext).sql_identifier = _x + } + { + p.SetState(6158) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6162) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(6159) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(6160) + p.Id_() + } + + case TSqlParserLOCAL_ID: + { + p.SetState(6161) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_partition_functionContext is an interface to support dynamic dispatch. +type ICreate_partition_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartition_function_name returns the partition_function_name rule contexts. + GetPartition_function_name() IId_Context + + // GetInput_parameter_type returns the input_parameter_type rule contexts. + GetInput_parameter_type() IData_typeContext + + // GetBoundary_values returns the boundary_values rule contexts. + GetBoundary_values() IExpression_list_Context + + // SetPartition_function_name sets the partition_function_name rule contexts. + SetPartition_function_name(IId_Context) + + // SetInput_parameter_type sets the input_parameter_type rule contexts. + SetInput_parameter_type(IData_typeContext) + + // SetBoundary_values sets the boundary_values rule contexts. + SetBoundary_values(IExpression_list_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + PARTITION() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AS() antlr.TerminalNode + RANGE() antlr.TerminalNode + FOR() antlr.TerminalNode + VALUES() antlr.TerminalNode + Id_() IId_Context + Data_type() IData_typeContext + Expression_list_() IExpression_list_Context + LEFT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + + // IsCreate_partition_functionContext differentiates from other interfaces. + IsCreate_partition_functionContext() +} + +type Create_partition_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partition_function_name IId_Context + input_parameter_type IData_typeContext + boundary_values IExpression_list_Context +} + +func NewEmptyCreate_partition_functionContext() *Create_partition_functionContext { + var p = new(Create_partition_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_partition_function + return p +} + +func InitEmptyCreate_partition_functionContext(p *Create_partition_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_partition_function +} + +func (*Create_partition_functionContext) IsCreate_partition_functionContext() {} + +func NewCreate_partition_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_partition_functionContext { + var p = new(Create_partition_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_partition_function + + return p +} + +func (s *Create_partition_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_partition_functionContext) GetPartition_function_name() IId_Context { + return s.partition_function_name +} + +func (s *Create_partition_functionContext) GetInput_parameter_type() IData_typeContext { + return s.input_parameter_type +} + +func (s *Create_partition_functionContext) GetBoundary_values() IExpression_list_Context { + return s.boundary_values +} + +func (s *Create_partition_functionContext) SetPartition_function_name(v IId_Context) { + s.partition_function_name = v +} + +func (s *Create_partition_functionContext) SetInput_parameter_type(v IData_typeContext) { + s.input_parameter_type = v +} + +func (s *Create_partition_functionContext) SetBoundary_values(v IExpression_list_Context) { + s.boundary_values = v +} + +func (s *Create_partition_functionContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_partition_functionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITION, 0) +} + +func (s *Create_partition_functionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(TSqlParserFUNCTION, 0) +} + +func (s *Create_partition_functionContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Create_partition_functionContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Create_partition_functionContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Create_partition_functionContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Create_partition_functionContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Create_partition_functionContext) RANGE() antlr.TerminalNode { + return s.GetToken(TSqlParserRANGE, 0) +} + +func (s *Create_partition_functionContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_partition_functionContext) VALUES() antlr.TerminalNode { + return s.GetToken(TSqlParserVALUES, 0) +} + +func (s *Create_partition_functionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_partition_functionContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Create_partition_functionContext) Expression_list_() IExpression_list_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_list_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_list_Context) +} + +func (s *Create_partition_functionContext) LEFT() antlr.TerminalNode { + return s.GetToken(TSqlParserLEFT, 0) +} + +func (s *Create_partition_functionContext) RIGHT() antlr.TerminalNode { + return s.GetToken(TSqlParserRIGHT, 0) +} + +func (s *Create_partition_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_partition_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_partition_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_partition_function(s) + } +} + +func (s *Create_partition_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_partition_function(s) + } +} + +func (s *Create_partition_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_partition_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_partition_function() (localctx ICreate_partition_functionContext) { + localctx = NewCreate_partition_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 444, TSqlParserRULE_create_partition_function) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6164) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6165) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6166) + p.Match(TSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6167) + + var _x = p.Id_() + + localctx.(*Create_partition_functionContext).partition_function_name = _x + } + { + p.SetState(6168) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6169) + + var _x = p.Data_type() + + localctx.(*Create_partition_functionContext).input_parameter_type = _x + } + { + p.SetState(6170) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6171) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6172) + p.Match(TSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6174) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLEFT || _la == TSqlParserRIGHT { + { + p.SetState(6173) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLEFT || _la == TSqlParserRIGHT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(6176) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6177) + p.Match(TSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6178) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6179) + + var _x = p.Expression_list_() + + localctx.(*Create_partition_functionContext).boundary_values = _x + } + { + p.SetState(6180) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_partition_schemeContext is an interface to support dynamic dispatch. +type ICreate_partition_schemeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartition_scheme_name returns the partition_scheme_name rule contexts. + GetPartition_scheme_name() IId_Context + + // GetPartition_function_name returns the partition_function_name rule contexts. + GetPartition_function_name() IId_Context + + // Get_id_ returns the _id_ rule contexts. + Get_id_() IId_Context + + // SetPartition_scheme_name sets the partition_scheme_name rule contexts. + SetPartition_scheme_name(IId_Context) + + // SetPartition_function_name sets the partition_function_name rule contexts. + SetPartition_function_name(IId_Context) + + // Set_id_ sets the _id_ rule contexts. + Set_id_(IId_Context) + + // GetFile_group_names returns the file_group_names rule context list. + GetFile_group_names() []IId_Context + + // SetFile_group_names sets the file_group_names rule context list. + SetFile_group_names([]IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + SCHEME() antlr.TerminalNode + AS() antlr.TerminalNode + TO() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ALL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_partition_schemeContext differentiates from other interfaces. + IsCreate_partition_schemeContext() +} + +type Create_partition_schemeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partition_scheme_name IId_Context + partition_function_name IId_Context + _id_ IId_Context + file_group_names []IId_Context +} + +func NewEmptyCreate_partition_schemeContext() *Create_partition_schemeContext { + var p = new(Create_partition_schemeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_partition_scheme + return p +} + +func InitEmptyCreate_partition_schemeContext(p *Create_partition_schemeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_partition_scheme +} + +func (*Create_partition_schemeContext) IsCreate_partition_schemeContext() {} + +func NewCreate_partition_schemeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_partition_schemeContext { + var p = new(Create_partition_schemeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_partition_scheme + + return p +} + +func (s *Create_partition_schemeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_partition_schemeContext) GetPartition_scheme_name() IId_Context { + return s.partition_scheme_name +} + +func (s *Create_partition_schemeContext) GetPartition_function_name() IId_Context { + return s.partition_function_name +} + +func (s *Create_partition_schemeContext) Get_id_() IId_Context { return s._id_ } + +func (s *Create_partition_schemeContext) SetPartition_scheme_name(v IId_Context) { + s.partition_scheme_name = v +} + +func (s *Create_partition_schemeContext) SetPartition_function_name(v IId_Context) { + s.partition_function_name = v +} + +func (s *Create_partition_schemeContext) Set_id_(v IId_Context) { s._id_ = v } + +func (s *Create_partition_schemeContext) GetFile_group_names() []IId_Context { + return s.file_group_names +} + +func (s *Create_partition_schemeContext) SetFile_group_names(v []IId_Context) { s.file_group_names = v } + +func (s *Create_partition_schemeContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_partition_schemeContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserPARTITION) +} + +func (s *Create_partition_schemeContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITION, i) +} + +func (s *Create_partition_schemeContext) SCHEME() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEME, 0) +} + +func (s *Create_partition_schemeContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Create_partition_schemeContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Create_partition_schemeContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_partition_schemeContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_partition_schemeContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_partition_schemeContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_partition_schemeContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Create_partition_schemeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_partition_schemeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_partition_schemeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_partition_schemeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_partition_schemeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_partition_scheme(s) + } +} + +func (s *Create_partition_schemeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_partition_scheme(s) + } +} + +func (s *Create_partition_schemeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_partition_scheme(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_partition_scheme() (localctx ICreate_partition_schemeContext) { + localctx = NewCreate_partition_schemeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 446, TSqlParserRULE_create_partition_scheme) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6182) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6183) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6184) + p.Match(TSqlParserSCHEME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6185) + + var _x = p.Id_() + + localctx.(*Create_partition_schemeContext).partition_scheme_name = _x + } + { + p.SetState(6186) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6187) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6188) + + var _x = p.Id_() + + localctx.(*Create_partition_schemeContext).partition_function_name = _x + } + p.SetState(6190) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserALL { + { + p.SetState(6189) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6192) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6193) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6194) + + var _x = p.Id_() + + localctx.(*Create_partition_schemeContext)._id_ = _x + } + localctx.(*Create_partition_schemeContext).file_group_names = append(localctx.(*Create_partition_schemeContext).file_group_names, localctx.(*Create_partition_schemeContext)._id_) + p.SetState(6199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(6195) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6196) + + var _x = p.Id_() + + localctx.(*Create_partition_schemeContext)._id_ = _x + } + localctx.(*Create_partition_schemeContext).file_group_names = append(localctx.(*Create_partition_schemeContext).file_group_names, localctx.(*Create_partition_schemeContext)._id_) + + p.SetState(6201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6202) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_queueContext is an interface to support dynamic dispatch. +type ICreate_queueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetQueue_name returns the queue_name rule contexts. + GetQueue_name() IId_Context + + // GetFilegroup returns the filegroup rule contexts. + GetFilegroup() IId_Context + + // SetQueue_name sets the queue_name rule contexts. + SetQueue_name(IId_Context) + + // SetFilegroup sets the filegroup rule contexts. + SetFilegroup(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + QUEUE() antlr.TerminalNode + Full_table_name() IFull_table_nameContext + AllId_() []IId_Context + Id_(i int) IId_Context + Queue_settings() IQueue_settingsContext + ON() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsCreate_queueContext differentiates from other interfaces. + IsCreate_queueContext() +} + +type Create_queueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + queue_name IId_Context + filegroup IId_Context +} + +func NewEmptyCreate_queueContext() *Create_queueContext { + var p = new(Create_queueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_queue + return p +} + +func InitEmptyCreate_queueContext(p *Create_queueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_queue +} + +func (*Create_queueContext) IsCreate_queueContext() {} + +func NewCreate_queueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_queueContext { + var p = new(Create_queueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_queue + + return p +} + +func (s *Create_queueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_queueContext) GetQueue_name() IId_Context { return s.queue_name } + +func (s *Create_queueContext) GetFilegroup() IId_Context { return s.filegroup } + +func (s *Create_queueContext) SetQueue_name(v IId_Context) { s.queue_name = v } + +func (s *Create_queueContext) SetFilegroup(v IId_Context) { s.filegroup = v } + +func (s *Create_queueContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_queueContext) QUEUE() antlr.TerminalNode { + return s.GetToken(TSqlParserQUEUE, 0) +} + +func (s *Create_queueContext) Full_table_name() IFull_table_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_table_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_table_nameContext) +} + +func (s *Create_queueContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_queueContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_queueContext) Queue_settings() IQueue_settingsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueue_settingsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueue_settingsContext) +} + +func (s *Create_queueContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Create_queueContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Create_queueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_queueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_queueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_queue(s) + } +} + +func (s *Create_queueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_queue(s) + } +} + +func (s *Create_queueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_queue(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_queue() (localctx ICreate_queueContext) { + localctx = NewCreate_queueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 448, TSqlParserRULE_create_queue) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6204) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6205) + p.Match(TSqlParserQUEUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 722, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6206) + p.Full_table_name() + } + + case 2: + { + p.SetState(6207) + + var _x = p.Id_() + + localctx.(*Create_queueContext).queue_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(6211) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 723, p.GetParserRuleContext()) == 1 { + { + p.SetState(6210) + p.Queue_settings() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case TSqlParserON: + { + p.SetState(6213) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6214) + + var _x = p.Id_() + + localctx.(*Create_queueContext).filegroup = _x + } + + case TSqlParserDEFAULT: + { + p.SetState(6215) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEOF, TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALTER, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBREAK, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKPOINT, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLOSE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMIT, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDEALLOCATE, TSqlParserDECLARE, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETE, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROP, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserELSE, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserEND, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXECUTE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFETCH, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOTO, TSqlParserGOVERNOR, TSqlParserGRANT, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIF, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERT, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserKILL, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMERGE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPEN, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRINT, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRAISERROR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECONFIGURE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURN, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREVERT, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROLLBACK, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSAVE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELECT, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSET, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSETUSER, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSHUTDOWN, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUNCATE, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDATE, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSE, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAITFOR, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWHILE, TSqlParserWINDOWS, TSqlParserWITH, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserLR_BRACKET, TSqlParserSEMI: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQueue_settingsContext is an interface to support dynamic dispatch. +type IQueue_settingsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMax_readers returns the max_readers token. + GetMax_readers() antlr.Token + + // GetUser_name returns the user_name token. + GetUser_name() antlr.Token + + // SetMax_readers sets the max_readers token. + SetMax_readers(antlr.Token) + + // SetUser_name sets the user_name token. + SetUser_name(antlr.Token) + + // Getter signatures + WITH() antlr.TerminalNode + AllSTATUS() []antlr.TerminalNode + STATUS(i int) antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllOn_off() []IOn_offContext + On_off(i int) IOn_offContext + RETENTION() antlr.TerminalNode + ACTIVATION() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + POISON_MESSAGE_HANDLING() antlr.TerminalNode + DROP() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + PROCEDURE_NAME() antlr.TerminalNode + Func_proc_name_database_schema() IFunc_proc_name_database_schemaContext + MAX_QUEUE_READERS() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + AS() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + SELF() antlr.TerminalNode + OWNER() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsQueue_settingsContext differentiates from other interfaces. + IsQueue_settingsContext() +} + +type Queue_settingsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + max_readers antlr.Token + user_name antlr.Token +} + +func NewEmptyQueue_settingsContext() *Queue_settingsContext { + var p = new(Queue_settingsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_queue_settings + return p +} + +func InitEmptyQueue_settingsContext(p *Queue_settingsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_queue_settings +} + +func (*Queue_settingsContext) IsQueue_settingsContext() {} + +func NewQueue_settingsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Queue_settingsContext { + var p = new(Queue_settingsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_queue_settings + + return p +} + +func (s *Queue_settingsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Queue_settingsContext) GetMax_readers() antlr.Token { return s.max_readers } + +func (s *Queue_settingsContext) GetUser_name() antlr.Token { return s.user_name } + +func (s *Queue_settingsContext) SetMax_readers(v antlr.Token) { s.max_readers = v } + +func (s *Queue_settingsContext) SetUser_name(v antlr.Token) { s.user_name = v } + +func (s *Queue_settingsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Queue_settingsContext) AllSTATUS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTATUS) +} + +func (s *Queue_settingsContext) STATUS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTATUS, i) +} + +func (s *Queue_settingsContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Queue_settingsContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Queue_settingsContext) AllOn_off() []IOn_offContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOn_offContext); ok { + len++ + } + } + + tst := make([]IOn_offContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOn_offContext); ok { + tst[i] = t.(IOn_offContext) + i++ + } + } + + return tst +} + +func (s *Queue_settingsContext) On_off(i int) IOn_offContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Queue_settingsContext) RETENTION() antlr.TerminalNode { + return s.GetToken(TSqlParserRETENTION, 0) +} + +func (s *Queue_settingsContext) ACTIVATION() antlr.TerminalNode { + return s.GetToken(TSqlParserACTIVATION, 0) +} + +func (s *Queue_settingsContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Queue_settingsContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Queue_settingsContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Queue_settingsContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Queue_settingsContext) POISON_MESSAGE_HANDLING() antlr.TerminalNode { + return s.GetToken(TSqlParserPOISON_MESSAGE_HANDLING, 0) +} + +func (s *Queue_settingsContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Queue_settingsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Queue_settingsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Queue_settingsContext) PROCEDURE_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserPROCEDURE_NAME, 0) +} + +func (s *Queue_settingsContext) Func_proc_name_database_schema() IFunc_proc_name_database_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_proc_name_database_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_proc_name_database_schemaContext) +} + +func (s *Queue_settingsContext) MAX_QUEUE_READERS() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_QUEUE_READERS, 0) +} + +func (s *Queue_settingsContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXECUTE, 0) +} + +func (s *Queue_settingsContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Queue_settingsContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Queue_settingsContext) SELF() antlr.TerminalNode { + return s.GetToken(TSqlParserSELF, 0) +} + +func (s *Queue_settingsContext) OWNER() antlr.TerminalNode { + return s.GetToken(TSqlParserOWNER, 0) +} + +func (s *Queue_settingsContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Queue_settingsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Queue_settingsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Queue_settingsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterQueue_settings(s) + } +} + +func (s *Queue_settingsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitQueue_settings(s) + } +} + +func (s *Queue_settingsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitQueue_settings(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Queue_settings() (localctx IQueue_settingsContext) { + localctx = NewQueue_settingsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 450, TSqlParserRULE_queue_settings) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6218) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6225) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 726, p.GetParserRuleContext()) == 1 { + { + p.SetState(6219) + p.Match(TSqlParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6220) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6221) + p.On_off() + } + p.SetState(6223) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6222) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6233) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 728, p.GetParserRuleContext()) == 1 { + { + p.SetState(6227) + p.Match(TSqlParserRETENTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6228) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6229) + p.On_off() + } + p.SetState(6231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6230) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6280) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 740, p.GetParserRuleContext()) == 1 { + { + p.SetState(6235) + p.Match(TSqlParserACTIVATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6236) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6274) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserEXECUTE, TSqlParserMAX_QUEUE_READERS, TSqlParserPROCEDURE_NAME, TSqlParserSTATUS, TSqlParserRR_BRACKET: + p.SetState(6243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSTATUS { + { + p.SetState(6237) + p.Match(TSqlParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6238) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6239) + p.On_off() + } + p.SetState(6241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6240) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(6251) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPROCEDURE_NAME { + { + p.SetState(6245) + p.Match(TSqlParserPROCEDURE_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6246) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6247) + p.Func_proc_name_database_schema() + } + p.SetState(6249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6248) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(6259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMAX_QUEUE_READERS { + { + p.SetState(6253) + p.Match(TSqlParserMAX_QUEUE_READERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6254) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6255) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Queue_settingsContext).max_readers = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6257) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6256) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(6271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserEXECUTE { + { + p.SetState(6261) + p.Match(TSqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6262) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSELF: + { + p.SetState(6263) + p.Match(TSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSTRING: + { + p.SetState(6264) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Queue_settingsContext).user_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserOWNER: + { + p.SetState(6265) + p.Match(TSqlParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6268) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + + case TSqlParserDROP: + { + p.SetState(6273) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6276) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6277) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6290) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 741, p.GetParserRuleContext()) == 1 { + { + p.SetState(6282) + p.Match(TSqlParserPOISON_MESSAGE_HANDLING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6283) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(6284) + p.Match(TSqlParserSTATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6285) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6286) + p.On_off() + } + + { + p.SetState(6288) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_queueContext is an interface to support dynamic dispatch. +type IAlter_queueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetQueue_name returns the queue_name rule contexts. + GetQueue_name() IId_Context + + // SetQueue_name sets the queue_name rule contexts. + SetQueue_name(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + QUEUE() antlr.TerminalNode + Full_table_name() IFull_table_nameContext + Queue_settings() IQueue_settingsContext + Queue_action() IQueue_actionContext + Id_() IId_Context + + // IsAlter_queueContext differentiates from other interfaces. + IsAlter_queueContext() +} + +type Alter_queueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + queue_name IId_Context +} + +func NewEmptyAlter_queueContext() *Alter_queueContext { + var p = new(Alter_queueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_queue + return p +} + +func InitEmptyAlter_queueContext(p *Alter_queueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_queue +} + +func (*Alter_queueContext) IsAlter_queueContext() {} + +func NewAlter_queueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_queueContext { + var p = new(Alter_queueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_queue + + return p +} + +func (s *Alter_queueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_queueContext) GetQueue_name() IId_Context { return s.queue_name } + +func (s *Alter_queueContext) SetQueue_name(v IId_Context) { s.queue_name = v } + +func (s *Alter_queueContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_queueContext) QUEUE() antlr.TerminalNode { + return s.GetToken(TSqlParserQUEUE, 0) +} + +func (s *Alter_queueContext) Full_table_name() IFull_table_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_table_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_table_nameContext) +} + +func (s *Alter_queueContext) Queue_settings() IQueue_settingsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueue_settingsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueue_settingsContext) +} + +func (s *Alter_queueContext) Queue_action() IQueue_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueue_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueue_actionContext) +} + +func (s *Alter_queueContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_queueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_queueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_queueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_queue(s) + } +} + +func (s *Alter_queueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_queue(s) + } +} + +func (s *Alter_queueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_queue(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_queue() (localctx IAlter_queueContext) { + localctx = NewAlter_queueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 452, TSqlParserRULE_alter_queue) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6292) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6293) + p.Match(TSqlParserQUEUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 742, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6294) + p.Full_table_name() + } + + case 2: + { + p.SetState(6295) + + var _x = p.Id_() + + localctx.(*Alter_queueContext).queue_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(6300) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserWITH: + { + p.SetState(6298) + p.Queue_settings() + } + + case TSqlParserMOVE, TSqlParserREBUILD, TSqlParserREORGANIZE: + { + p.SetState(6299) + p.Queue_action() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQueue_actionContext is an interface to support dynamic dispatch. +type IQueue_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REBUILD() antlr.TerminalNode + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Queue_rebuild_options() IQueue_rebuild_optionsContext + RR_BRACKET() antlr.TerminalNode + REORGANIZE() antlr.TerminalNode + LOB_COMPACTION() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + MOVE() antlr.TerminalNode + TO() antlr.TerminalNode + Id_() IId_Context + DEFAULT() antlr.TerminalNode + + // IsQueue_actionContext differentiates from other interfaces. + IsQueue_actionContext() +} + +type Queue_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQueue_actionContext() *Queue_actionContext { + var p = new(Queue_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_queue_action + return p +} + +func InitEmptyQueue_actionContext(p *Queue_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_queue_action +} + +func (*Queue_actionContext) IsQueue_actionContext() {} + +func NewQueue_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Queue_actionContext { + var p = new(Queue_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_queue_action + + return p +} + +func (s *Queue_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Queue_actionContext) REBUILD() antlr.TerminalNode { + return s.GetToken(TSqlParserREBUILD, 0) +} + +func (s *Queue_actionContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Queue_actionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Queue_actionContext) Queue_rebuild_options() IQueue_rebuild_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueue_rebuild_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueue_rebuild_optionsContext) +} + +func (s *Queue_actionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Queue_actionContext) REORGANIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserREORGANIZE, 0) +} + +func (s *Queue_actionContext) LOB_COMPACTION() antlr.TerminalNode { + return s.GetToken(TSqlParserLOB_COMPACTION, 0) +} + +func (s *Queue_actionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Queue_actionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Queue_actionContext) MOVE() antlr.TerminalNode { + return s.GetToken(TSqlParserMOVE, 0) +} + +func (s *Queue_actionContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Queue_actionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Queue_actionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Queue_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Queue_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Queue_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterQueue_action(s) + } +} + +func (s *Queue_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitQueue_action(s) + } +} + +func (s *Queue_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitQueue_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Queue_action() (localctx IQueue_actionContext) { + localctx = NewQueue_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 454, TSqlParserRULE_queue_action) + p.SetState(6323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserREBUILD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6302) + p.Match(TSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6308) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 744, p.GetParserRuleContext()) == 1 { + { + p.SetState(6303) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6304) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6305) + p.Queue_rebuild_options() + } + { + p.SetState(6306) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserREORGANIZE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6310) + p.Match(TSqlParserREORGANIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6315) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 745, p.GetParserRuleContext()) == 1 { + { + p.SetState(6311) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6312) + p.Match(TSqlParserLOB_COMPACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6313) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6314) + p.On_off() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserMOVE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6317) + p.Match(TSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6318) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(6319) + p.Id_() + } + + case TSqlParserDEFAULT: + { + p.SetState(6320) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQueue_rebuild_optionsContext is an interface to support dynamic dispatch. +type IQueue_rebuild_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAXDOP() antlr.TerminalNode + EQUAL() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + + // IsQueue_rebuild_optionsContext differentiates from other interfaces. + IsQueue_rebuild_optionsContext() +} + +type Queue_rebuild_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQueue_rebuild_optionsContext() *Queue_rebuild_optionsContext { + var p = new(Queue_rebuild_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_queue_rebuild_options + return p +} + +func InitEmptyQueue_rebuild_optionsContext(p *Queue_rebuild_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_queue_rebuild_options +} + +func (*Queue_rebuild_optionsContext) IsQueue_rebuild_optionsContext() {} + +func NewQueue_rebuild_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Queue_rebuild_optionsContext { + var p = new(Queue_rebuild_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_queue_rebuild_options + + return p +} + +func (s *Queue_rebuild_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Queue_rebuild_optionsContext) MAXDOP() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXDOP, 0) +} + +func (s *Queue_rebuild_optionsContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Queue_rebuild_optionsContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Queue_rebuild_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Queue_rebuild_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Queue_rebuild_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterQueue_rebuild_options(s) + } +} + +func (s *Queue_rebuild_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitQueue_rebuild_options(s) + } +} + +func (s *Queue_rebuild_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitQueue_rebuild_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Queue_rebuild_options() (localctx IQueue_rebuild_optionsContext) { + localctx = NewQueue_rebuild_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 456, TSqlParserRULE_queue_rebuild_options) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6325) + p.Match(TSqlParserMAXDOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6326) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6327) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_contractContext is an interface to support dynamic dispatch. +type ICreate_contractContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // GetMessage_type_name returns the message_type_name rule contexts. + GetMessage_type_name() IId_Context + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // SetMessage_type_name sets the message_type_name rule contexts. + SetMessage_type_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + CONTRACT() antlr.TerminalNode + Contract_name() IContract_nameContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + AllSENT() []antlr.TerminalNode + SENT(i int) antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllINITIATOR() []antlr.TerminalNode + INITIATOR(i int) antlr.TerminalNode + AllTARGET() []antlr.TerminalNode + TARGET(i int) antlr.TerminalNode + AllANY() []antlr.TerminalNode + ANY(i int) antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_contractContext differentiates from other interfaces. + IsCreate_contractContext() +} + +type Create_contractContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + owner_name IId_Context + message_type_name IId_Context +} + +func NewEmptyCreate_contractContext() *Create_contractContext { + var p = new(Create_contractContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_contract + return p +} + +func InitEmptyCreate_contractContext(p *Create_contractContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_contract +} + +func (*Create_contractContext) IsCreate_contractContext() {} + +func NewCreate_contractContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_contractContext { + var p = new(Create_contractContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_contract + + return p +} + +func (s *Create_contractContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_contractContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Create_contractContext) GetMessage_type_name() IId_Context { return s.message_type_name } + +func (s *Create_contractContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Create_contractContext) SetMessage_type_name(v IId_Context) { s.message_type_name = v } + +func (s *Create_contractContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_contractContext) CONTRACT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTRACT, 0) +} + +func (s *Create_contractContext) Contract_name() IContract_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContract_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContract_nameContext) +} + +func (s *Create_contractContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_contractContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_contractContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_contractContext) AllSENT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSENT) +} + +func (s *Create_contractContext) SENT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSENT, i) +} + +func (s *Create_contractContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBY) +} + +func (s *Create_contractContext) BY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBY, i) +} + +func (s *Create_contractContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_contractContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_contractContext) AllINITIATOR() []antlr.TerminalNode { + return s.GetTokens(TSqlParserINITIATOR) +} + +func (s *Create_contractContext) INITIATOR(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserINITIATOR, i) +} + +func (s *Create_contractContext) AllTARGET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTARGET) +} + +func (s *Create_contractContext) TARGET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTARGET, i) +} + +func (s *Create_contractContext) AllANY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserANY) +} + +func (s *Create_contractContext) ANY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserANY, i) +} + +func (s *Create_contractContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDEFAULT) +} + +func (s *Create_contractContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, i) +} + +func (s *Create_contractContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_contractContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_contractContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_contractContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_contractContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_contract(s) + } +} + +func (s *Create_contractContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_contract(s) + } +} + +func (s *Create_contractContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_contract(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_contract() (localctx ICreate_contractContext) { + localctx = NewCreate_contractContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 458, TSqlParserRULE_create_contract) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6329) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6330) + p.Match(TSqlParserCONTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6331) + p.Contract_name() + } + p.SetState(6334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(6332) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6333) + + var _x = p.Id_() + + localctx.(*Create_contractContext).owner_name = _x + } + + } + { + p.SetState(6336) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6347) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212729921) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&22413823) != 0) { + p.SetState(6339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(6337) + + var _x = p.Id_() + + localctx.(*Create_contractContext).message_type_name = _x + } + + case TSqlParserDEFAULT: + { + p.SetState(6338) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6341) + p.Match(TSqlParserSENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6342) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6343) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserANY || _la == TSqlParserINITIATOR || _la == TSqlParserTARGET) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6344) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(6349) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6351) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConversation_statementContext is an interface to support dynamic dispatch. +type IConversation_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Begin_conversation_timer() IBegin_conversation_timerContext + Begin_conversation_dialog() IBegin_conversation_dialogContext + End_conversation() IEnd_conversationContext + Get_conversation() IGet_conversationContext + Send_conversation() ISend_conversationContext + Waitfor_conversation() IWaitfor_conversationContext + + // IsConversation_statementContext differentiates from other interfaces. + IsConversation_statementContext() +} + +type Conversation_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConversation_statementContext() *Conversation_statementContext { + var p = new(Conversation_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_conversation_statement + return p +} + +func InitEmptyConversation_statementContext(p *Conversation_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_conversation_statement +} + +func (*Conversation_statementContext) IsConversation_statementContext() {} + +func NewConversation_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Conversation_statementContext { + var p = new(Conversation_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_conversation_statement + + return p +} + +func (s *Conversation_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Conversation_statementContext) Begin_conversation_timer() IBegin_conversation_timerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBegin_conversation_timerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBegin_conversation_timerContext) +} + +func (s *Conversation_statementContext) Begin_conversation_dialog() IBegin_conversation_dialogContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBegin_conversation_dialogContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBegin_conversation_dialogContext) +} + +func (s *Conversation_statementContext) End_conversation() IEnd_conversationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnd_conversationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnd_conversationContext) +} + +func (s *Conversation_statementContext) Get_conversation() IGet_conversationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGet_conversationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGet_conversationContext) +} + +func (s *Conversation_statementContext) Send_conversation() ISend_conversationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISend_conversationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISend_conversationContext) +} + +func (s *Conversation_statementContext) Waitfor_conversation() IWaitfor_conversationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWaitfor_conversationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWaitfor_conversationContext) +} + +func (s *Conversation_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Conversation_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Conversation_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterConversation_statement(s) + } +} + +func (s *Conversation_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitConversation_statement(s) + } +} + +func (s *Conversation_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitConversation_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Conversation_statement() (localctx IConversation_statementContext) { + localctx = NewConversation_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 460, TSqlParserRULE_conversation_statement) + p.SetState(6359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 752, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6353) + p.Begin_conversation_timer() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6354) + p.Begin_conversation_dialog() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6355) + p.End_conversation() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6356) + p.Get_conversation() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6357) + p.Send_conversation() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6358) + p.Waitfor_conversation() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMessage_statementContext is an interface to support dynamic dispatch. +type IMessage_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMessage_type_name returns the message_type_name rule contexts. + GetMessage_type_name() IId_Context + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // GetSchema_collection_name returns the schema_collection_name rule contexts. + GetSchema_collection_name() IId_Context + + // SetMessage_type_name sets the message_type_name rule contexts. + SetMessage_type_name(IId_Context) + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // SetSchema_collection_name sets the schema_collection_name rule contexts. + SetSchema_collection_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + MESSAGE() antlr.TerminalNode + TYPE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + VALIDATION() antlr.TerminalNode + EQUAL() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + NONE() antlr.TerminalNode + EMPTY() antlr.TerminalNode + WELL_FORMED_XML() antlr.TerminalNode + VALID_XML() antlr.TerminalNode + WITH() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + COLLECTION() antlr.TerminalNode + + // IsMessage_statementContext differentiates from other interfaces. + IsMessage_statementContext() +} + +type Message_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + message_type_name IId_Context + owner_name IId_Context + schema_collection_name IId_Context +} + +func NewEmptyMessage_statementContext() *Message_statementContext { + var p = new(Message_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_message_statement + return p +} + +func InitEmptyMessage_statementContext(p *Message_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_message_statement +} + +func (*Message_statementContext) IsMessage_statementContext() {} + +func NewMessage_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Message_statementContext { + var p = new(Message_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_message_statement + + return p +} + +func (s *Message_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Message_statementContext) GetMessage_type_name() IId_Context { return s.message_type_name } + +func (s *Message_statementContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Message_statementContext) GetSchema_collection_name() IId_Context { + return s.schema_collection_name +} + +func (s *Message_statementContext) SetMessage_type_name(v IId_Context) { s.message_type_name = v } + +func (s *Message_statementContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Message_statementContext) SetSchema_collection_name(v IId_Context) { + s.schema_collection_name = v +} + +func (s *Message_statementContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Message_statementContext) MESSAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE, 0) +} + +func (s *Message_statementContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *Message_statementContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Message_statementContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Message_statementContext) VALIDATION() antlr.TerminalNode { + return s.GetToken(TSqlParserVALIDATION, 0) +} + +func (s *Message_statementContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Message_statementContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Message_statementContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Message_statementContext) EMPTY() antlr.TerminalNode { + return s.GetToken(TSqlParserEMPTY, 0) +} + +func (s *Message_statementContext) WELL_FORMED_XML() antlr.TerminalNode { + return s.GetToken(TSqlParserWELL_FORMED_XML, 0) +} + +func (s *Message_statementContext) VALID_XML() antlr.TerminalNode { + return s.GetToken(TSqlParserVALID_XML, 0) +} + +func (s *Message_statementContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Message_statementContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Message_statementContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLECTION, 0) +} + +func (s *Message_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Message_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Message_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMessage_statement(s) + } +} + +func (s *Message_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMessage_statement(s) + } +} + +func (s *Message_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMessage_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Message_statement() (localctx IMessage_statementContext) { + localctx = NewMessage_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 462, TSqlParserRULE_message_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6361) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6362) + p.Match(TSqlParserMESSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6363) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6364) + + var _x = p.Id_() + + localctx.(*Message_statementContext).message_type_name = _x + } + p.SetState(6367) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(6365) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6366) + + var _x = p.Id_() + + localctx.(*Message_statementContext).owner_name = _x + } + + } + + { + p.SetState(6369) + p.Match(TSqlParserVALIDATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6370) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserNONE: + { + p.SetState(6371) + p.Match(TSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEMPTY: + { + p.SetState(6372) + p.Match(TSqlParserEMPTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserWELL_FORMED_XML: + { + p.SetState(6373) + p.Match(TSqlParserWELL_FORMED_XML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserVALID_XML: + { + p.SetState(6374) + p.Match(TSqlParserVALID_XML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6375) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6376) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6377) + p.Match(TSqlParserCOLLECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6378) + + var _x = p.Id_() + + localctx.(*Message_statementContext).schema_collection_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_statementContext is an interface to support dynamic dispatch. +type IMerge_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MERGE() antlr.TerminalNode + Ddl_object() IDdl_objectContext + USING() antlr.TerminalNode + Table_sources() ITable_sourcesContext + ON() antlr.TerminalNode + Search_condition() ISearch_conditionContext + SEMI() antlr.TerminalNode + With_expression() IWith_expressionContext + TOP() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET() antlr.TerminalNode + INTO() antlr.TerminalNode + With_table_hints() IWith_table_hintsContext + As_table_alias() IAs_table_aliasContext + AllWhen_matches() []IWhen_matchesContext + When_matches(i int) IWhen_matchesContext + Output_clause() IOutput_clauseContext + Option_clause() IOption_clauseContext + PERCENT() antlr.TerminalNode + + // IsMerge_statementContext differentiates from other interfaces. + IsMerge_statementContext() +} + +type Merge_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_statementContext() *Merge_statementContext { + var p = new(Merge_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_merge_statement + return p +} + +func InitEmptyMerge_statementContext(p *Merge_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_merge_statement +} + +func (*Merge_statementContext) IsMerge_statementContext() {} + +func NewMerge_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_statementContext { + var p = new(Merge_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_merge_statement + + return p +} + +func (s *Merge_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_statementContext) MERGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMERGE, 0) +} + +func (s *Merge_statementContext) Ddl_object() IDdl_objectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDdl_objectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDdl_objectContext) +} + +func (s *Merge_statementContext) USING() antlr.TerminalNode { + return s.GetToken(TSqlParserUSING, 0) +} + +func (s *Merge_statementContext) Table_sources() ITable_sourcesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_sourcesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_sourcesContext) +} + +func (s *Merge_statementContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Merge_statementContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Merge_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Merge_statementContext) With_expression() IWith_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_expressionContext) +} + +func (s *Merge_statementContext) TOP() antlr.TerminalNode { + return s.GetToken(TSqlParserTOP, 0) +} + +func (s *Merge_statementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Merge_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Merge_statementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Merge_statementContext) INTO() antlr.TerminalNode { + return s.GetToken(TSqlParserINTO, 0) +} + +func (s *Merge_statementContext) With_table_hints() IWith_table_hintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_table_hintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_table_hintsContext) +} + +func (s *Merge_statementContext) As_table_alias() IAs_table_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_table_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_table_aliasContext) +} + +func (s *Merge_statementContext) AllWhen_matches() []IWhen_matchesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWhen_matchesContext); ok { + len++ + } + } + + tst := make([]IWhen_matchesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWhen_matchesContext); ok { + tst[i] = t.(IWhen_matchesContext) + i++ + } + } + + return tst +} + +func (s *Merge_statementContext) When_matches(i int) IWhen_matchesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhen_matchesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWhen_matchesContext) +} + +func (s *Merge_statementContext) Output_clause() IOutput_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOutput_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOutput_clauseContext) +} + +func (s *Merge_statementContext) Option_clause() IOption_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOption_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOption_clauseContext) +} + +func (s *Merge_statementContext) PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserPERCENT, 0) +} + +func (s *Merge_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMerge_statement(s) + } +} + +func (s *Merge_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMerge_statement(s) + } +} + +func (s *Merge_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMerge_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Merge_statement() (localctx IMerge_statementContext) { + localctx = NewMerge_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 464, TSqlParserRULE_merge_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(6381) + p.With_expression() + } + + } + { + p.SetState(6384) + p.Match(TSqlParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserTOP { + { + p.SetState(6385) + p.Match(TSqlParserTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6386) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6387) + p.expression(0) + } + { + p.SetState(6388) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6390) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPERCENT { + { + p.SetState(6389) + p.Match(TSqlParserPERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(6395) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserINTO { + { + p.SetState(6394) + p.Match(TSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6397) + p.Ddl_object() + } + p.SetState(6399) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(6398) + p.With_table_hints() + } + + } + p.SetState(6402) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 760, p.GetParserRuleContext()) == 1 { + { + p.SetState(6401) + p.As_table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6404) + p.Match(TSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6405) + p.Table_sources() + } + { + p.SetState(6406) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6407) + p.search_condition(0) + } + p.SetState(6409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserWHEN { + { + p.SetState(6408) + p.When_matches() + } + + p.SetState(6411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6414) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOUTPUT { + { + p.SetState(6413) + p.Output_clause() + } + + } + p.SetState(6417) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOPTION { + { + p.SetState(6416) + p.Option_clause() + } + + } + { + p.SetState(6419) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhen_matchesContext is an interface to support dynamic dispatch. +type IWhen_matchesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllWHEN() []antlr.TerminalNode + WHEN(i int) antlr.TerminalNode + AllMATCHED() []antlr.TerminalNode + MATCHED(i int) antlr.TerminalNode + AllTHEN() []antlr.TerminalNode + THEN(i int) antlr.TerminalNode + AllMerge_matched() []IMerge_matchedContext + Merge_matched(i int) IMerge_matchedContext + AllAND() []antlr.TerminalNode + AND(i int) antlr.TerminalNode + AllSearch_condition() []ISearch_conditionContext + Search_condition(i int) ISearch_conditionContext + AllNOT() []antlr.TerminalNode + NOT(i int) antlr.TerminalNode + Merge_not_matched() IMerge_not_matchedContext + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + TARGET() antlr.TerminalNode + AllSOURCE() []antlr.TerminalNode + SOURCE(i int) antlr.TerminalNode + + // IsWhen_matchesContext differentiates from other interfaces. + IsWhen_matchesContext() +} + +type When_matchesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhen_matchesContext() *When_matchesContext { + var p = new(When_matchesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_when_matches + return p +} + +func InitEmptyWhen_matchesContext(p *When_matchesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_when_matches +} + +func (*When_matchesContext) IsWhen_matchesContext() {} + +func NewWhen_matchesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *When_matchesContext { + var p = new(When_matchesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_when_matches + + return p +} + +func (s *When_matchesContext) GetParser() antlr.Parser { return s.parser } + +func (s *When_matchesContext) AllWHEN() []antlr.TerminalNode { + return s.GetTokens(TSqlParserWHEN) +} + +func (s *When_matchesContext) WHEN(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserWHEN, i) +} + +func (s *When_matchesContext) AllMATCHED() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMATCHED) +} + +func (s *When_matchesContext) MATCHED(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMATCHED, i) +} + +func (s *When_matchesContext) AllTHEN() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTHEN) +} + +func (s *When_matchesContext) THEN(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTHEN, i) +} + +func (s *When_matchesContext) AllMerge_matched() []IMerge_matchedContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMerge_matchedContext); ok { + len++ + } + } + + tst := make([]IMerge_matchedContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMerge_matchedContext); ok { + tst[i] = t.(IMerge_matchedContext) + i++ + } + } + + return tst +} + +func (s *When_matchesContext) Merge_matched(i int) IMerge_matchedContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_matchedContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMerge_matchedContext) +} + +func (s *When_matchesContext) AllAND() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAND) +} + +func (s *When_matchesContext) AND(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAND, i) +} + +func (s *When_matchesContext) AllSearch_condition() []ISearch_conditionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISearch_conditionContext); ok { + len++ + } + } + + tst := make([]ISearch_conditionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISearch_conditionContext); ok { + tst[i] = t.(ISearch_conditionContext) + i++ + } + } + + return tst +} + +func (s *When_matchesContext) Search_condition(i int) ISearch_conditionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *When_matchesContext) AllNOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOT) +} + +func (s *When_matchesContext) NOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, i) +} + +func (s *When_matchesContext) Merge_not_matched() IMerge_not_matchedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_not_matchedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_not_matchedContext) +} + +func (s *When_matchesContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBY) +} + +func (s *When_matchesContext) BY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBY, i) +} + +func (s *When_matchesContext) TARGET() antlr.TerminalNode { + return s.GetToken(TSqlParserTARGET, 0) +} + +func (s *When_matchesContext) AllSOURCE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSOURCE) +} + +func (s *When_matchesContext) SOURCE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSOURCE, i) +} + +func (s *When_matchesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *When_matchesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *When_matchesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterWhen_matches(s) + } +} + +func (s *When_matchesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitWhen_matches(s) + } +} + +func (s *When_matchesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitWhen_matches(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) When_matches() (localctx IWhen_matchesContext) { + localctx = NewWhen_matchesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 466, TSqlParserRULE_when_matches) + var _la int + + var _alt int + + p.SetState(6461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 770, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(6429) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(6421) + p.Match(TSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6422) + p.Match(TSqlParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6425) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAND { + { + p.SetState(6423) + p.Match(TSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6424) + p.search_condition(0) + } + + } + { + p.SetState(6427) + p.Match(TSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6428) + p.Merge_matched() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(6431) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 765, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6433) + p.Match(TSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6434) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6435) + p.Match(TSqlParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6438) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserBY { + { + p.SetState(6436) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6437) + p.Match(TSqlParserTARGET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAND { + { + p.SetState(6440) + p.Match(TSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6441) + p.search_condition(0) + } + + } + { + p.SetState(6444) + p.Match(TSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6445) + p.Merge_not_matched() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + p.SetState(6457) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(6446) + p.Match(TSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6447) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6448) + p.Match(TSqlParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6449) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6450) + p.Match(TSqlParserSOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAND { + { + p.SetState(6451) + p.Match(TSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6452) + p.search_condition(0) + } + + } + { + p.SetState(6455) + p.Match(TSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6456) + p.Merge_matched() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(6459) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 769, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_matchedContext is an interface to support dynamic dispatch. +type IMerge_matchedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPDATE() antlr.TerminalNode + SET() antlr.TerminalNode + AllUpdate_elem_merge() []IUpdate_elem_mergeContext + Update_elem_merge(i int) IUpdate_elem_mergeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DELETE() antlr.TerminalNode + + // IsMerge_matchedContext differentiates from other interfaces. + IsMerge_matchedContext() +} + +type Merge_matchedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_matchedContext() *Merge_matchedContext { + var p = new(Merge_matchedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_merge_matched + return p +} + +func InitEmptyMerge_matchedContext(p *Merge_matchedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_merge_matched +} + +func (*Merge_matchedContext) IsMerge_matchedContext() {} + +func NewMerge_matchedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_matchedContext { + var p = new(Merge_matchedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_merge_matched + + return p +} + +func (s *Merge_matchedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_matchedContext) UPDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserUPDATE, 0) +} + +func (s *Merge_matchedContext) SET() antlr.TerminalNode { + return s.GetToken(TSqlParserSET, 0) +} + +func (s *Merge_matchedContext) AllUpdate_elem_merge() []IUpdate_elem_mergeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdate_elem_mergeContext); ok { + len++ + } + } + + tst := make([]IUpdate_elem_mergeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdate_elem_mergeContext); ok { + tst[i] = t.(IUpdate_elem_mergeContext) + i++ + } + } + + return tst +} + +func (s *Merge_matchedContext) Update_elem_merge(i int) IUpdate_elem_mergeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_elem_mergeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_elem_mergeContext) +} + +func (s *Merge_matchedContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Merge_matchedContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Merge_matchedContext) DELETE() antlr.TerminalNode { + return s.GetToken(TSqlParserDELETE, 0) +} + +func (s *Merge_matchedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_matchedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_matchedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMerge_matched(s) + } +} + +func (s *Merge_matchedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMerge_matched(s) + } +} + +func (s *Merge_matchedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMerge_matched(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Merge_matched() (localctx IMerge_matchedContext) { + localctx = NewMerge_matchedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 468, TSqlParserRULE_merge_matched) + var _la int + + p.SetState(6474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserUPDATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6463) + p.Match(TSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6464) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6465) + p.Update_elem_merge() + } + p.SetState(6470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(6466) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6467) + p.Update_elem_merge() + } + + p.SetState(6472) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case TSqlParserDELETE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6473) + p.Match(TSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_not_matchedContext is an interface to support dynamic dispatch. +type IMerge_not_matchedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSERT() antlr.TerminalNode + Table_value_constructor() ITable_value_constructorContext + DEFAULT() antlr.TerminalNode + VALUES() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Column_name_list() IColumn_name_listContext + RR_BRACKET() antlr.TerminalNode + + // IsMerge_not_matchedContext differentiates from other interfaces. + IsMerge_not_matchedContext() +} + +type Merge_not_matchedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_not_matchedContext() *Merge_not_matchedContext { + var p = new(Merge_not_matchedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_merge_not_matched + return p +} + +func InitEmptyMerge_not_matchedContext(p *Merge_not_matchedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_merge_not_matched +} + +func (*Merge_not_matchedContext) IsMerge_not_matchedContext() {} + +func NewMerge_not_matchedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_not_matchedContext { + var p = new(Merge_not_matchedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_merge_not_matched + + return p +} + +func (s *Merge_not_matchedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_not_matchedContext) INSERT() antlr.TerminalNode { + return s.GetToken(TSqlParserINSERT, 0) +} + +func (s *Merge_not_matchedContext) Table_value_constructor() ITable_value_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_value_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_value_constructorContext) +} + +func (s *Merge_not_matchedContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Merge_not_matchedContext) VALUES() antlr.TerminalNode { + return s.GetToken(TSqlParserVALUES, 0) +} + +func (s *Merge_not_matchedContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Merge_not_matchedContext) Column_name_list() IColumn_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Merge_not_matchedContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Merge_not_matchedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_not_matchedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_not_matchedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMerge_not_matched(s) + } +} + +func (s *Merge_not_matchedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMerge_not_matched(s) + } +} + +func (s *Merge_not_matchedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMerge_not_matched(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Merge_not_matched() (localctx IMerge_not_matchedContext) { + localctx = NewMerge_not_matchedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 470, TSqlParserRULE_merge_not_matched) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6476) + p.Match(TSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLR_BRACKET { + { + p.SetState(6477) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6478) + p.Column_name_list() + } + { + p.SetState(6479) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserVALUES: + { + p.SetState(6483) + p.Table_value_constructor() + } + + case TSqlParserDEFAULT: + { + p.SetState(6484) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6485) + p.Match(TSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDelete_statementContext is an interface to support dynamic dispatch. +type IDelete_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCursor_var returns the cursor_var token. + GetCursor_var() antlr.Token + + // SetCursor_var sets the cursor_var token. + SetCursor_var(antlr.Token) + + // Getter signatures + DELETE() antlr.TerminalNode + Delete_statement_from() IDelete_statement_fromContext + With_expression() IWith_expressionContext + TOP() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + FROM() antlr.TerminalNode + With_table_hints() IWith_table_hintsContext + Output_clause() IOutput_clauseContext + From_table_sources() IFrom_table_sourcesContext + WHERE() antlr.TerminalNode + For_clause() IFor_clauseContext + Option_clause() IOption_clauseContext + SEMI() antlr.TerminalNode + Search_condition() ISearch_conditionContext + CURRENT() antlr.TerminalNode + OF() antlr.TerminalNode + PERCENT() antlr.TerminalNode + Cursor_name() ICursor_nameContext + LOCAL_ID() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + + // IsDelete_statementContext differentiates from other interfaces. + IsDelete_statementContext() +} + +type Delete_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + cursor_var antlr.Token +} + +func NewEmptyDelete_statementContext() *Delete_statementContext { + var p = new(Delete_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_delete_statement + return p +} + +func InitEmptyDelete_statementContext(p *Delete_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_delete_statement +} + +func (*Delete_statementContext) IsDelete_statementContext() {} + +func NewDelete_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_statementContext { + var p = new(Delete_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_delete_statement + + return p +} + +func (s *Delete_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Delete_statementContext) GetCursor_var() antlr.Token { return s.cursor_var } + +func (s *Delete_statementContext) SetCursor_var(v antlr.Token) { s.cursor_var = v } + +func (s *Delete_statementContext) DELETE() antlr.TerminalNode { + return s.GetToken(TSqlParserDELETE, 0) +} + +func (s *Delete_statementContext) Delete_statement_from() IDelete_statement_fromContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelete_statement_fromContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelete_statement_fromContext) +} + +func (s *Delete_statementContext) With_expression() IWith_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_expressionContext) +} + +func (s *Delete_statementContext) TOP() antlr.TerminalNode { + return s.GetToken(TSqlParserTOP, 0) +} + +func (s *Delete_statementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Delete_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Delete_statementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Delete_statementContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Delete_statementContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Delete_statementContext) With_table_hints() IWith_table_hintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_table_hintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_table_hintsContext) +} + +func (s *Delete_statementContext) Output_clause() IOutput_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOutput_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOutput_clauseContext) +} + +func (s *Delete_statementContext) From_table_sources() IFrom_table_sourcesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_table_sourcesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_table_sourcesContext) +} + +func (s *Delete_statementContext) WHERE() antlr.TerminalNode { + return s.GetToken(TSqlParserWHERE, 0) +} + +func (s *Delete_statementContext) For_clause() IFor_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_clauseContext) +} + +func (s *Delete_statementContext) Option_clause() IOption_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOption_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOption_clauseContext) +} + +func (s *Delete_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Delete_statementContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Delete_statementContext) CURRENT() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT, 0) +} + +func (s *Delete_statementContext) OF() antlr.TerminalNode { + return s.GetToken(TSqlParserOF, 0) +} + +func (s *Delete_statementContext) PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserPERCENT, 0) +} + +func (s *Delete_statementContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Delete_statementContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Delete_statementContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(TSqlParserGLOBAL, 0) +} + +func (s *Delete_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Delete_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Delete_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDelete_statement(s) + } +} + +func (s *Delete_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDelete_statement(s) + } +} + +func (s *Delete_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDelete_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Delete_statement() (localctx IDelete_statementContext) { + localctx = NewDelete_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 472, TSqlParserRULE_delete_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6489) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(6488) + p.With_expression() + } + + } + { + p.SetState(6491) + p.Match(TSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6501) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 777, p.GetParserRuleContext()) == 1 { + { + p.SetState(6492) + p.Match(TSqlParserTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6493) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6494) + p.expression(0) + } + { + p.SetState(6495) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6497) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPERCENT { + { + p.SetState(6496) + p.Match(TSqlParserPERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 777, p.GetParserRuleContext()) == 2 { + { + p.SetState(6499) + p.Match(TSqlParserTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6500) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6504) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFROM { + { + p.SetState(6503) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6506) + p.Delete_statement_from() + } + p.SetState(6508) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 779, p.GetParserRuleContext()) == 1 { + { + p.SetState(6507) + p.With_table_hints() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6511) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 780, p.GetParserRuleContext()) == 1 { + { + p.SetState(6510) + p.Output_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFROM { + { + p.SetState(6513) + p.From_table_sources() + } + + } + p.SetState(6529) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWHERE { + { + p.SetState(6516) + p.Match(TSqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6527) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCASE, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOALESCE, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTAINS, TSqlParserCONTAINSTABLE, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCONVERT, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_DATE, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TIMESTAMP, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURRENT_USER, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDOLLAR_PARTITION, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXISTS, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFREETEXT, TSqlParserFREETEXTTABLE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEFT, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOT, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULLIF, TSqlParserNULL_, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVER, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserRIGHT, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMANTICKEYPHRASETABLE, TSqlParserSEMANTICSIMILARITYDETAILSTABLE, TSqlParserSEMANTICSIMILARITYTABLE, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSESSION_USER, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserSYSTEM_USER, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOLLAR_ACTION, TSqlParserCURSOR_ROWS, TSqlParserFETCH_STATUS, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserLOCAL_ID, TSqlParserTEMP_ID, TSqlParserDECIMAL, TSqlParserID, TSqlParserSTRING, TSqlParserBINARY, TSqlParserFLOAT, TSqlParserREAL, TSqlParserDOT, TSqlParserDOLLAR, TSqlParserLR_BRACKET, TSqlParserPLUS, TSqlParserMINUS, TSqlParserBIT_NOT, TSqlParserPLACEHOLDER: + { + p.SetState(6517) + p.search_condition(0) + } + + case TSqlParserCURRENT: + { + p.SetState(6518) + p.Match(TSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6519) + p.Match(TSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 783, p.GetParserRuleContext()) { + case 1: + p.SetState(6521) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 782, p.GetParserRuleContext()) == 1 { + { + p.SetState(6520) + p.Match(TSqlParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6523) + p.Cursor_name() + } + + case 2: + { + p.SetState(6524) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*Delete_statementContext).cursor_var = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(6532) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR { + { + p.SetState(6531) + p.For_clause() + } + + } + p.SetState(6535) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOPTION { + { + p.SetState(6534) + p.Option_clause() + } + + } + p.SetState(6538) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 788, p.GetParserRuleContext()) == 1 { + { + p.SetState(6537) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDelete_statement_fromContext is an interface to support dynamic dispatch. +type IDelete_statement_fromContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTable_var returns the table_var token. + GetTable_var() antlr.Token + + // SetTable_var sets the table_var token. + SetTable_var(antlr.Token) + + // Getter signatures + Ddl_object() IDdl_objectContext + Rowset_function_limited() IRowset_function_limitedContext + LOCAL_ID() antlr.TerminalNode + + // IsDelete_statement_fromContext differentiates from other interfaces. + IsDelete_statement_fromContext() +} + +type Delete_statement_fromContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + table_var antlr.Token +} + +func NewEmptyDelete_statement_fromContext() *Delete_statement_fromContext { + var p = new(Delete_statement_fromContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_delete_statement_from + return p +} + +func InitEmptyDelete_statement_fromContext(p *Delete_statement_fromContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_delete_statement_from +} + +func (*Delete_statement_fromContext) IsDelete_statement_fromContext() {} + +func NewDelete_statement_fromContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_statement_fromContext { + var p = new(Delete_statement_fromContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_delete_statement_from + + return p +} + +func (s *Delete_statement_fromContext) GetParser() antlr.Parser { return s.parser } + +func (s *Delete_statement_fromContext) GetTable_var() antlr.Token { return s.table_var } + +func (s *Delete_statement_fromContext) SetTable_var(v antlr.Token) { s.table_var = v } + +func (s *Delete_statement_fromContext) Ddl_object() IDdl_objectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDdl_objectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDdl_objectContext) +} + +func (s *Delete_statement_fromContext) Rowset_function_limited() IRowset_function_limitedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowset_function_limitedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowset_function_limitedContext) +} + +func (s *Delete_statement_fromContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Delete_statement_fromContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Delete_statement_fromContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Delete_statement_fromContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDelete_statement_from(s) + } +} + +func (s *Delete_statement_fromContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDelete_statement_from(s) + } +} + +func (s *Delete_statement_fromContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDelete_statement_from(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Delete_statement_from() (localctx IDelete_statement_fromContext) { + localctx = NewDelete_statement_fromContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 474, TSqlParserRULE_delete_statement_from) + p.SetState(6543) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 789, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6540) + p.Ddl_object() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6541) + p.Rowset_function_limited() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6542) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*Delete_statement_fromContext).table_var = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_statementContext is an interface to support dynamic dispatch. +type IInsert_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSERT() antlr.TerminalNode + Insert_statement_value() IInsert_statement_valueContext + Ddl_object() IDdl_objectContext + Rowset_function_limited() IRowset_function_limitedContext + With_expression() IWith_expressionContext + TOP() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + Expression() IExpressionContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + INTO() antlr.TerminalNode + With_table_hints() IWith_table_hintsContext + Insert_column_name_list() IInsert_column_name_listContext + Output_clause() IOutput_clauseContext + For_clause() IFor_clauseContext + Option_clause() IOption_clauseContext + SEMI() antlr.TerminalNode + PERCENT() antlr.TerminalNode + + // IsInsert_statementContext differentiates from other interfaces. + IsInsert_statementContext() +} + +type Insert_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_statementContext() *Insert_statementContext { + var p = new(Insert_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_insert_statement + return p +} + +func InitEmptyInsert_statementContext(p *Insert_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_insert_statement +} + +func (*Insert_statementContext) IsInsert_statementContext() {} + +func NewInsert_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_statementContext { + var p = new(Insert_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_insert_statement + + return p +} + +func (s *Insert_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_statementContext) INSERT() antlr.TerminalNode { + return s.GetToken(TSqlParserINSERT, 0) +} + +func (s *Insert_statementContext) Insert_statement_value() IInsert_statement_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_statement_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_statement_valueContext) +} + +func (s *Insert_statementContext) Ddl_object() IDdl_objectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDdl_objectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDdl_objectContext) +} + +func (s *Insert_statementContext) Rowset_function_limited() IRowset_function_limitedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowset_function_limitedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowset_function_limitedContext) +} + +func (s *Insert_statementContext) With_expression() IWith_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_expressionContext) +} + +func (s *Insert_statementContext) TOP() antlr.TerminalNode { + return s.GetToken(TSqlParserTOP, 0) +} + +func (s *Insert_statementContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Insert_statementContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Insert_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Insert_statementContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Insert_statementContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Insert_statementContext) INTO() antlr.TerminalNode { + return s.GetToken(TSqlParserINTO, 0) +} + +func (s *Insert_statementContext) With_table_hints() IWith_table_hintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_table_hintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_table_hintsContext) +} + +func (s *Insert_statementContext) Insert_column_name_list() IInsert_column_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_column_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_column_name_listContext) +} + +func (s *Insert_statementContext) Output_clause() IOutput_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOutput_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOutput_clauseContext) +} + +func (s *Insert_statementContext) For_clause() IFor_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_clauseContext) +} + +func (s *Insert_statementContext) Option_clause() IOption_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOption_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOption_clauseContext) +} + +func (s *Insert_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Insert_statementContext) PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserPERCENT, 0) +} + +func (s *Insert_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterInsert_statement(s) + } +} + +func (s *Insert_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitInsert_statement(s) + } +} + +func (s *Insert_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitInsert_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Insert_statement() (localctx IInsert_statementContext) { + localctx = NewInsert_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 476, TSqlParserRULE_insert_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(6545) + p.With_expression() + } + + } + { + p.SetState(6548) + p.Match(TSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6556) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserTOP { + { + p.SetState(6549) + p.Match(TSqlParserTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6550) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6551) + p.expression(0) + } + { + p.SetState(6552) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPERCENT { + { + p.SetState(6553) + p.Match(TSqlParserPERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(6559) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserINTO { + { + p.SetState(6558) + p.Match(TSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserLOCAL_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(6561) + p.Ddl_object() + } + + case TSqlParserOPENDATASOURCE, TSqlParserOPENQUERY: + { + p.SetState(6562) + p.Rowset_function_limited() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(6565) + p.With_table_hints() + } + + } + p.SetState(6572) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 796, p.GetParserRuleContext()) == 1 { + { + p.SetState(6568) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6569) + p.Insert_column_name_list() + } + { + p.SetState(6570) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6575) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOUTPUT { + { + p.SetState(6574) + p.Output_clause() + } + + } + { + p.SetState(6577) + p.Insert_statement_value() + } + p.SetState(6579) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR { + { + p.SetState(6578) + p.For_clause() + } + + } + p.SetState(6582) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOPTION { + { + p.SetState(6581) + p.Option_clause() + } + + } + p.SetState(6585) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 800, p.GetParserRuleContext()) == 1 { + { + p.SetState(6584) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_statement_valueContext is an interface to support dynamic dispatch. +type IInsert_statement_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Derived_table() IDerived_tableContext + Execute_statement() IExecute_statementContext + DEFAULT() antlr.TerminalNode + VALUES() antlr.TerminalNode + + // IsInsert_statement_valueContext differentiates from other interfaces. + IsInsert_statement_valueContext() +} + +type Insert_statement_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_statement_valueContext() *Insert_statement_valueContext { + var p = new(Insert_statement_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_insert_statement_value + return p +} + +func InitEmptyInsert_statement_valueContext(p *Insert_statement_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_insert_statement_value +} + +func (*Insert_statement_valueContext) IsInsert_statement_valueContext() {} + +func NewInsert_statement_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_statement_valueContext { + var p = new(Insert_statement_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_insert_statement_value + + return p +} + +func (s *Insert_statement_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_statement_valueContext) Derived_table() IDerived_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDerived_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDerived_tableContext) +} + +func (s *Insert_statement_valueContext) Execute_statement() IExecute_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_statementContext) +} + +func (s *Insert_statement_valueContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Insert_statement_valueContext) VALUES() antlr.TerminalNode { + return s.GetToken(TSqlParserVALUES, 0) +} + +func (s *Insert_statement_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_statement_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_statement_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterInsert_statement_value(s) + } +} + +func (s *Insert_statement_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitInsert_statement_value(s) + } +} + +func (s *Insert_statement_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitInsert_statement_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Insert_statement_value() (localctx IInsert_statement_valueContext) { + localctx = NewInsert_statement_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 478, TSqlParserRULE_insert_statement_value) + p.SetState(6591) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSELECT, TSqlParserVALUES, TSqlParserLR_BRACKET: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6587) + p.Derived_table() + } + + case TSqlParserEXECUTE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6588) + p.Execute_statement() + } + + case TSqlParserDEFAULT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6589) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6590) + p.Match(TSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReceive_statementContext is an interface to support dynamic dispatch. +type IReceive_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTable_variable returns the table_variable rule contexts. + GetTable_variable() IId_Context + + // GetWhere returns the where rule contexts. + GetWhere() ISearch_conditionContext + + // SetTable_variable sets the table_variable rule contexts. + SetTable_variable(IId_Context) + + // SetWhere sets the where rule contexts. + SetWhere(ISearch_conditionContext) + + // Getter signatures + RECEIVE() antlr.TerminalNode + FROM() antlr.TerminalNode + Full_table_name() IFull_table_nameContext + ALL() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + Top_clause() ITop_clauseContext + STAR() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllLOCAL_ID() []antlr.TerminalNode + LOCAL_ID(i int) antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + INTO() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Id_() IId_Context + WHERE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Search_condition() ISearch_conditionContext + + // IsReceive_statementContext differentiates from other interfaces. + IsReceive_statementContext() +} + +type Receive_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + table_variable IId_Context + where ISearch_conditionContext +} + +func NewEmptyReceive_statementContext() *Receive_statementContext { + var p = new(Receive_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_receive_statement + return p +} + +func InitEmptyReceive_statementContext(p *Receive_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_receive_statement +} + +func (*Receive_statementContext) IsReceive_statementContext() {} + +func NewReceive_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Receive_statementContext { + var p = new(Receive_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_receive_statement + + return p +} + +func (s *Receive_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Receive_statementContext) GetTable_variable() IId_Context { return s.table_variable } + +func (s *Receive_statementContext) GetWhere() ISearch_conditionContext { return s.where } + +func (s *Receive_statementContext) SetTable_variable(v IId_Context) { s.table_variable = v } + +func (s *Receive_statementContext) SetWhere(v ISearch_conditionContext) { s.where = v } + +func (s *Receive_statementContext) RECEIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserRECEIVE, 0) +} + +func (s *Receive_statementContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Receive_statementContext) Full_table_name() IFull_table_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_table_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_table_nameContext) +} + +func (s *Receive_statementContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Receive_statementContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(TSqlParserDISTINCT, 0) +} + +func (s *Receive_statementContext) Top_clause() ITop_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITop_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITop_clauseContext) +} + +func (s *Receive_statementContext) STAR() antlr.TerminalNode { + return s.GetToken(TSqlParserSTAR, 0) +} + +func (s *Receive_statementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Receive_statementContext) AllLOCAL_ID() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOCAL_ID) +} + +func (s *Receive_statementContext) LOCAL_ID(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, i) +} + +func (s *Receive_statementContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Receive_statementContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Receive_statementContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Receive_statementContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Receive_statementContext) INTO() antlr.TerminalNode { + return s.GetToken(TSqlParserINTO, 0) +} + +func (s *Receive_statementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Receive_statementContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Receive_statementContext) WHERE() antlr.TerminalNode { + return s.GetToken(TSqlParserWHERE, 0) +} + +func (s *Receive_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Receive_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Receive_statementContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Receive_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Receive_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Receive_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterReceive_statement(s) + } +} + +func (s *Receive_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitReceive_statement(s) + } +} + +func (s *Receive_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitReceive_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Receive_statement() (localctx IReceive_statementContext) { + localctx = NewReceive_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 480, TSqlParserRULE_receive_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6594) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLR_BRACKET { + { + p.SetState(6593) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6596) + p.Match(TSqlParserRECEIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALL: + { + p.SetState(6597) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDISTINCT: + { + p.SetState(6598) + p.Match(TSqlParserDISTINCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTOP: + { + p.SetState(6599) + p.Top_clause() + } + + case TSqlParserSTAR: + { + p.SetState(6600) + p.Match(TSqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserLOCAL_ID { + { + p.SetState(6603) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6604) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6605) + p.expression(0) + } + p.SetState(6607) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(6606) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(6613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6614) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6615) + p.Full_table_name() + } + p.SetState(6621) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserINTO { + { + p.SetState(6616) + p.Match(TSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6617) + + var _x = p.Id_() + + localctx.(*Receive_statementContext).table_variable = _x + } + + { + p.SetState(6618) + p.Match(TSqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6619) + + var _x = p.search_condition(0) + + localctx.(*Receive_statementContext).where = _x + } + + } + p.SetState(6624) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserRR_BRACKET { + { + p.SetState(6623) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_statement_standaloneContext is an interface to support dynamic dispatch. +type ISelect_statement_standaloneContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_statement() ISelect_statementContext + With_expression() IWith_expressionContext + + // IsSelect_statement_standaloneContext differentiates from other interfaces. + IsSelect_statement_standaloneContext() +} + +type Select_statement_standaloneContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_statement_standaloneContext() *Select_statement_standaloneContext { + var p = new(Select_statement_standaloneContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_select_statement_standalone + return p +} + +func InitEmptySelect_statement_standaloneContext(p *Select_statement_standaloneContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_select_statement_standalone +} + +func (*Select_statement_standaloneContext) IsSelect_statement_standaloneContext() {} + +func NewSelect_statement_standaloneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_statement_standaloneContext { + var p = new(Select_statement_standaloneContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_select_statement_standalone + + return p +} + +func (s *Select_statement_standaloneContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_statement_standaloneContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Select_statement_standaloneContext) With_expression() IWith_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_expressionContext) +} + +func (s *Select_statement_standaloneContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_statement_standaloneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_statement_standaloneContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSelect_statement_standalone(s) + } +} + +func (s *Select_statement_standaloneContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSelect_statement_standalone(s) + } +} + +func (s *Select_statement_standaloneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSelect_statement_standalone(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Select_statement_standalone() (localctx ISelect_statement_standaloneContext) { + localctx = NewSelect_statement_standaloneContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 482, TSqlParserRULE_select_statement_standalone) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(6626) + p.With_expression() + } + + } + { + p.SetState(6629) + p.Select_statement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_statementContext is an interface to support dynamic dispatch. +type ISelect_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_expression() IQuery_expressionContext + Select_order_by_clause() ISelect_order_by_clauseContext + For_clause() IFor_clauseContext + Option_clause() IOption_clauseContext + SEMI() antlr.TerminalNode + + // IsSelect_statementContext differentiates from other interfaces. + IsSelect_statementContext() +} + +type Select_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_statementContext() *Select_statementContext { + var p = new(Select_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_select_statement + return p +} + +func InitEmptySelect_statementContext(p *Select_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_select_statement +} + +func (*Select_statementContext) IsSelect_statementContext() {} + +func NewSelect_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_statementContext { + var p = new(Select_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_select_statement + + return p +} + +func (s *Select_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_statementContext) Query_expression() IQuery_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_expressionContext) +} + +func (s *Select_statementContext) Select_order_by_clause() ISelect_order_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_order_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_order_by_clauseContext) +} + +func (s *Select_statementContext) For_clause() IFor_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_clauseContext) +} + +func (s *Select_statementContext) Option_clause() IOption_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOption_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOption_clauseContext) +} + +func (s *Select_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Select_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSelect_statement(s) + } +} + +func (s *Select_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSelect_statement(s) + } +} + +func (s *Select_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSelect_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Select_statement() (localctx ISelect_statementContext) { + localctx = NewSelect_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 484, TSqlParserRULE_select_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6631) + p.Query_expression() + } + p.SetState(6633) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserORDER { + { + p.SetState(6632) + p.Select_order_by_clause() + } + + } + p.SetState(6636) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 810, p.GetParserRuleContext()) == 1 { + { + p.SetState(6635) + p.For_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6639) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 811, p.GetParserRuleContext()) == 1 { + { + p.SetState(6638) + p.Option_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6642) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 812, p.GetParserRuleContext()) == 1 { + { + p.SetState(6641) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITimeContext is an interface to support dynamic dispatch. +type ITimeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL_ID() antlr.TerminalNode + Constant() IConstantContext + + // IsTimeContext differentiates from other interfaces. + IsTimeContext() +} + +type TimeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTimeContext() *TimeContext { + var p = new(TimeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_time + return p +} + +func InitEmptyTimeContext(p *TimeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_time +} + +func (*TimeContext) IsTimeContext() {} + +func NewTimeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TimeContext { + var p = new(TimeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_time + + return p +} + +func (s *TimeContext) GetParser() antlr.Parser { return s.parser } + +func (s *TimeContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *TimeContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *TimeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TimeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TimeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTime(s) + } +} + +func (s *TimeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTime(s) + } +} + +func (s *TimeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTime(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Time() (localctx ITimeContext) { + localctx = NewTimeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 486, TSqlParserRULE_time) + p.EnterOuterAlt(localctx, 1) + p.SetState(6646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLOCAL_ID: + { + p.SetState(6644) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL, TSqlParserSTRING, TSqlParserBINARY, TSqlParserFLOAT, TSqlParserREAL, TSqlParserDOLLAR, TSqlParserMINUS, TSqlParserPLACEHOLDER: + { + p.SetState(6645) + p.Constant() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_statementContext is an interface to support dynamic dispatch. +type IUpdate_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCursor_var returns the cursor_var token. + GetCursor_var() antlr.Token + + // SetCursor_var sets the cursor_var token. + SetCursor_var(antlr.Token) + + // Getter signatures + UPDATE() antlr.TerminalNode + SET() antlr.TerminalNode + AllUpdate_elem() []IUpdate_elemContext + Update_elem(i int) IUpdate_elemContext + Ddl_object() IDdl_objectContext + Rowset_function_limited() IRowset_function_limitedContext + With_expression() IWith_expressionContext + TOP() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET() antlr.TerminalNode + With_table_hints() IWith_table_hintsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Output_clause() IOutput_clauseContext + FROM() antlr.TerminalNode + Table_sources() ITable_sourcesContext + WHERE() antlr.TerminalNode + For_clause() IFor_clauseContext + Option_clause() IOption_clauseContext + SEMI() antlr.TerminalNode + Search_condition() ISearch_conditionContext + CURRENT() antlr.TerminalNode + OF() antlr.TerminalNode + PERCENT() antlr.TerminalNode + Cursor_name() ICursor_nameContext + LOCAL_ID() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + + // IsUpdate_statementContext differentiates from other interfaces. + IsUpdate_statementContext() +} + +type Update_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + cursor_var antlr.Token +} + +func NewEmptyUpdate_statementContext() *Update_statementContext { + var p = new(Update_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_update_statement + return p +} + +func InitEmptyUpdate_statementContext(p *Update_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_update_statement +} + +func (*Update_statementContext) IsUpdate_statementContext() {} + +func NewUpdate_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_statementContext { + var p = new(Update_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_update_statement + + return p +} + +func (s *Update_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_statementContext) GetCursor_var() antlr.Token { return s.cursor_var } + +func (s *Update_statementContext) SetCursor_var(v antlr.Token) { s.cursor_var = v } + +func (s *Update_statementContext) UPDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserUPDATE, 0) +} + +func (s *Update_statementContext) SET() antlr.TerminalNode { + return s.GetToken(TSqlParserSET, 0) +} + +func (s *Update_statementContext) AllUpdate_elem() []IUpdate_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdate_elemContext); ok { + len++ + } + } + + tst := make([]IUpdate_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdate_elemContext); ok { + tst[i] = t.(IUpdate_elemContext) + i++ + } + } + + return tst +} + +func (s *Update_statementContext) Update_elem(i int) IUpdate_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_elemContext) +} + +func (s *Update_statementContext) Ddl_object() IDdl_objectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDdl_objectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDdl_objectContext) +} + +func (s *Update_statementContext) Rowset_function_limited() IRowset_function_limitedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowset_function_limitedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowset_function_limitedContext) +} + +func (s *Update_statementContext) With_expression() IWith_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_expressionContext) +} + +func (s *Update_statementContext) TOP() antlr.TerminalNode { + return s.GetToken(TSqlParserTOP, 0) +} + +func (s *Update_statementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Update_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Update_statementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Update_statementContext) With_table_hints() IWith_table_hintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_table_hintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_table_hintsContext) +} + +func (s *Update_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Update_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Update_statementContext) Output_clause() IOutput_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOutput_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOutput_clauseContext) +} + +func (s *Update_statementContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Update_statementContext) Table_sources() ITable_sourcesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_sourcesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_sourcesContext) +} + +func (s *Update_statementContext) WHERE() antlr.TerminalNode { + return s.GetToken(TSqlParserWHERE, 0) +} + +func (s *Update_statementContext) For_clause() IFor_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_clauseContext) +} + +func (s *Update_statementContext) Option_clause() IOption_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOption_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOption_clauseContext) +} + +func (s *Update_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Update_statementContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Update_statementContext) CURRENT() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT, 0) +} + +func (s *Update_statementContext) OF() antlr.TerminalNode { + return s.GetToken(TSqlParserOF, 0) +} + +func (s *Update_statementContext) PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserPERCENT, 0) +} + +func (s *Update_statementContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Update_statementContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Update_statementContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(TSqlParserGLOBAL, 0) +} + +func (s *Update_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUpdate_statement(s) + } +} + +func (s *Update_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUpdate_statement(s) + } +} + +func (s *Update_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUpdate_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Update_statement() (localctx IUpdate_statementContext) { + localctx = NewUpdate_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 488, TSqlParserRULE_update_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(6648) + p.With_expression() + } + + } + { + p.SetState(6651) + p.Match(TSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6659) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserTOP { + { + p.SetState(6652) + p.Match(TSqlParserTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6653) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6654) + p.expression(0) + } + { + p.SetState(6655) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6657) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPERCENT { + { + p.SetState(6656) + p.Match(TSqlParserPERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(6663) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserLOCAL_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(6661) + p.Ddl_object() + } + + case TSqlParserOPENDATASOURCE, TSqlParserOPENQUERY: + { + p.SetState(6662) + p.Rowset_function_limited() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6666) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(6665) + p.With_table_hints() + } + + } + { + p.SetState(6668) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6669) + p.Update_elem() + } + p.SetState(6674) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(6670) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6671) + p.Update_elem() + } + + p.SetState(6676) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6678) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 820, p.GetParserRuleContext()) == 1 { + { + p.SetState(6677) + p.Output_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFROM { + { + p.SetState(6680) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6681) + p.Table_sources() + } + + } + p.SetState(6697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWHERE { + { + p.SetState(6684) + p.Match(TSqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCASE, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOALESCE, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTAINS, TSqlParserCONTAINSTABLE, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCONVERT, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_DATE, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TIMESTAMP, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURRENT_USER, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDOLLAR_PARTITION, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXISTS, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFREETEXT, TSqlParserFREETEXTTABLE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEFT, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOT, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULLIF, TSqlParserNULL_, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVER, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserRIGHT, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMANTICKEYPHRASETABLE, TSqlParserSEMANTICSIMILARITYDETAILSTABLE, TSqlParserSEMANTICSIMILARITYTABLE, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSESSION_USER, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserSYSTEM_USER, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOLLAR_ACTION, TSqlParserCURSOR_ROWS, TSqlParserFETCH_STATUS, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserLOCAL_ID, TSqlParserTEMP_ID, TSqlParserDECIMAL, TSqlParserID, TSqlParserSTRING, TSqlParserBINARY, TSqlParserFLOAT, TSqlParserREAL, TSqlParserDOT, TSqlParserDOLLAR, TSqlParserLR_BRACKET, TSqlParserPLUS, TSqlParserMINUS, TSqlParserBIT_NOT, TSqlParserPLACEHOLDER: + { + p.SetState(6685) + p.search_condition(0) + } + + case TSqlParserCURRENT: + { + p.SetState(6686) + p.Match(TSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6687) + p.Match(TSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 823, p.GetParserRuleContext()) { + case 1: + p.SetState(6689) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 822, p.GetParserRuleContext()) == 1 { + { + p.SetState(6688) + p.Match(TSqlParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6691) + p.Cursor_name() + } + + case 2: + { + p.SetState(6692) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*Update_statementContext).cursor_var = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(6700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR { + { + p.SetState(6699) + p.For_clause() + } + + } + p.SetState(6703) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOPTION { + { + p.SetState(6702) + p.Option_clause() + } + + } + p.SetState(6706) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 828, p.GetParserRuleContext()) == 1 { + { + p.SetState(6705) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOutput_clauseContext is an interface to support dynamic dispatch. +type IOutput_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OUTPUT() antlr.TerminalNode + AllOutput_dml_list_elem() []IOutput_dml_list_elemContext + Output_dml_list_elem(i int) IOutput_dml_list_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + INTO() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + Table_name() ITable_nameContext + LR_BRACKET() antlr.TerminalNode + Column_name_list() IColumn_name_listContext + RR_BRACKET() antlr.TerminalNode + + // IsOutput_clauseContext differentiates from other interfaces. + IsOutput_clauseContext() +} + +type Output_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOutput_clauseContext() *Output_clauseContext { + var p = new(Output_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_output_clause + return p +} + +func InitEmptyOutput_clauseContext(p *Output_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_output_clause +} + +func (*Output_clauseContext) IsOutput_clauseContext() {} + +func NewOutput_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Output_clauseContext { + var p = new(Output_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_output_clause + + return p +} + +func (s *Output_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Output_clauseContext) OUTPUT() antlr.TerminalNode { + return s.GetToken(TSqlParserOUTPUT, 0) +} + +func (s *Output_clauseContext) AllOutput_dml_list_elem() []IOutput_dml_list_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOutput_dml_list_elemContext); ok { + len++ + } + } + + tst := make([]IOutput_dml_list_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOutput_dml_list_elemContext); ok { + tst[i] = t.(IOutput_dml_list_elemContext) + i++ + } + } + + return tst +} + +func (s *Output_clauseContext) Output_dml_list_elem(i int) IOutput_dml_list_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOutput_dml_list_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOutput_dml_list_elemContext) +} + +func (s *Output_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Output_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Output_clauseContext) INTO() antlr.TerminalNode { + return s.GetToken(TSqlParserINTO, 0) +} + +func (s *Output_clauseContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Output_clauseContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Output_clauseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Output_clauseContext) Column_name_list() IColumn_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Output_clauseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Output_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Output_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Output_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOutput_clause(s) + } +} + +func (s *Output_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOutput_clause(s) + } +} + +func (s *Output_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOutput_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Output_clause() (localctx IOutput_clauseContext) { + localctx = NewOutput_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 490, TSqlParserRULE_output_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6708) + p.Match(TSqlParserOUTPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6709) + p.Output_dml_list_elem() + } + p.SetState(6714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(6710) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6711) + p.Output_dml_list_elem() + } + + p.SetState(6716) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserINTO { + { + p.SetState(6717) + p.Match(TSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLOCAL_ID: + { + p.SetState(6718) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(6719) + p.Table_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6726) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 831, p.GetParserRuleContext()) == 1 { + { + p.SetState(6722) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6723) + p.Column_name_list() + } + { + p.SetState(6724) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOutput_dml_list_elemContext is an interface to support dynamic dispatch. +type IOutput_dml_list_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Asterisk() IAsteriskContext + As_column_alias() IAs_column_aliasContext + + // IsOutput_dml_list_elemContext differentiates from other interfaces. + IsOutput_dml_list_elemContext() +} + +type Output_dml_list_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOutput_dml_list_elemContext() *Output_dml_list_elemContext { + var p = new(Output_dml_list_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_output_dml_list_elem + return p +} + +func InitEmptyOutput_dml_list_elemContext(p *Output_dml_list_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_output_dml_list_elem +} + +func (*Output_dml_list_elemContext) IsOutput_dml_list_elemContext() {} + +func NewOutput_dml_list_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Output_dml_list_elemContext { + var p = new(Output_dml_list_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_output_dml_list_elem + + return p +} + +func (s *Output_dml_list_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Output_dml_list_elemContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Output_dml_list_elemContext) Asterisk() IAsteriskContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAsteriskContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAsteriskContext) +} + +func (s *Output_dml_list_elemContext) As_column_alias() IAs_column_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_column_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_column_aliasContext) +} + +func (s *Output_dml_list_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Output_dml_list_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Output_dml_list_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOutput_dml_list_elem(s) + } +} + +func (s *Output_dml_list_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOutput_dml_list_elem(s) + } +} + +func (s *Output_dml_list_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOutput_dml_list_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Output_dml_list_elem() (localctx IOutput_dml_list_elemContext) { + localctx = NewOutput_dml_list_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 492, TSqlParserRULE_output_dml_list_elem) + p.EnterOuterAlt(localctx, 1) + p.SetState(6732) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 833, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6730) + p.expression(0) + } + + case 2: + { + p.SetState(6731) + p.Asterisk() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(6735) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 834, p.GetParserRuleContext()) == 1 { + { + p.SetState(6734) + p.As_column_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_databaseContext is an interface to support dynamic dispatch. +type ICreate_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatabase returns the database rule contexts. + GetDatabase() IId_Context + + // GetCollation_name returns the collation_name rule contexts. + GetCollation_name() IId_Context + + // SetDatabase sets the database rule contexts. + SetDatabase(IId_Context) + + // SetCollation_name sets the collation_name rule contexts. + SetCollation_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + CONTAINMENT() antlr.TerminalNode + EQUAL() antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllDatabase_file_spec() []IDatabase_file_specContext + Database_file_spec(i int) IDatabase_file_specContext + LOG() antlr.TerminalNode + COLLATE() antlr.TerminalNode + WITH() antlr.TerminalNode + AllCreate_database_option() []ICreate_database_optionContext + Create_database_option(i int) ICreate_database_optionContext + NONE() antlr.TerminalNode + PARTIAL() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_databaseContext differentiates from other interfaces. + IsCreate_databaseContext() +} + +type Create_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database IId_Context + collation_name IId_Context +} + +func NewEmptyCreate_databaseContext() *Create_databaseContext { + var p = new(Create_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_database + return p +} + +func InitEmptyCreate_databaseContext(p *Create_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_database +} + +func (*Create_databaseContext) IsCreate_databaseContext() {} + +func NewCreate_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_databaseContext { + var p = new(Create_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_database + + return p +} + +func (s *Create_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_databaseContext) GetDatabase() IId_Context { return s.database } + +func (s *Create_databaseContext) GetCollation_name() IId_Context { return s.collation_name } + +func (s *Create_databaseContext) SetDatabase(v IId_Context) { s.database = v } + +func (s *Create_databaseContext) SetCollation_name(v IId_Context) { s.collation_name = v } + +func (s *Create_databaseContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Create_databaseContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_databaseContext) CONTAINMENT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTAINMENT, 0) +} + +func (s *Create_databaseContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_databaseContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Create_databaseContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Create_databaseContext) AllDatabase_file_spec() []IDatabase_file_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatabase_file_specContext); ok { + len++ + } + } + + tst := make([]IDatabase_file_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatabase_file_specContext); ok { + tst[i] = t.(IDatabase_file_specContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Database_file_spec(i int) IDatabase_file_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_file_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_file_specContext) +} + +func (s *Create_databaseContext) LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserLOG, 0) +} + +func (s *Create_databaseContext) COLLATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLATE, 0) +} + +func (s *Create_databaseContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_databaseContext) AllCreate_database_option() []ICreate_database_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreate_database_optionContext); ok { + len++ + } + } + + tst := make([]ICreate_database_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreate_database_optionContext); ok { + tst[i] = t.(ICreate_database_optionContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Create_database_option(i int) ICreate_database_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_database_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreate_database_optionContext) +} + +func (s *Create_databaseContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Create_databaseContext) PARTIAL() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTIAL, 0) +} + +func (s *Create_databaseContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIMARY, 0) +} + +func (s *Create_databaseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_databaseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_database(s) + } +} + +func (s *Create_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_database(s) + } +} + +func (s *Create_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_database() (localctx ICreate_databaseContext) { + localctx = NewCreate_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 494, TSqlParserRULE_create_database) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6737) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6738) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(6739) + + var _x = p.Id_() + + localctx.(*Create_databaseContext).database = _x + } + + p.SetState(6743) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 835, p.GetParserRuleContext()) == 1 { + { + p.SetState(6740) + p.Match(TSqlParserCONTAINMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6741) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6742) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNONE || _la == TSqlParserPARTIAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(6745) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6747) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPRIMARY { + { + p.SetState(6746) + p.Match(TSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6749) + p.Database_file_spec() + } + p.SetState(6754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(6750) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6751) + p.Database_file_spec() + } + + p.SetState(6756) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(6769) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 840, p.GetParserRuleContext()) == 1 { + { + p.SetState(6759) + p.Match(TSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6760) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6761) + p.Database_file_spec() + } + p.SetState(6766) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(6762) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6763) + p.Database_file_spec() + } + + p.SetState(6768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6773) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOLLATE { + { + p.SetState(6771) + p.Match(TSqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6772) + + var _x = p.Id_() + + localctx.(*Create_databaseContext).collation_name = _x + } + + } + p.SetState(6784) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 843, p.GetParserRuleContext()) == 1 { + { + p.SetState(6775) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6776) + p.Create_database_option() + } + p.SetState(6781) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(6777) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6778) + p.Create_database_option() + } + + p.SetState(6783) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_indexContext is an interface to support dynamic dispatch. +type ICreate_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetWhere returns the where rule contexts. + GetWhere() ISearch_conditionContext + + // SetWhere sets the where rule contexts. + SetWhere(ISearch_conditionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + INDEX() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + Table_name() ITable_nameContext + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + Column_name_list_with_order() IColumn_name_list_with_orderContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + UNIQUE() antlr.TerminalNode + Clustered() IClusteredContext + INCLUDE() antlr.TerminalNode + Column_name_list() IColumn_name_listContext + WHERE() antlr.TerminalNode + Create_index_options() ICreate_index_optionsContext + SEMI() antlr.TerminalNode + Search_condition() ISearch_conditionContext + + // IsCreate_indexContext differentiates from other interfaces. + IsCreate_indexContext() +} + +type Create_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + where ISearch_conditionContext +} + +func NewEmptyCreate_indexContext() *Create_indexContext { + var p = new(Create_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_index + return p +} + +func InitEmptyCreate_indexContext(p *Create_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_index +} + +func (*Create_indexContext) IsCreate_indexContext() {} + +func NewCreate_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_indexContext { + var p = new(Create_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_index + + return p +} + +func (s *Create_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_indexContext) GetWhere() ISearch_conditionContext { return s.where } + +func (s *Create_indexContext) SetWhere(v ISearch_conditionContext) { s.where = v } + +func (s *Create_indexContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Create_indexContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_indexContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_indexContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Create_indexContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Create_indexContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Create_indexContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Create_indexContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Create_indexContext) Column_name_list_with_order() IColumn_name_list_with_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_list_with_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_list_with_orderContext) +} + +func (s *Create_indexContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Create_indexContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Create_indexContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(TSqlParserUNIQUE, 0) +} + +func (s *Create_indexContext) Clustered() IClusteredContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClusteredContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClusteredContext) +} + +func (s *Create_indexContext) INCLUDE() antlr.TerminalNode { + return s.GetToken(TSqlParserINCLUDE, 0) +} + +func (s *Create_indexContext) Column_name_list() IColumn_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Create_indexContext) WHERE() antlr.TerminalNode { + return s.GetToken(TSqlParserWHERE, 0) +} + +func (s *Create_indexContext) Create_index_options() ICreate_index_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_index_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_index_optionsContext) +} + +func (s *Create_indexContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Create_indexContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Create_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_index(s) + } +} + +func (s *Create_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_index(s) + } +} + +func (s *Create_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_index() (localctx ICreate_indexContext) { + localctx = NewCreate_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 496, TSqlParserRULE_create_index) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6786) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserUNIQUE { + { + p.SetState(6787) + p.Match(TSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCLUSTERED || _la == TSqlParserNONCLUSTERED { + { + p.SetState(6790) + p.Clustered() + } + + } + { + p.SetState(6793) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6794) + p.Id_() + } + { + p.SetState(6795) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6796) + p.Table_name() + } + { + p.SetState(6797) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6798) + p.Column_name_list_with_order() + } + { + p.SetState(6799) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6805) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 846, p.GetParserRuleContext()) == 1 { + { + p.SetState(6800) + p.Match(TSqlParserINCLUDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6801) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6802) + p.Column_name_list() + } + { + p.SetState(6803) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWHERE { + { + p.SetState(6807) + p.Match(TSqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6808) + + var _x = p.search_condition(0) + + localctx.(*Create_indexContext).where = _x + } + + } + p.SetState(6812) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 848, p.GetParserRuleContext()) == 1 { + { + p.SetState(6811) + p.Create_index_options() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(6814) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6815) + p.Id_() + } + + } + p.SetState(6819) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 850, p.GetParserRuleContext()) == 1 { + { + p.SetState(6818) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_spatial_indexContext is an interface to support dynamic dispatch. +type ICreate_spatial_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SPATIAL() antlr.TerminalNode + INDEX() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + Table_name() ITable_nameContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Spatial_tessellation_scheme() ISpatial_tessellation_schemeContext + Spatial_index_options() ISpatial_index_optionsContext + SEMI() antlr.TerminalNode + + // IsCreate_spatial_indexContext differentiates from other interfaces. + IsCreate_spatial_indexContext() +} + +type Create_spatial_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_spatial_indexContext() *Create_spatial_indexContext { + var p = new(Create_spatial_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_spatial_index + return p +} + +func InitEmptyCreate_spatial_indexContext(p *Create_spatial_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_spatial_index +} + +func (*Create_spatial_indexContext) IsCreate_spatial_indexContext() {} + +func NewCreate_spatial_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_spatial_indexContext { + var p = new(Create_spatial_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_spatial_index + + return p +} + +func (s *Create_spatial_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_spatial_indexContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_spatial_indexContext) SPATIAL() antlr.TerminalNode { + return s.GetToken(TSqlParserSPATIAL, 0) +} + +func (s *Create_spatial_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Create_spatial_indexContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_spatial_indexContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_spatial_indexContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Create_spatial_indexContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Create_spatial_indexContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Create_spatial_indexContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_spatial_indexContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_spatial_indexContext) Spatial_tessellation_scheme() ISpatial_tessellation_schemeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpatial_tessellation_schemeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpatial_tessellation_schemeContext) +} + +func (s *Create_spatial_indexContext) Spatial_index_options() ISpatial_index_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpatial_index_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpatial_index_optionsContext) +} + +func (s *Create_spatial_indexContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Create_spatial_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_spatial_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_spatial_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_spatial_index(s) + } +} + +func (s *Create_spatial_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_spatial_index(s) + } +} + +func (s *Create_spatial_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_spatial_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_spatial_index() (localctx ICreate_spatial_indexContext) { + localctx = NewCreate_spatial_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 498, TSqlParserRULE_create_spatial_index) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6821) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6822) + p.Match(TSqlParserSPATIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6823) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6824) + p.Id_() + } + { + p.SetState(6825) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6826) + p.Table_name() + } + { + p.SetState(6827) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6828) + p.Id_() + } + { + p.SetState(6829) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6831) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 851, p.GetParserRuleContext()) == 1 { + { + p.SetState(6830) + p.Spatial_tessellation_scheme() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6834) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 852, p.GetParserRuleContext()) == 1 { + { + p.SetState(6833) + p.Spatial_index_options() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(6836) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6837) + p.Id_() + } + + } + p.SetState(6841) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 854, p.GetParserRuleContext()) == 1 { + { + p.SetState(6840) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpatial_tessellation_schemeContext is an interface to support dynamic dispatch. +type ISpatial_tessellation_schemeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + GEOMETRY_AUTO_GRID() antlr.TerminalNode + GEOMETRY_GRID() antlr.TerminalNode + GEOGRAPHY_AUTO_GRID() antlr.TerminalNode + GEOGRAPHY_GRID() antlr.TerminalNode + + // IsSpatial_tessellation_schemeContext differentiates from other interfaces. + IsSpatial_tessellation_schemeContext() +} + +type Spatial_tessellation_schemeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpatial_tessellation_schemeContext() *Spatial_tessellation_schemeContext { + var p = new(Spatial_tessellation_schemeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_spatial_tessellation_scheme + return p +} + +func InitEmptySpatial_tessellation_schemeContext(p *Spatial_tessellation_schemeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_spatial_tessellation_scheme +} + +func (*Spatial_tessellation_schemeContext) IsSpatial_tessellation_schemeContext() {} + +func NewSpatial_tessellation_schemeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spatial_tessellation_schemeContext { + var p = new(Spatial_tessellation_schemeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_spatial_tessellation_scheme + + return p +} + +func (s *Spatial_tessellation_schemeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Spatial_tessellation_schemeContext) USING() antlr.TerminalNode { + return s.GetToken(TSqlParserUSING, 0) +} + +func (s *Spatial_tessellation_schemeContext) GEOMETRY_AUTO_GRID() antlr.TerminalNode { + return s.GetToken(TSqlParserGEOMETRY_AUTO_GRID, 0) +} + +func (s *Spatial_tessellation_schemeContext) GEOMETRY_GRID() antlr.TerminalNode { + return s.GetToken(TSqlParserGEOMETRY_GRID, 0) +} + +func (s *Spatial_tessellation_schemeContext) GEOGRAPHY_AUTO_GRID() antlr.TerminalNode { + return s.GetToken(TSqlParserGEOGRAPHY_AUTO_GRID, 0) +} + +func (s *Spatial_tessellation_schemeContext) GEOGRAPHY_GRID() antlr.TerminalNode { + return s.GetToken(TSqlParserGEOGRAPHY_GRID, 0) +} + +func (s *Spatial_tessellation_schemeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spatial_tessellation_schemeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spatial_tessellation_schemeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSpatial_tessellation_scheme(s) + } +} + +func (s *Spatial_tessellation_schemeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSpatial_tessellation_scheme(s) + } +} + +func (s *Spatial_tessellation_schemeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSpatial_tessellation_scheme(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Spatial_tessellation_scheme() (localctx ISpatial_tessellation_schemeContext) { + localctx = NewSpatial_tessellation_schemeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 500, TSqlParserRULE_spatial_tessellation_scheme) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6843) + p.Match(TSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6844) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-390)) & ^0x3f) == 0 && ((int64(1)<<(_la-390))&27) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpatial_index_optionsContext is an interface to support dynamic dispatch. +type ISpatial_index_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllSpatial_index_option() []ISpatial_index_optionContext + Spatial_index_option(i int) ISpatial_index_optionContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSpatial_index_optionsContext differentiates from other interfaces. + IsSpatial_index_optionsContext() +} + +type Spatial_index_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpatial_index_optionsContext() *Spatial_index_optionsContext { + var p = new(Spatial_index_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_spatial_index_options + return p +} + +func InitEmptySpatial_index_optionsContext(p *Spatial_index_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_spatial_index_options +} + +func (*Spatial_index_optionsContext) IsSpatial_index_optionsContext() {} + +func NewSpatial_index_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spatial_index_optionsContext { + var p = new(Spatial_index_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_spatial_index_options + + return p +} + +func (s *Spatial_index_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Spatial_index_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Spatial_index_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Spatial_index_optionsContext) AllSpatial_index_option() []ISpatial_index_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISpatial_index_optionContext); ok { + len++ + } + } + + tst := make([]ISpatial_index_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISpatial_index_optionContext); ok { + tst[i] = t.(ISpatial_index_optionContext) + i++ + } + } + + return tst +} + +func (s *Spatial_index_optionsContext) Spatial_index_option(i int) ISpatial_index_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpatial_index_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISpatial_index_optionContext) +} + +func (s *Spatial_index_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Spatial_index_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Spatial_index_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Spatial_index_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spatial_index_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spatial_index_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSpatial_index_options(s) + } +} + +func (s *Spatial_index_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSpatial_index_options(s) + } +} + +func (s *Spatial_index_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSpatial_index_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Spatial_index_options() (localctx ISpatial_index_optionsContext) { + localctx = NewSpatial_index_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 502, TSqlParserRULE_spatial_index_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6846) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6847) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6848) + p.Spatial_index_option() + } + p.SetState(6853) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(6849) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6850) + p.Spatial_index_option() + } + + p.SetState(6855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6856) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpatial_index_optionContext is an interface to support dynamic dispatch. +type ISpatial_index_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BOUNDING_BOX() antlr.TerminalNode + EQUAL() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllSigned_decimal() []ISigned_decimalContext + Signed_decimal(i int) ISigned_decimalContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + GRIDS() antlr.TerminalNode + AllSpatial_grid_level() []ISpatial_grid_levelContext + Spatial_grid_level(i int) ISpatial_grid_levelContext + CELLS_PER_OBJECT() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + Rebuild_index_option() IRebuild_index_optionContext + + // IsSpatial_index_optionContext differentiates from other interfaces. + IsSpatial_index_optionContext() +} + +type Spatial_index_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpatial_index_optionContext() *Spatial_index_optionContext { + var p = new(Spatial_index_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_spatial_index_option + return p +} + +func InitEmptySpatial_index_optionContext(p *Spatial_index_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_spatial_index_option +} + +func (*Spatial_index_optionContext) IsSpatial_index_optionContext() {} + +func NewSpatial_index_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spatial_index_optionContext { + var p = new(Spatial_index_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_spatial_index_option + + return p +} + +func (s *Spatial_index_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Spatial_index_optionContext) BOUNDING_BOX() antlr.TerminalNode { + return s.GetToken(TSqlParserBOUNDING_BOX, 0) +} + +func (s *Spatial_index_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Spatial_index_optionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Spatial_index_optionContext) AllSigned_decimal() []ISigned_decimalContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISigned_decimalContext); ok { + len++ + } + } + + tst := make([]ISigned_decimalContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISigned_decimalContext); ok { + tst[i] = t.(ISigned_decimalContext) + i++ + } + } + + return tst +} + +func (s *Spatial_index_optionContext) Signed_decimal(i int) ISigned_decimalContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISigned_decimalContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISigned_decimalContext) +} + +func (s *Spatial_index_optionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Spatial_index_optionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Spatial_index_optionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Spatial_index_optionContext) GRIDS() antlr.TerminalNode { + return s.GetToken(TSqlParserGRIDS, 0) +} + +func (s *Spatial_index_optionContext) AllSpatial_grid_level() []ISpatial_grid_levelContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISpatial_grid_levelContext); ok { + len++ + } + } + + tst := make([]ISpatial_grid_levelContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISpatial_grid_levelContext); ok { + tst[i] = t.(ISpatial_grid_levelContext) + i++ + } + } + + return tst +} + +func (s *Spatial_index_optionContext) Spatial_grid_level(i int) ISpatial_grid_levelContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpatial_grid_levelContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISpatial_grid_levelContext) +} + +func (s *Spatial_index_optionContext) CELLS_PER_OBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserCELLS_PER_OBJECT, 0) +} + +func (s *Spatial_index_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Spatial_index_optionContext) Rebuild_index_option() IRebuild_index_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRebuild_index_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRebuild_index_optionContext) +} + +func (s *Spatial_index_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spatial_index_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spatial_index_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSpatial_index_option(s) + } +} + +func (s *Spatial_index_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSpatial_index_option(s) + } +} + +func (s *Spatial_index_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSpatial_index_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Spatial_index_option() (localctx ISpatial_index_optionContext) { + localctx = NewSpatial_index_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 504, TSqlParserRULE_spatial_index_option) + var _la int + + p.SetState(6887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserBOUNDING_BOX: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6858) + p.Match(TSqlParserBOUNDING_BOX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6859) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6860) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6861) + p.Signed_decimal() + } + { + p.SetState(6862) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6863) + p.Signed_decimal() + } + { + p.SetState(6864) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6865) + p.Signed_decimal() + } + { + p.SetState(6866) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6867) + p.Signed_decimal() + } + { + p.SetState(6868) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserGRIDS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6870) + p.Match(TSqlParserGRIDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6871) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6872) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6873) + p.Spatial_grid_level() + } + p.SetState(6878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(6874) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6875) + p.Spatial_grid_level() + } + + p.SetState(6880) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6881) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCELLS_PER_OBJECT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6883) + p.Match(TSqlParserCELLS_PER_OBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6884) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6885) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserDATA_COMPRESSION, TSqlParserFILLFACTOR, TSqlParserIGNORE_DUP_KEY, TSqlParserMAXDOP, TSqlParserMAX_DURATION, TSqlParserONLINE, TSqlParserPAD_INDEX, TSqlParserRESUMABLE, TSqlParserSORT_IN_TEMPDB, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserXML_COMPRESSION: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6886) + p.Rebuild_index_option() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISigned_decimalContext is an interface to support dynamic dispatch. +type ISigned_decimalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECIMAL() antlr.TerminalNode + REAL() antlr.TerminalNode + FLOAT() antlr.TerminalNode + MINUS() antlr.TerminalNode + + // IsSigned_decimalContext differentiates from other interfaces. + IsSigned_decimalContext() +} + +type Signed_decimalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySigned_decimalContext() *Signed_decimalContext { + var p = new(Signed_decimalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_signed_decimal + return p +} + +func InitEmptySigned_decimalContext(p *Signed_decimalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_signed_decimal +} + +func (*Signed_decimalContext) IsSigned_decimalContext() {} + +func NewSigned_decimalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Signed_decimalContext { + var p = new(Signed_decimalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_signed_decimal + + return p +} + +func (s *Signed_decimalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Signed_decimalContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Signed_decimalContext) REAL() antlr.TerminalNode { + return s.GetToken(TSqlParserREAL, 0) +} + +func (s *Signed_decimalContext) FLOAT() antlr.TerminalNode { + return s.GetToken(TSqlParserFLOAT, 0) +} + +func (s *Signed_decimalContext) MINUS() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUS, 0) +} + +func (s *Signed_decimalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Signed_decimalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Signed_decimalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSigned_decimal(s) + } +} + +func (s *Signed_decimalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSigned_decimal(s) + } +} + +func (s *Signed_decimalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSigned_decimal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Signed_decimal() (localctx ISigned_decimalContext) { + localctx = NewSigned_decimalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 506, TSqlParserRULE_signed_decimal) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMINUS { + { + p.SetState(6889) + p.Match(TSqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6892) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1182)) & ^0x3f) == 0 && ((int64(1)<<(_la-1182))&49) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpatial_grid_levelContext is an interface to support dynamic dispatch. +type ISpatial_grid_levelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEVEL_1() antlr.TerminalNode + EQUAL() antlr.TerminalNode + Spatial_grid_density() ISpatial_grid_densityContext + LEVEL_2() antlr.TerminalNode + LEVEL_3() antlr.TerminalNode + LEVEL_4() antlr.TerminalNode + + // IsSpatial_grid_levelContext differentiates from other interfaces. + IsSpatial_grid_levelContext() +} + +type Spatial_grid_levelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpatial_grid_levelContext() *Spatial_grid_levelContext { + var p = new(Spatial_grid_levelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_spatial_grid_level + return p +} + +func InitEmptySpatial_grid_levelContext(p *Spatial_grid_levelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_spatial_grid_level +} + +func (*Spatial_grid_levelContext) IsSpatial_grid_levelContext() {} + +func NewSpatial_grid_levelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spatial_grid_levelContext { + var p = new(Spatial_grid_levelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_spatial_grid_level + + return p +} + +func (s *Spatial_grid_levelContext) GetParser() antlr.Parser { return s.parser } + +func (s *Spatial_grid_levelContext) LEVEL_1() antlr.TerminalNode { + return s.GetToken(TSqlParserLEVEL_1, 0) +} + +func (s *Spatial_grid_levelContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Spatial_grid_levelContext) Spatial_grid_density() ISpatial_grid_densityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpatial_grid_densityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpatial_grid_densityContext) +} + +func (s *Spatial_grid_levelContext) LEVEL_2() antlr.TerminalNode { + return s.GetToken(TSqlParserLEVEL_2, 0) +} + +func (s *Spatial_grid_levelContext) LEVEL_3() antlr.TerminalNode { + return s.GetToken(TSqlParserLEVEL_3, 0) +} + +func (s *Spatial_grid_levelContext) LEVEL_4() antlr.TerminalNode { + return s.GetToken(TSqlParserLEVEL_4, 0) +} + +func (s *Spatial_grid_levelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spatial_grid_levelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spatial_grid_levelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSpatial_grid_level(s) + } +} + +func (s *Spatial_grid_levelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSpatial_grid_level(s) + } +} + +func (s *Spatial_grid_levelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSpatial_grid_level(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Spatial_grid_level() (localctx ISpatial_grid_levelContext) { + localctx = NewSpatial_grid_levelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 508, TSqlParserRULE_spatial_grid_level) + p.SetState(6906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLEVEL_1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6894) + p.Match(TSqlParserLEVEL_1) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6895) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6896) + p.Spatial_grid_density() + } + + case TSqlParserLEVEL_2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6897) + p.Match(TSqlParserLEVEL_2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6898) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6899) + p.Spatial_grid_density() + } + + case TSqlParserLEVEL_3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6900) + p.Match(TSqlParserLEVEL_3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6901) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6902) + p.Spatial_grid_density() + } + + case TSqlParserLEVEL_4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6903) + p.Match(TSqlParserLEVEL_4) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6904) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6905) + p.Spatial_grid_density() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpatial_grid_densityContext is an interface to support dynamic dispatch. +type ISpatial_grid_densityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOW() antlr.TerminalNode + MEDIUM() antlr.TerminalNode + HIGH() antlr.TerminalNode + + // IsSpatial_grid_densityContext differentiates from other interfaces. + IsSpatial_grid_densityContext() +} + +type Spatial_grid_densityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpatial_grid_densityContext() *Spatial_grid_densityContext { + var p = new(Spatial_grid_densityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_spatial_grid_density + return p +} + +func InitEmptySpatial_grid_densityContext(p *Spatial_grid_densityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_spatial_grid_density +} + +func (*Spatial_grid_densityContext) IsSpatial_grid_densityContext() {} + +func NewSpatial_grid_densityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spatial_grid_densityContext { + var p = new(Spatial_grid_densityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_spatial_grid_density + + return p +} + +func (s *Spatial_grid_densityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Spatial_grid_densityContext) LOW() antlr.TerminalNode { + return s.GetToken(TSqlParserLOW, 0) +} + +func (s *Spatial_grid_densityContext) MEDIUM() antlr.TerminalNode { + return s.GetToken(TSqlParserMEDIUM, 0) +} + +func (s *Spatial_grid_densityContext) HIGH() antlr.TerminalNode { + return s.GetToken(TSqlParserHIGH, 0) +} + +func (s *Spatial_grid_densityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spatial_grid_densityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spatial_grid_densityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSpatial_grid_density(s) + } +} + +func (s *Spatial_grid_densityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSpatial_grid_density(s) + } +} + +func (s *Spatial_grid_densityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSpatial_grid_density(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Spatial_grid_density() (localctx ISpatial_grid_densityContext) { + localctx = NewSpatial_grid_densityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 510, TSqlParserRULE_spatial_grid_density) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6908) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserHIGH || _la == TSqlParserLOW || _la == TSqlParserMEDIUM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_index_optionsContext is an interface to support dynamic dispatch. +type ICreate_index_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllRelational_index_option() []IRelational_index_optionContext + Relational_index_option(i int) IRelational_index_optionContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_index_optionsContext differentiates from other interfaces. + IsCreate_index_optionsContext() +} + +type Create_index_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_index_optionsContext() *Create_index_optionsContext { + var p = new(Create_index_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_index_options + return p +} + +func InitEmptyCreate_index_optionsContext(p *Create_index_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_index_options +} + +func (*Create_index_optionsContext) IsCreate_index_optionsContext() {} + +func NewCreate_index_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_index_optionsContext { + var p = new(Create_index_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_index_options + + return p +} + +func (s *Create_index_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_index_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_index_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_index_optionsContext) AllRelational_index_option() []IRelational_index_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRelational_index_optionContext); ok { + len++ + } + } + + tst := make([]IRelational_index_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRelational_index_optionContext); ok { + tst[i] = t.(IRelational_index_optionContext) + i++ + } + } + + return tst +} + +func (s *Create_index_optionsContext) Relational_index_option(i int) IRelational_index_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_index_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRelational_index_optionContext) +} + +func (s *Create_index_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_index_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_index_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_index_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_index_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_index_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_index_options(s) + } +} + +func (s *Create_index_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_index_options(s) + } +} + +func (s *Create_index_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_index_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_index_options() (localctx ICreate_index_optionsContext) { + localctx = NewCreate_index_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 512, TSqlParserRULE_create_index_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6910) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6911) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6912) + p.Relational_index_option() + } + p.SetState(6917) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(6913) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6914) + p.Relational_index_option() + } + + p.SetState(6919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6920) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelational_index_optionContext is an interface to support dynamic dispatch. +type IRelational_index_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Rebuild_index_option() IRebuild_index_optionContext + DROP_EXISTING() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + OPTIMIZE_FOR_SEQUENTIAL_KEY() antlr.TerminalNode + + // IsRelational_index_optionContext differentiates from other interfaces. + IsRelational_index_optionContext() +} + +type Relational_index_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelational_index_optionContext() *Relational_index_optionContext { + var p = new(Relational_index_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_relational_index_option + return p +} + +func InitEmptyRelational_index_optionContext(p *Relational_index_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_relational_index_option +} + +func (*Relational_index_optionContext) IsRelational_index_optionContext() {} + +func NewRelational_index_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relational_index_optionContext { + var p = new(Relational_index_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_relational_index_option + + return p +} + +func (s *Relational_index_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relational_index_optionContext) Rebuild_index_option() IRebuild_index_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRebuild_index_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRebuild_index_optionContext) +} + +func (s *Relational_index_optionContext) DROP_EXISTING() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP_EXISTING, 0) +} + +func (s *Relational_index_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Relational_index_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Relational_index_optionContext) OPTIMIZE_FOR_SEQUENTIAL_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, 0) +} + +func (s *Relational_index_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relational_index_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relational_index_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRelational_index_option(s) + } +} + +func (s *Relational_index_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRelational_index_option(s) + } +} + +func (s *Relational_index_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRelational_index_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Relational_index_option() (localctx IRelational_index_optionContext) { + localctx = NewRelational_index_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 514, TSqlParserRULE_relational_index_option) + p.SetState(6929) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserDATA_COMPRESSION, TSqlParserFILLFACTOR, TSqlParserIGNORE_DUP_KEY, TSqlParserMAXDOP, TSqlParserMAX_DURATION, TSqlParserONLINE, TSqlParserPAD_INDEX, TSqlParserRESUMABLE, TSqlParserSORT_IN_TEMPDB, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserXML_COMPRESSION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6922) + p.Rebuild_index_option() + } + + case TSqlParserDROP_EXISTING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6923) + p.Match(TSqlParserDROP_EXISTING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6924) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6925) + p.On_off() + } + + case TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6926) + p.Match(TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6927) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6928) + p.On_off() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_indexContext is an interface to support dynamic dispatch. +type IAlter_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + INDEX() antlr.TerminalNode + ON() antlr.TerminalNode + Table_name() ITable_nameContext + Id_() IId_Context + ALL() antlr.TerminalNode + DISABLE() antlr.TerminalNode + PAUSE() antlr.TerminalNode + ABORT() antlr.TerminalNode + RESUME() antlr.TerminalNode + Reorganize_partition() IReorganize_partitionContext + Set_index_options() ISet_index_optionsContext + Rebuild_partition() IRebuild_partitionContext + Resumable_index_options() IResumable_index_optionsContext + + // IsAlter_indexContext differentiates from other interfaces. + IsAlter_indexContext() +} + +type Alter_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_indexContext() *Alter_indexContext { + var p = new(Alter_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_index + return p +} + +func InitEmptyAlter_indexContext(p *Alter_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_index +} + +func (*Alter_indexContext) IsAlter_indexContext() {} + +func NewAlter_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_indexContext { + var p = new(Alter_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_index + + return p +} + +func (s *Alter_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_indexContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Alter_indexContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Alter_indexContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Alter_indexContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_indexContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Alter_indexContext) DISABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLE, 0) +} + +func (s *Alter_indexContext) PAUSE() antlr.TerminalNode { + return s.GetToken(TSqlParserPAUSE, 0) +} + +func (s *Alter_indexContext) ABORT() antlr.TerminalNode { + return s.GetToken(TSqlParserABORT, 0) +} + +func (s *Alter_indexContext) RESUME() antlr.TerminalNode { + return s.GetToken(TSqlParserRESUME, 0) +} + +func (s *Alter_indexContext) Reorganize_partition() IReorganize_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReorganize_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReorganize_partitionContext) +} + +func (s *Alter_indexContext) Set_index_options() ISet_index_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_index_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_index_optionsContext) +} + +func (s *Alter_indexContext) Rebuild_partition() IRebuild_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRebuild_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRebuild_partitionContext) +} + +func (s *Alter_indexContext) Resumable_index_options() IResumable_index_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResumable_index_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResumable_index_optionsContext) +} + +func (s *Alter_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_index(s) + } +} + +func (s *Alter_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_index(s) + } +} + +func (s *Alter_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_index() (localctx IAlter_indexContext) { + localctx = NewAlter_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 516, TSqlParserRULE_alter_index) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6931) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6932) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6935) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(6933) + p.Id_() + } + + case TSqlParserALL: + { + p.SetState(6934) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6937) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6938) + p.Table_name() + } + p.SetState(6949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDISABLE: + { + p.SetState(6939) + p.Match(TSqlParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPAUSE: + { + p.SetState(6940) + p.Match(TSqlParserPAUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT: + { + p.SetState(6941) + p.Match(TSqlParserABORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserRESUME: + { + p.SetState(6942) + p.Match(TSqlParserRESUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6944) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 863, p.GetParserRuleContext()) == 1 { + { + p.SetState(6943) + p.Resumable_index_options() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserREORGANIZE: + { + p.SetState(6946) + p.Reorganize_partition() + } + + case TSqlParserSET: + { + p.SetState(6947) + p.Set_index_options() + } + + case TSqlParserREBUILD: + { + p.SetState(6948) + p.Rebuild_partition() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IResumable_index_optionsContext is an interface to support dynamic dispatch. +type IResumable_index_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllResumable_index_option() []IResumable_index_optionContext + Resumable_index_option(i int) IResumable_index_optionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsResumable_index_optionsContext differentiates from other interfaces. + IsResumable_index_optionsContext() +} + +type Resumable_index_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResumable_index_optionsContext() *Resumable_index_optionsContext { + var p = new(Resumable_index_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_resumable_index_options + return p +} + +func InitEmptyResumable_index_optionsContext(p *Resumable_index_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_resumable_index_options +} + +func (*Resumable_index_optionsContext) IsResumable_index_optionsContext() {} + +func NewResumable_index_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Resumable_index_optionsContext { + var p = new(Resumable_index_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_resumable_index_options + + return p +} + +func (s *Resumable_index_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Resumable_index_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Resumable_index_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Resumable_index_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Resumable_index_optionsContext) AllResumable_index_option() []IResumable_index_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IResumable_index_optionContext); ok { + len++ + } + } + + tst := make([]IResumable_index_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IResumable_index_optionContext); ok { + tst[i] = t.(IResumable_index_optionContext) + i++ + } + } + + return tst +} + +func (s *Resumable_index_optionsContext) Resumable_index_option(i int) IResumable_index_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResumable_index_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IResumable_index_optionContext) +} + +func (s *Resumable_index_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Resumable_index_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Resumable_index_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Resumable_index_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Resumable_index_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterResumable_index_options(s) + } +} + +func (s *Resumable_index_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitResumable_index_options(s) + } +} + +func (s *Resumable_index_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitResumable_index_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Resumable_index_options() (localctx IResumable_index_optionsContext) { + localctx = NewResumable_index_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 518, TSqlParserRULE_resumable_index_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6951) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6952) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(6953) + p.Resumable_index_option() + } + p.SetState(6958) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(6954) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6955) + p.Resumable_index_option() + } + + p.SetState(6960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + { + p.SetState(6961) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IResumable_index_optionContext is an interface to support dynamic dispatch. +type IResumable_index_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMax_degree_of_parallelism returns the max_degree_of_parallelism token. + GetMax_degree_of_parallelism() antlr.Token + + // GetMax_duration returns the max_duration token. + GetMax_duration() antlr.Token + + // SetMax_degree_of_parallelism sets the max_degree_of_parallelism token. + SetMax_degree_of_parallelism(antlr.Token) + + // SetMax_duration sets the max_duration token. + SetMax_duration(antlr.Token) + + // Getter signatures + MAXDOP() antlr.TerminalNode + EQUAL() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + MAX_DURATION() antlr.TerminalNode + MINUTES() antlr.TerminalNode + Low_priority_lock_wait() ILow_priority_lock_waitContext + + // IsResumable_index_optionContext differentiates from other interfaces. + IsResumable_index_optionContext() +} + +type Resumable_index_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + max_degree_of_parallelism antlr.Token + max_duration antlr.Token +} + +func NewEmptyResumable_index_optionContext() *Resumable_index_optionContext { + var p = new(Resumable_index_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_resumable_index_option + return p +} + +func InitEmptyResumable_index_optionContext(p *Resumable_index_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_resumable_index_option +} + +func (*Resumable_index_optionContext) IsResumable_index_optionContext() {} + +func NewResumable_index_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Resumable_index_optionContext { + var p = new(Resumable_index_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_resumable_index_option + + return p +} + +func (s *Resumable_index_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Resumable_index_optionContext) GetMax_degree_of_parallelism() antlr.Token { + return s.max_degree_of_parallelism +} + +func (s *Resumable_index_optionContext) GetMax_duration() antlr.Token { return s.max_duration } + +func (s *Resumable_index_optionContext) SetMax_degree_of_parallelism(v antlr.Token) { + s.max_degree_of_parallelism = v +} + +func (s *Resumable_index_optionContext) SetMax_duration(v antlr.Token) { s.max_duration = v } + +func (s *Resumable_index_optionContext) MAXDOP() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXDOP, 0) +} + +func (s *Resumable_index_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Resumable_index_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Resumable_index_optionContext) MAX_DURATION() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_DURATION, 0) +} + +func (s *Resumable_index_optionContext) MINUTES() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUTES, 0) +} + +func (s *Resumable_index_optionContext) Low_priority_lock_wait() ILow_priority_lock_waitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILow_priority_lock_waitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILow_priority_lock_waitContext) +} + +func (s *Resumable_index_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Resumable_index_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Resumable_index_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterResumable_index_option(s) + } +} + +func (s *Resumable_index_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitResumable_index_option(s) + } +} + +func (s *Resumable_index_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitResumable_index_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Resumable_index_option() (localctx IResumable_index_optionContext) { + localctx = NewResumable_index_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 520, TSqlParserRULE_resumable_index_option) + var _la int + + p.SetState(6973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserMAXDOP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6963) + p.Match(TSqlParserMAXDOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6964) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6965) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Resumable_index_optionContext).max_degree_of_parallelism = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMAX_DURATION: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6966) + p.Match(TSqlParserMAX_DURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6967) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6968) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Resumable_index_optionContext).max_duration = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6970) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMINUTES { + { + p.SetState(6969) + p.Match(TSqlParserMINUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserWAIT_AT_LOW_PRIORITY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6972) + p.Low_priority_lock_wait() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReorganize_partitionContext is an interface to support dynamic dispatch. +type IReorganize_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REORGANIZE() antlr.TerminalNode + PARTITION() antlr.TerminalNode + EQUAL() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + Reorganize_options() IReorganize_optionsContext + + // IsReorganize_partitionContext differentiates from other interfaces. + IsReorganize_partitionContext() +} + +type Reorganize_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReorganize_partitionContext() *Reorganize_partitionContext { + var p = new(Reorganize_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_reorganize_partition + return p +} + +func InitEmptyReorganize_partitionContext(p *Reorganize_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_reorganize_partition +} + +func (*Reorganize_partitionContext) IsReorganize_partitionContext() {} + +func NewReorganize_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reorganize_partitionContext { + var p = new(Reorganize_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_reorganize_partition + + return p +} + +func (s *Reorganize_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reorganize_partitionContext) REORGANIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserREORGANIZE, 0) +} + +func (s *Reorganize_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITION, 0) +} + +func (s *Reorganize_partitionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Reorganize_partitionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Reorganize_partitionContext) Reorganize_options() IReorganize_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReorganize_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReorganize_optionsContext) +} + +func (s *Reorganize_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reorganize_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reorganize_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterReorganize_partition(s) + } +} + +func (s *Reorganize_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitReorganize_partition(s) + } +} + +func (s *Reorganize_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitReorganize_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Reorganize_partition() (localctx IReorganize_partitionContext) { + localctx = NewReorganize_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 522, TSqlParserRULE_reorganize_partition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6975) + p.Match(TSqlParserREORGANIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6979) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 868, p.GetParserRuleContext()) == 1 { + { + p.SetState(6976) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6977) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6978) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6982) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 869, p.GetParserRuleContext()) == 1 { + { + p.SetState(6981) + p.Reorganize_options() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReorganize_optionsContext is an interface to support dynamic dispatch. +type IReorganize_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllReorganize_option() []IReorganize_optionContext + Reorganize_option(i int) IReorganize_optionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsReorganize_optionsContext differentiates from other interfaces. + IsReorganize_optionsContext() +} + +type Reorganize_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReorganize_optionsContext() *Reorganize_optionsContext { + var p = new(Reorganize_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_reorganize_options + return p +} + +func InitEmptyReorganize_optionsContext(p *Reorganize_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_reorganize_options +} + +func (*Reorganize_optionsContext) IsReorganize_optionsContext() {} + +func NewReorganize_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reorganize_optionsContext { + var p = new(Reorganize_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_reorganize_options + + return p +} + +func (s *Reorganize_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reorganize_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Reorganize_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Reorganize_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Reorganize_optionsContext) AllReorganize_option() []IReorganize_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReorganize_optionContext); ok { + len++ + } + } + + tst := make([]IReorganize_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReorganize_optionContext); ok { + tst[i] = t.(IReorganize_optionContext) + i++ + } + } + + return tst +} + +func (s *Reorganize_optionsContext) Reorganize_option(i int) IReorganize_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReorganize_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReorganize_optionContext) +} + +func (s *Reorganize_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Reorganize_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Reorganize_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reorganize_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reorganize_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterReorganize_options(s) + } +} + +func (s *Reorganize_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitReorganize_options(s) + } +} + +func (s *Reorganize_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitReorganize_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Reorganize_options() (localctx IReorganize_optionsContext) { + localctx = NewReorganize_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 524, TSqlParserRULE_reorganize_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6984) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6985) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(6986) + p.Reorganize_option() + } + p.SetState(6991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(6987) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6988) + p.Reorganize_option() + } + + p.SetState(6993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + { + p.SetState(6994) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReorganize_optionContext is an interface to support dynamic dispatch. +type IReorganize_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOB_COMPACTION() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + COMPRESS_ALL_ROW_GROUPS() antlr.TerminalNode + + // IsReorganize_optionContext differentiates from other interfaces. + IsReorganize_optionContext() +} + +type Reorganize_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReorganize_optionContext() *Reorganize_optionContext { + var p = new(Reorganize_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_reorganize_option + return p +} + +func InitEmptyReorganize_optionContext(p *Reorganize_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_reorganize_option +} + +func (*Reorganize_optionContext) IsReorganize_optionContext() {} + +func NewReorganize_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reorganize_optionContext { + var p = new(Reorganize_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_reorganize_option + + return p +} + +func (s *Reorganize_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reorganize_optionContext) LOB_COMPACTION() antlr.TerminalNode { + return s.GetToken(TSqlParserLOB_COMPACTION, 0) +} + +func (s *Reorganize_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Reorganize_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Reorganize_optionContext) COMPRESS_ALL_ROW_GROUPS() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPRESS_ALL_ROW_GROUPS, 0) +} + +func (s *Reorganize_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reorganize_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reorganize_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterReorganize_option(s) + } +} + +func (s *Reorganize_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitReorganize_option(s) + } +} + +func (s *Reorganize_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitReorganize_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Reorganize_option() (localctx IReorganize_optionContext) { + localctx = NewReorganize_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 526, TSqlParserRULE_reorganize_option) + p.SetState(7002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLOB_COMPACTION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6996) + p.Match(TSqlParserLOB_COMPACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6997) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6998) + p.On_off() + } + + case TSqlParserCOMPRESS_ALL_ROW_GROUPS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6999) + p.Match(TSqlParserCOMPRESS_ALL_ROW_GROUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7000) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7001) + p.On_off() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_index_optionsContext is an interface to support dynamic dispatch. +type ISet_index_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllSet_index_option() []ISet_index_optionContext + Set_index_option(i int) ISet_index_optionContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSet_index_optionsContext differentiates from other interfaces. + IsSet_index_optionsContext() +} + +type Set_index_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_index_optionsContext() *Set_index_optionsContext { + var p = new(Set_index_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_set_index_options + return p +} + +func InitEmptySet_index_optionsContext(p *Set_index_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_set_index_options +} + +func (*Set_index_optionsContext) IsSet_index_optionsContext() {} + +func NewSet_index_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_index_optionsContext { + var p = new(Set_index_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_set_index_options + + return p +} + +func (s *Set_index_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_index_optionsContext) SET() antlr.TerminalNode { + return s.GetToken(TSqlParserSET, 0) +} + +func (s *Set_index_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Set_index_optionsContext) AllSet_index_option() []ISet_index_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISet_index_optionContext); ok { + len++ + } + } + + tst := make([]ISet_index_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISet_index_optionContext); ok { + tst[i] = t.(ISet_index_optionContext) + i++ + } + } + + return tst +} + +func (s *Set_index_optionsContext) Set_index_option(i int) ISet_index_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_index_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISet_index_optionContext) +} + +func (s *Set_index_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Set_index_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Set_index_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Set_index_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_index_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_index_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSet_index_options(s) + } +} + +func (s *Set_index_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSet_index_options(s) + } +} + +func (s *Set_index_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSet_index_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Set_index_options() (localctx ISet_index_optionsContext) { + localctx = NewSet_index_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 528, TSqlParserRULE_set_index_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7004) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7005) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7006) + p.Set_index_option() + } + p.SetState(7011) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7007) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7008) + p.Set_index_option() + } + + p.SetState(7013) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7014) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_index_optionContext is an interface to support dynamic dispatch. +type ISet_index_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDelay returns the delay token. + GetDelay() antlr.Token + + // SetDelay sets the delay token. + SetDelay(antlr.Token) + + // Getter signatures + ALLOW_ROW_LOCKS() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + ALLOW_PAGE_LOCKS() antlr.TerminalNode + OPTIMIZE_FOR_SEQUENTIAL_KEY() antlr.TerminalNode + IGNORE_DUP_KEY() antlr.TerminalNode + STATISTICS_NORECOMPUTE() antlr.TerminalNode + COMPRESSION_DELAY() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + MINUTES() antlr.TerminalNode + + // IsSet_index_optionContext differentiates from other interfaces. + IsSet_index_optionContext() +} + +type Set_index_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + delay antlr.Token +} + +func NewEmptySet_index_optionContext() *Set_index_optionContext { + var p = new(Set_index_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_set_index_option + return p +} + +func InitEmptySet_index_optionContext(p *Set_index_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_set_index_option +} + +func (*Set_index_optionContext) IsSet_index_optionContext() {} + +func NewSet_index_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_index_optionContext { + var p = new(Set_index_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_set_index_option + + return p +} + +func (s *Set_index_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_index_optionContext) GetDelay() antlr.Token { return s.delay } + +func (s *Set_index_optionContext) SetDelay(v antlr.Token) { s.delay = v } + +func (s *Set_index_optionContext) ALLOW_ROW_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_ROW_LOCKS, 0) +} + +func (s *Set_index_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Set_index_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Set_index_optionContext) ALLOW_PAGE_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_PAGE_LOCKS, 0) +} + +func (s *Set_index_optionContext) OPTIMIZE_FOR_SEQUENTIAL_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, 0) +} + +func (s *Set_index_optionContext) IGNORE_DUP_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_DUP_KEY, 0) +} + +func (s *Set_index_optionContext) STATISTICS_NORECOMPUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS_NORECOMPUTE, 0) +} + +func (s *Set_index_optionContext) COMPRESSION_DELAY() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPRESSION_DELAY, 0) +} + +func (s *Set_index_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Set_index_optionContext) MINUTES() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUTES, 0) +} + +func (s *Set_index_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_index_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_index_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSet_index_option(s) + } +} + +func (s *Set_index_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSet_index_option(s) + } +} + +func (s *Set_index_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSet_index_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Set_index_option() (localctx ISet_index_optionContext) { + localctx = NewSet_index_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 530, TSqlParserRULE_set_index_option) + var _la int + + p.SetState(7037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALLOW_ROW_LOCKS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7016) + p.Match(TSqlParserALLOW_ROW_LOCKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7017) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7018) + p.On_off() + } + + case TSqlParserALLOW_PAGE_LOCKS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7019) + p.Match(TSqlParserALLOW_PAGE_LOCKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7020) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7021) + p.On_off() + } + + case TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7022) + p.Match(TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7023) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7024) + p.On_off() + } + + case TSqlParserIGNORE_DUP_KEY: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7025) + p.Match(TSqlParserIGNORE_DUP_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7026) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7027) + p.On_off() + } + + case TSqlParserSTATISTICS_NORECOMPUTE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7028) + p.Match(TSqlParserSTATISTICS_NORECOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7029) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7030) + p.On_off() + } + + case TSqlParserCOMPRESSION_DELAY: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7031) + p.Match(TSqlParserCOMPRESSION_DELAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7032) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7033) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Set_index_optionContext).delay = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7035) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMINUTES { + { + p.SetState(7034) + p.Match(TSqlParserMINUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRebuild_partitionContext is an interface to support dynamic dispatch. +type IRebuild_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REBUILD() antlr.TerminalNode + PARTITION() antlr.TerminalNode + EQUAL() antlr.TerminalNode + ALL() antlr.TerminalNode + Rebuild_index_options() IRebuild_index_optionsContext + DECIMAL() antlr.TerminalNode + Single_partition_rebuild_index_options() ISingle_partition_rebuild_index_optionsContext + + // IsRebuild_partitionContext differentiates from other interfaces. + IsRebuild_partitionContext() +} + +type Rebuild_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRebuild_partitionContext() *Rebuild_partitionContext { + var p = new(Rebuild_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_rebuild_partition + return p +} + +func InitEmptyRebuild_partitionContext(p *Rebuild_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_rebuild_partition +} + +func (*Rebuild_partitionContext) IsRebuild_partitionContext() {} + +func NewRebuild_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rebuild_partitionContext { + var p = new(Rebuild_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_rebuild_partition + + return p +} + +func (s *Rebuild_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rebuild_partitionContext) REBUILD() antlr.TerminalNode { + return s.GetToken(TSqlParserREBUILD, 0) +} + +func (s *Rebuild_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITION, 0) +} + +func (s *Rebuild_partitionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Rebuild_partitionContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Rebuild_partitionContext) Rebuild_index_options() IRebuild_index_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRebuild_index_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRebuild_index_optionsContext) +} + +func (s *Rebuild_partitionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Rebuild_partitionContext) Single_partition_rebuild_index_options() ISingle_partition_rebuild_index_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISingle_partition_rebuild_index_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISingle_partition_rebuild_index_optionsContext) +} + +func (s *Rebuild_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rebuild_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rebuild_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRebuild_partition(s) + } +} + +func (s *Rebuild_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRebuild_partition(s) + } +} + +func (s *Rebuild_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRebuild_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Rebuild_partition() (localctx IRebuild_partitionContext) { + localctx = NewRebuild_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 532, TSqlParserRULE_rebuild_partition) + p.SetState(7055) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 878, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7039) + p.Match(TSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7043) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 875, p.GetParserRuleContext()) == 1 { + { + p.SetState(7040) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7041) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7042) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7046) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 876, p.GetParserRuleContext()) == 1 { + { + p.SetState(7045) + p.Rebuild_index_options() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7048) + p.Match(TSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7049) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7050) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7051) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7053) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 877, p.GetParserRuleContext()) == 1 { + { + p.SetState(7052) + p.Single_partition_rebuild_index_options() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRebuild_index_optionsContext is an interface to support dynamic dispatch. +type IRebuild_index_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllRebuild_index_option() []IRebuild_index_optionContext + Rebuild_index_option(i int) IRebuild_index_optionContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRebuild_index_optionsContext differentiates from other interfaces. + IsRebuild_index_optionsContext() +} + +type Rebuild_index_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRebuild_index_optionsContext() *Rebuild_index_optionsContext { + var p = new(Rebuild_index_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_rebuild_index_options + return p +} + +func InitEmptyRebuild_index_optionsContext(p *Rebuild_index_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_rebuild_index_options +} + +func (*Rebuild_index_optionsContext) IsRebuild_index_optionsContext() {} + +func NewRebuild_index_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rebuild_index_optionsContext { + var p = new(Rebuild_index_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_rebuild_index_options + + return p +} + +func (s *Rebuild_index_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rebuild_index_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Rebuild_index_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Rebuild_index_optionsContext) AllRebuild_index_option() []IRebuild_index_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRebuild_index_optionContext); ok { + len++ + } + } + + tst := make([]IRebuild_index_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRebuild_index_optionContext); ok { + tst[i] = t.(IRebuild_index_optionContext) + i++ + } + } + + return tst +} + +func (s *Rebuild_index_optionsContext) Rebuild_index_option(i int) IRebuild_index_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRebuild_index_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRebuild_index_optionContext) +} + +func (s *Rebuild_index_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Rebuild_index_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Rebuild_index_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Rebuild_index_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rebuild_index_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rebuild_index_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRebuild_index_options(s) + } +} + +func (s *Rebuild_index_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRebuild_index_options(s) + } +} + +func (s *Rebuild_index_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRebuild_index_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Rebuild_index_options() (localctx IRebuild_index_optionsContext) { + localctx = NewRebuild_index_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 534, TSqlParserRULE_rebuild_index_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7057) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7058) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7059) + p.Rebuild_index_option() + } + p.SetState(7064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7060) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7061) + p.Rebuild_index_option() + } + + p.SetState(7066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7067) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRebuild_index_optionContext is an interface to support dynamic dispatch. +type IRebuild_index_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTimes returns the times token. + GetTimes() antlr.Token + + // GetMax_degree_of_parallelism returns the max_degree_of_parallelism token. + GetMax_degree_of_parallelism() antlr.Token + + // SetTimes sets the times token. + SetTimes(antlr.Token) + + // SetMax_degree_of_parallelism sets the max_degree_of_parallelism token. + SetMax_degree_of_parallelism(antlr.Token) + + // Getter signatures + PAD_INDEX() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + FILLFACTOR() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + SORT_IN_TEMPDB() antlr.TerminalNode + IGNORE_DUP_KEY() antlr.TerminalNode + STATISTICS_NORECOMPUTE() antlr.TerminalNode + STATISTICS_INCREMENTAL() antlr.TerminalNode + ONLINE() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Low_priority_lock_wait() ILow_priority_lock_waitContext + RR_BRACKET() antlr.TerminalNode + RESUMABLE() antlr.TerminalNode + MAX_DURATION() antlr.TerminalNode + MINUTES() antlr.TerminalNode + ALLOW_ROW_LOCKS() antlr.TerminalNode + ALLOW_PAGE_LOCKS() antlr.TerminalNode + MAXDOP() antlr.TerminalNode + DATA_COMPRESSION() antlr.TerminalNode + NONE() antlr.TerminalNode + ROW() antlr.TerminalNode + PAGE() antlr.TerminalNode + COLUMNSTORE() antlr.TerminalNode + COLUMNSTORE_ARCHIVE() antlr.TerminalNode + On_partitions() IOn_partitionsContext + XML_COMPRESSION() antlr.TerminalNode + + // IsRebuild_index_optionContext differentiates from other interfaces. + IsRebuild_index_optionContext() +} + +type Rebuild_index_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + times antlr.Token + max_degree_of_parallelism antlr.Token +} + +func NewEmptyRebuild_index_optionContext() *Rebuild_index_optionContext { + var p = new(Rebuild_index_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_rebuild_index_option + return p +} + +func InitEmptyRebuild_index_optionContext(p *Rebuild_index_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_rebuild_index_option +} + +func (*Rebuild_index_optionContext) IsRebuild_index_optionContext() {} + +func NewRebuild_index_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rebuild_index_optionContext { + var p = new(Rebuild_index_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_rebuild_index_option + + return p +} + +func (s *Rebuild_index_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rebuild_index_optionContext) GetTimes() antlr.Token { return s.times } + +func (s *Rebuild_index_optionContext) GetMax_degree_of_parallelism() antlr.Token { + return s.max_degree_of_parallelism +} + +func (s *Rebuild_index_optionContext) SetTimes(v antlr.Token) { s.times = v } + +func (s *Rebuild_index_optionContext) SetMax_degree_of_parallelism(v antlr.Token) { + s.max_degree_of_parallelism = v +} + +func (s *Rebuild_index_optionContext) PAD_INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserPAD_INDEX, 0) +} + +func (s *Rebuild_index_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Rebuild_index_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Rebuild_index_optionContext) FILLFACTOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFILLFACTOR, 0) +} + +func (s *Rebuild_index_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Rebuild_index_optionContext) SORT_IN_TEMPDB() antlr.TerminalNode { + return s.GetToken(TSqlParserSORT_IN_TEMPDB, 0) +} + +func (s *Rebuild_index_optionContext) IGNORE_DUP_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_DUP_KEY, 0) +} + +func (s *Rebuild_index_optionContext) STATISTICS_NORECOMPUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS_NORECOMPUTE, 0) +} + +func (s *Rebuild_index_optionContext) STATISTICS_INCREMENTAL() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS_INCREMENTAL, 0) +} + +func (s *Rebuild_index_optionContext) ONLINE() antlr.TerminalNode { + return s.GetToken(TSqlParserONLINE, 0) +} + +func (s *Rebuild_index_optionContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Rebuild_index_optionContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Rebuild_index_optionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Rebuild_index_optionContext) Low_priority_lock_wait() ILow_priority_lock_waitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILow_priority_lock_waitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILow_priority_lock_waitContext) +} + +func (s *Rebuild_index_optionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Rebuild_index_optionContext) RESUMABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESUMABLE, 0) +} + +func (s *Rebuild_index_optionContext) MAX_DURATION() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_DURATION, 0) +} + +func (s *Rebuild_index_optionContext) MINUTES() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUTES, 0) +} + +func (s *Rebuild_index_optionContext) ALLOW_ROW_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_ROW_LOCKS, 0) +} + +func (s *Rebuild_index_optionContext) ALLOW_PAGE_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_PAGE_LOCKS, 0) +} + +func (s *Rebuild_index_optionContext) MAXDOP() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXDOP, 0) +} + +func (s *Rebuild_index_optionContext) DATA_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA_COMPRESSION, 0) +} + +func (s *Rebuild_index_optionContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Rebuild_index_optionContext) ROW() antlr.TerminalNode { + return s.GetToken(TSqlParserROW, 0) +} + +func (s *Rebuild_index_optionContext) PAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserPAGE, 0) +} + +func (s *Rebuild_index_optionContext) COLUMNSTORE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE, 0) +} + +func (s *Rebuild_index_optionContext) COLUMNSTORE_ARCHIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE_ARCHIVE, 0) +} + +func (s *Rebuild_index_optionContext) On_partitions() IOn_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_partitionsContext) +} + +func (s *Rebuild_index_optionContext) XML_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserXML_COMPRESSION, 0) +} + +func (s *Rebuild_index_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rebuild_index_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rebuild_index_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRebuild_index_option(s) + } +} + +func (s *Rebuild_index_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRebuild_index_option(s) + } +} + +func (s *Rebuild_index_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRebuild_index_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Rebuild_index_option() (localctx IRebuild_index_optionContext) { + localctx = NewRebuild_index_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 536, TSqlParserRULE_rebuild_index_option) + var _la int + + p.SetState(7129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPAD_INDEX: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7069) + p.Match(TSqlParserPAD_INDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7070) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7071) + p.On_off() + } + + case TSqlParserFILLFACTOR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7072) + p.Match(TSqlParserFILLFACTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7073) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7074) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSORT_IN_TEMPDB: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7075) + p.Match(TSqlParserSORT_IN_TEMPDB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7076) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7077) + p.On_off() + } + + case TSqlParserIGNORE_DUP_KEY: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7078) + p.Match(TSqlParserIGNORE_DUP_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7079) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7080) + p.On_off() + } + + case TSqlParserSTATISTICS_NORECOMPUTE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7081) + p.Match(TSqlParserSTATISTICS_NORECOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7082) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7083) + p.On_off() + } + + case TSqlParserSTATISTICS_INCREMENTAL: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7084) + p.Match(TSqlParserSTATISTICS_INCREMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7085) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7086) + p.On_off() + } + + case TSqlParserONLINE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7087) + p.Match(TSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7088) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7097) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserON: + { + p.SetState(7089) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLR_BRACKET { + { + p.SetState(7090) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7091) + p.Low_priority_lock_wait() + } + { + p.SetState(7092) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserOFF: + { + p.SetState(7096) + p.Match(TSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserRESUMABLE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(7099) + p.Match(TSqlParserRESUMABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7100) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7101) + p.On_off() + } + + case TSqlParserMAX_DURATION: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(7102) + p.Match(TSqlParserMAX_DURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7103) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7104) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Rebuild_index_optionContext).times = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7106) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMINUTES { + { + p.SetState(7105) + p.Match(TSqlParserMINUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserALLOW_ROW_LOCKS: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(7108) + p.Match(TSqlParserALLOW_ROW_LOCKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7109) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7110) + p.On_off() + } + + case TSqlParserALLOW_PAGE_LOCKS: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(7111) + p.Match(TSqlParserALLOW_PAGE_LOCKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7112) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7113) + p.On_off() + } + + case TSqlParserMAXDOP: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(7114) + p.Match(TSqlParserMAXDOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7115) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7116) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Rebuild_index_optionContext).max_degree_of_parallelism = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDATA_COMPRESSION: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(7117) + p.Match(TSqlParserDATA_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7118) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7119) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCOLUMNSTORE || _la == TSqlParserCOLUMNSTORE_ARCHIVE || _la == TSqlParserNONE || _la == TSqlParserPAGE || _la == TSqlParserROW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(7121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(7120) + p.On_partitions() + } + + } + + case TSqlParserXML_COMPRESSION: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(7123) + p.Match(TSqlParserXML_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7124) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7125) + p.On_off() + } + p.SetState(7127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(7126) + p.On_partitions() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISingle_partition_rebuild_index_optionsContext is an interface to support dynamic dispatch. +type ISingle_partition_rebuild_index_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllSingle_partition_rebuild_index_option() []ISingle_partition_rebuild_index_optionContext + Single_partition_rebuild_index_option(i int) ISingle_partition_rebuild_index_optionContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSingle_partition_rebuild_index_optionsContext differentiates from other interfaces. + IsSingle_partition_rebuild_index_optionsContext() +} + +type Single_partition_rebuild_index_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySingle_partition_rebuild_index_optionsContext() *Single_partition_rebuild_index_optionsContext { + var p = new(Single_partition_rebuild_index_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_single_partition_rebuild_index_options + return p +} + +func InitEmptySingle_partition_rebuild_index_optionsContext(p *Single_partition_rebuild_index_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_single_partition_rebuild_index_options +} + +func (*Single_partition_rebuild_index_optionsContext) IsSingle_partition_rebuild_index_optionsContext() { +} + +func NewSingle_partition_rebuild_index_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Single_partition_rebuild_index_optionsContext { + var p = new(Single_partition_rebuild_index_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_single_partition_rebuild_index_options + + return p +} + +func (s *Single_partition_rebuild_index_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Single_partition_rebuild_index_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Single_partition_rebuild_index_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Single_partition_rebuild_index_optionsContext) AllSingle_partition_rebuild_index_option() []ISingle_partition_rebuild_index_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISingle_partition_rebuild_index_optionContext); ok { + len++ + } + } + + tst := make([]ISingle_partition_rebuild_index_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISingle_partition_rebuild_index_optionContext); ok { + tst[i] = t.(ISingle_partition_rebuild_index_optionContext) + i++ + } + } + + return tst +} + +func (s *Single_partition_rebuild_index_optionsContext) Single_partition_rebuild_index_option(i int) ISingle_partition_rebuild_index_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISingle_partition_rebuild_index_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISingle_partition_rebuild_index_optionContext) +} + +func (s *Single_partition_rebuild_index_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Single_partition_rebuild_index_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Single_partition_rebuild_index_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Single_partition_rebuild_index_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Single_partition_rebuild_index_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Single_partition_rebuild_index_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSingle_partition_rebuild_index_options(s) + } +} + +func (s *Single_partition_rebuild_index_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSingle_partition_rebuild_index_options(s) + } +} + +func (s *Single_partition_rebuild_index_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSingle_partition_rebuild_index_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Single_partition_rebuild_index_options() (localctx ISingle_partition_rebuild_index_optionsContext) { + localctx = NewSingle_partition_rebuild_index_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 538, TSqlParserRULE_single_partition_rebuild_index_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7131) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7132) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7133) + p.Single_partition_rebuild_index_option() + } + p.SetState(7138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7134) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7135) + p.Single_partition_rebuild_index_option() + } + + p.SetState(7140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7141) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISingle_partition_rebuild_index_optionContext is an interface to support dynamic dispatch. +type ISingle_partition_rebuild_index_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMax_degree_of_parallelism returns the max_degree_of_parallelism token. + GetMax_degree_of_parallelism() antlr.Token + + // SetMax_degree_of_parallelism sets the max_degree_of_parallelism token. + SetMax_degree_of_parallelism(antlr.Token) + + // Getter signatures + SORT_IN_TEMPDB() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + MAXDOP() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + RESUMABLE() antlr.TerminalNode + DATA_COMPRESSION() antlr.TerminalNode + NONE() antlr.TerminalNode + ROW() antlr.TerminalNode + PAGE() antlr.TerminalNode + COLUMNSTORE() antlr.TerminalNode + COLUMNSTORE_ARCHIVE() antlr.TerminalNode + On_partitions() IOn_partitionsContext + XML_COMPRESSION() antlr.TerminalNode + ONLINE() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Low_priority_lock_wait() ILow_priority_lock_waitContext + RR_BRACKET() antlr.TerminalNode + + // IsSingle_partition_rebuild_index_optionContext differentiates from other interfaces. + IsSingle_partition_rebuild_index_optionContext() +} + +type Single_partition_rebuild_index_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + max_degree_of_parallelism antlr.Token +} + +func NewEmptySingle_partition_rebuild_index_optionContext() *Single_partition_rebuild_index_optionContext { + var p = new(Single_partition_rebuild_index_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_single_partition_rebuild_index_option + return p +} + +func InitEmptySingle_partition_rebuild_index_optionContext(p *Single_partition_rebuild_index_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_single_partition_rebuild_index_option +} + +func (*Single_partition_rebuild_index_optionContext) IsSingle_partition_rebuild_index_optionContext() { +} + +func NewSingle_partition_rebuild_index_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Single_partition_rebuild_index_optionContext { + var p = new(Single_partition_rebuild_index_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_single_partition_rebuild_index_option + + return p +} + +func (s *Single_partition_rebuild_index_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Single_partition_rebuild_index_optionContext) GetMax_degree_of_parallelism() antlr.Token { + return s.max_degree_of_parallelism +} + +func (s *Single_partition_rebuild_index_optionContext) SetMax_degree_of_parallelism(v antlr.Token) { + s.max_degree_of_parallelism = v +} + +func (s *Single_partition_rebuild_index_optionContext) SORT_IN_TEMPDB() antlr.TerminalNode { + return s.GetToken(TSqlParserSORT_IN_TEMPDB, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Single_partition_rebuild_index_optionContext) MAXDOP() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXDOP, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) RESUMABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESUMABLE, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) DATA_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA_COMPRESSION, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) ROW() antlr.TerminalNode { + return s.GetToken(TSqlParserROW, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) PAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserPAGE, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) COLUMNSTORE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) COLUMNSTORE_ARCHIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE_ARCHIVE, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) On_partitions() IOn_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_partitionsContext) +} + +func (s *Single_partition_rebuild_index_optionContext) XML_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserXML_COMPRESSION, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) ONLINE() antlr.TerminalNode { + return s.GetToken(TSqlParserONLINE, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) Low_priority_lock_wait() ILow_priority_lock_waitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILow_priority_lock_waitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILow_priority_lock_waitContext) +} + +func (s *Single_partition_rebuild_index_optionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Single_partition_rebuild_index_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Single_partition_rebuild_index_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Single_partition_rebuild_index_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSingle_partition_rebuild_index_option(s) + } +} + +func (s *Single_partition_rebuild_index_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSingle_partition_rebuild_index_option(s) + } +} + +func (s *Single_partition_rebuild_index_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSingle_partition_rebuild_index_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Single_partition_rebuild_index_option() (localctx ISingle_partition_rebuild_index_optionContext) { + localctx = NewSingle_partition_rebuild_index_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 540, TSqlParserRULE_single_partition_rebuild_index_option) + var _la int + + p.SetState(7176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSORT_IN_TEMPDB: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7143) + p.Match(TSqlParserSORT_IN_TEMPDB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7144) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7145) + p.On_off() + } + + case TSqlParserMAXDOP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7146) + p.Match(TSqlParserMAXDOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7147) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7148) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Single_partition_rebuild_index_optionContext).max_degree_of_parallelism = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserRESUMABLE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7149) + p.Match(TSqlParserRESUMABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7150) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7151) + p.On_off() + } + + case TSqlParserDATA_COMPRESSION: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7152) + p.Match(TSqlParserDATA_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7153) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7154) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCOLUMNSTORE || _la == TSqlParserCOLUMNSTORE_ARCHIVE || _la == TSqlParserNONE || _la == TSqlParserPAGE || _la == TSqlParserROW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(7156) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(7155) + p.On_partitions() + } + + } + + case TSqlParserXML_COMPRESSION: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7158) + p.Match(TSqlParserXML_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7159) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7160) + p.On_off() + } + p.SetState(7162) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(7161) + p.On_partitions() + } + + } + + case TSqlParserONLINE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7164) + p.Match(TSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7165) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7174) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserON: + { + p.SetState(7166) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7171) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLR_BRACKET { + { + p.SetState(7167) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7168) + p.Low_priority_lock_wait() + } + { + p.SetState(7169) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserOFF: + { + p.SetState(7173) + p.Match(TSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_partitionsContext is an interface to support dynamic dispatch. +type IOn_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartition_number returns the partition_number token. + GetPartition_number() antlr.Token + + // GetTo_partition_number returns the to_partition_number token. + GetTo_partition_number() antlr.Token + + // SetPartition_number sets the partition_number token. + SetPartition_number(antlr.Token) + + // SetTo_partition_number sets the to_partition_number token. + SetTo_partition_number(antlr.Token) + + // Getter signatures + ON() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOn_partitionsContext differentiates from other interfaces. + IsOn_partitionsContext() +} + +type On_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partition_number antlr.Token + to_partition_number antlr.Token +} + +func NewEmptyOn_partitionsContext() *On_partitionsContext { + var p = new(On_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_on_partitions + return p +} + +func InitEmptyOn_partitionsContext(p *On_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_on_partitions +} + +func (*On_partitionsContext) IsOn_partitionsContext() {} + +func NewOn_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_partitionsContext { + var p = new(On_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_on_partitions + + return p +} + +func (s *On_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_partitionsContext) GetPartition_number() antlr.Token { return s.partition_number } + +func (s *On_partitionsContext) GetTo_partition_number() antlr.Token { return s.to_partition_number } + +func (s *On_partitionsContext) SetPartition_number(v antlr.Token) { s.partition_number = v } + +func (s *On_partitionsContext) SetTo_partition_number(v antlr.Token) { s.to_partition_number = v } + +func (s *On_partitionsContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *On_partitionsContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITIONS, 0) +} + +func (s *On_partitionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *On_partitionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *On_partitionsContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *On_partitionsContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *On_partitionsContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTO) +} + +func (s *On_partitionsContext) TO(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTO, i) +} + +func (s *On_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *On_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *On_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOn_partitions(s) + } +} + +func (s *On_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOn_partitions(s) + } +} + +func (s *On_partitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOn_partitions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) On_partitions() (localctx IOn_partitionsContext) { + localctx = NewOn_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 542, TSqlParserRULE_on_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7178) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7179) + p.Match(TSqlParserPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7180) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7181) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*On_partitionsContext).partition_number = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserTO { + { + p.SetState(7182) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7183) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*On_partitionsContext).to_partition_number = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7186) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7187) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*On_partitionsContext).partition_number = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7190) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserTO { + { + p.SetState(7188) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7189) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*On_partitionsContext).to_partition_number = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(7196) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7197) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_columnstore_indexContext is an interface to support dynamic dispatch. +type ICreate_columnstore_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + CLUSTERED() antlr.TerminalNode + COLUMNSTORE() antlr.TerminalNode + INDEX() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + Table_name() ITable_nameContext + Create_columnstore_index_options() ICreate_columnstore_index_optionsContext + SEMI() antlr.TerminalNode + + // IsCreate_columnstore_indexContext differentiates from other interfaces. + IsCreate_columnstore_indexContext() +} + +type Create_columnstore_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_columnstore_indexContext() *Create_columnstore_indexContext { + var p = new(Create_columnstore_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_columnstore_index + return p +} + +func InitEmptyCreate_columnstore_indexContext(p *Create_columnstore_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_columnstore_index +} + +func (*Create_columnstore_indexContext) IsCreate_columnstore_indexContext() {} + +func NewCreate_columnstore_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_columnstore_indexContext { + var p = new(Create_columnstore_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_columnstore_index + + return p +} + +func (s *Create_columnstore_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_columnstore_indexContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_columnstore_indexContext) CLUSTERED() antlr.TerminalNode { + return s.GetToken(TSqlParserCLUSTERED, 0) +} + +func (s *Create_columnstore_indexContext) COLUMNSTORE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE, 0) +} + +func (s *Create_columnstore_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Create_columnstore_indexContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_columnstore_indexContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_columnstore_indexContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Create_columnstore_indexContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Create_columnstore_indexContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Create_columnstore_indexContext) Create_columnstore_index_options() ICreate_columnstore_index_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_columnstore_index_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_columnstore_index_optionsContext) +} + +func (s *Create_columnstore_indexContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Create_columnstore_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_columnstore_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_columnstore_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_columnstore_index(s) + } +} + +func (s *Create_columnstore_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_columnstore_index(s) + } +} + +func (s *Create_columnstore_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_columnstore_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_columnstore_index() (localctx ICreate_columnstore_indexContext) { + localctx = NewCreate_columnstore_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 544, TSqlParserRULE_create_columnstore_index) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7199) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7200) + p.Match(TSqlParserCLUSTERED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7201) + p.Match(TSqlParserCOLUMNSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7202) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7203) + p.Id_() + } + { + p.SetState(7204) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7205) + p.Table_name() + } + p.SetState(7207) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 895, p.GetParserRuleContext()) == 1 { + { + p.SetState(7206) + p.Create_columnstore_index_options() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(7209) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7210) + p.Id_() + } + + } + p.SetState(7214) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 897, p.GetParserRuleContext()) == 1 { + { + p.SetState(7213) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_columnstore_index_optionsContext is an interface to support dynamic dispatch. +type ICreate_columnstore_index_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllColumnstore_index_option() []IColumnstore_index_optionContext + Columnstore_index_option(i int) IColumnstore_index_optionContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_columnstore_index_optionsContext differentiates from other interfaces. + IsCreate_columnstore_index_optionsContext() +} + +type Create_columnstore_index_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_columnstore_index_optionsContext() *Create_columnstore_index_optionsContext { + var p = new(Create_columnstore_index_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_columnstore_index_options + return p +} + +func InitEmptyCreate_columnstore_index_optionsContext(p *Create_columnstore_index_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_columnstore_index_options +} + +func (*Create_columnstore_index_optionsContext) IsCreate_columnstore_index_optionsContext() {} + +func NewCreate_columnstore_index_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_columnstore_index_optionsContext { + var p = new(Create_columnstore_index_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_columnstore_index_options + + return p +} + +func (s *Create_columnstore_index_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_columnstore_index_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_columnstore_index_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_columnstore_index_optionsContext) AllColumnstore_index_option() []IColumnstore_index_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnstore_index_optionContext); ok { + len++ + } + } + + tst := make([]IColumnstore_index_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnstore_index_optionContext); ok { + tst[i] = t.(IColumnstore_index_optionContext) + i++ + } + } + + return tst +} + +func (s *Create_columnstore_index_optionsContext) Columnstore_index_option(i int) IColumnstore_index_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnstore_index_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnstore_index_optionContext) +} + +func (s *Create_columnstore_index_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_columnstore_index_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_columnstore_index_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_columnstore_index_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_columnstore_index_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_columnstore_index_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_columnstore_index_options(s) + } +} + +func (s *Create_columnstore_index_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_columnstore_index_options(s) + } +} + +func (s *Create_columnstore_index_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_columnstore_index_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_columnstore_index_options() (localctx ICreate_columnstore_index_optionsContext) { + localctx = NewCreate_columnstore_index_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 546, TSqlParserRULE_create_columnstore_index_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7216) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7217) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7218) + p.Columnstore_index_option() + } + p.SetState(7223) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7219) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7220) + p.Columnstore_index_option() + } + + p.SetState(7225) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7226) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnstore_index_optionContext is an interface to support dynamic dispatch. +type IColumnstore_index_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMax_degree_of_parallelism returns the max_degree_of_parallelism token. + GetMax_degree_of_parallelism() antlr.Token + + // GetDelay returns the delay token. + GetDelay() antlr.Token + + // SetMax_degree_of_parallelism sets the max_degree_of_parallelism token. + SetMax_degree_of_parallelism(antlr.Token) + + // SetDelay sets the delay token. + SetDelay(antlr.Token) + + // Getter signatures + DROP_EXISTING() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + MAXDOP() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + ONLINE() antlr.TerminalNode + COMPRESSION_DELAY() antlr.TerminalNode + MINUTES() antlr.TerminalNode + DATA_COMPRESSION() antlr.TerminalNode + COLUMNSTORE() antlr.TerminalNode + COLUMNSTORE_ARCHIVE() antlr.TerminalNode + On_partitions() IOn_partitionsContext + + // IsColumnstore_index_optionContext differentiates from other interfaces. + IsColumnstore_index_optionContext() +} + +type Columnstore_index_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + max_degree_of_parallelism antlr.Token + delay antlr.Token +} + +func NewEmptyColumnstore_index_optionContext() *Columnstore_index_optionContext { + var p = new(Columnstore_index_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_columnstore_index_option + return p +} + +func InitEmptyColumnstore_index_optionContext(p *Columnstore_index_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_columnstore_index_option +} + +func (*Columnstore_index_optionContext) IsColumnstore_index_optionContext() {} + +func NewColumnstore_index_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Columnstore_index_optionContext { + var p = new(Columnstore_index_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_columnstore_index_option + + return p +} + +func (s *Columnstore_index_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Columnstore_index_optionContext) GetMax_degree_of_parallelism() antlr.Token { + return s.max_degree_of_parallelism +} + +func (s *Columnstore_index_optionContext) GetDelay() antlr.Token { return s.delay } + +func (s *Columnstore_index_optionContext) SetMax_degree_of_parallelism(v antlr.Token) { + s.max_degree_of_parallelism = v +} + +func (s *Columnstore_index_optionContext) SetDelay(v antlr.Token) { s.delay = v } + +func (s *Columnstore_index_optionContext) DROP_EXISTING() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP_EXISTING, 0) +} + +func (s *Columnstore_index_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Columnstore_index_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Columnstore_index_optionContext) MAXDOP() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXDOP, 0) +} + +func (s *Columnstore_index_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Columnstore_index_optionContext) ONLINE() antlr.TerminalNode { + return s.GetToken(TSqlParserONLINE, 0) +} + +func (s *Columnstore_index_optionContext) COMPRESSION_DELAY() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPRESSION_DELAY, 0) +} + +func (s *Columnstore_index_optionContext) MINUTES() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUTES, 0) +} + +func (s *Columnstore_index_optionContext) DATA_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA_COMPRESSION, 0) +} + +func (s *Columnstore_index_optionContext) COLUMNSTORE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE, 0) +} + +func (s *Columnstore_index_optionContext) COLUMNSTORE_ARCHIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE_ARCHIVE, 0) +} + +func (s *Columnstore_index_optionContext) On_partitions() IOn_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_partitionsContext) +} + +func (s *Columnstore_index_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Columnstore_index_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Columnstore_index_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumnstore_index_option(s) + } +} + +func (s *Columnstore_index_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumnstore_index_option(s) + } +} + +func (s *Columnstore_index_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumnstore_index_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Columnstore_index_option() (localctx IColumnstore_index_optionContext) { + localctx = NewColumnstore_index_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 548, TSqlParserRULE_columnstore_index_option) + var _la int + + p.SetState(7249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDROP_EXISTING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7228) + p.Match(TSqlParserDROP_EXISTING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7229) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7230) + p.On_off() + } + + case TSqlParserMAXDOP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7231) + p.Match(TSqlParserMAXDOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7232) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7233) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Columnstore_index_optionContext).max_degree_of_parallelism = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserONLINE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7234) + p.Match(TSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7235) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7236) + p.On_off() + } + + case TSqlParserCOMPRESSION_DELAY: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7237) + p.Match(TSqlParserCOMPRESSION_DELAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7238) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7239) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Columnstore_index_optionContext).delay = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMINUTES { + { + p.SetState(7240) + p.Match(TSqlParserMINUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserDATA_COMPRESSION: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7243) + p.Match(TSqlParserDATA_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7244) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7245) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCOLUMNSTORE || _la == TSqlParserCOLUMNSTORE_ARCHIVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(7247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(7246) + p.On_partitions() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_nonclustered_columnstore_indexContext is an interface to support dynamic dispatch. +type ICreate_nonclustered_columnstore_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + COLUMNSTORE() antlr.TerminalNode + INDEX() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + Table_name() ITable_nameContext + LR_BRACKET() antlr.TerminalNode + Column_name_list_with_order() IColumn_name_list_with_orderContext + RR_BRACKET() antlr.TerminalNode + NONCLUSTERED() antlr.TerminalNode + WHERE() antlr.TerminalNode + Search_condition() ISearch_conditionContext + Create_columnstore_index_options() ICreate_columnstore_index_optionsContext + SEMI() antlr.TerminalNode + + // IsCreate_nonclustered_columnstore_indexContext differentiates from other interfaces. + IsCreate_nonclustered_columnstore_indexContext() +} + +type Create_nonclustered_columnstore_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_nonclustered_columnstore_indexContext() *Create_nonclustered_columnstore_indexContext { + var p = new(Create_nonclustered_columnstore_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_nonclustered_columnstore_index + return p +} + +func InitEmptyCreate_nonclustered_columnstore_indexContext(p *Create_nonclustered_columnstore_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_nonclustered_columnstore_index +} + +func (*Create_nonclustered_columnstore_indexContext) IsCreate_nonclustered_columnstore_indexContext() { +} + +func NewCreate_nonclustered_columnstore_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_nonclustered_columnstore_indexContext { + var p = new(Create_nonclustered_columnstore_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_nonclustered_columnstore_index + + return p +} + +func (s *Create_nonclustered_columnstore_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_nonclustered_columnstore_indexContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_nonclustered_columnstore_indexContext) COLUMNSTORE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE, 0) +} + +func (s *Create_nonclustered_columnstore_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Create_nonclustered_columnstore_indexContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_nonclustered_columnstore_indexContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_nonclustered_columnstore_indexContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Create_nonclustered_columnstore_indexContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Create_nonclustered_columnstore_indexContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Create_nonclustered_columnstore_indexContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_nonclustered_columnstore_indexContext) Column_name_list_with_order() IColumn_name_list_with_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_list_with_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_list_with_orderContext) +} + +func (s *Create_nonclustered_columnstore_indexContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_nonclustered_columnstore_indexContext) NONCLUSTERED() antlr.TerminalNode { + return s.GetToken(TSqlParserNONCLUSTERED, 0) +} + +func (s *Create_nonclustered_columnstore_indexContext) WHERE() antlr.TerminalNode { + return s.GetToken(TSqlParserWHERE, 0) +} + +func (s *Create_nonclustered_columnstore_indexContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Create_nonclustered_columnstore_indexContext) Create_columnstore_index_options() ICreate_columnstore_index_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_columnstore_index_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_columnstore_index_optionsContext) +} + +func (s *Create_nonclustered_columnstore_indexContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Create_nonclustered_columnstore_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_nonclustered_columnstore_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_nonclustered_columnstore_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_nonclustered_columnstore_index(s) + } +} + +func (s *Create_nonclustered_columnstore_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_nonclustered_columnstore_index(s) + } +} + +func (s *Create_nonclustered_columnstore_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_nonclustered_columnstore_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_nonclustered_columnstore_index() (localctx ICreate_nonclustered_columnstore_indexContext) { + localctx = NewCreate_nonclustered_columnstore_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 550, TSqlParserRULE_create_nonclustered_columnstore_index) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7251) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7253) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserNONCLUSTERED { + { + p.SetState(7252) + p.Match(TSqlParserNONCLUSTERED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7255) + p.Match(TSqlParserCOLUMNSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7256) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7257) + p.Id_() + } + { + p.SetState(7258) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7259) + p.Table_name() + } + { + p.SetState(7260) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7261) + p.Column_name_list_with_order() + } + { + p.SetState(7262) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7265) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWHERE { + { + p.SetState(7263) + p.Match(TSqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7264) + p.search_condition(0) + } + + } + p.SetState(7268) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 904, p.GetParserRuleContext()) == 1 { + { + p.SetState(7267) + p.Create_columnstore_index_options() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(7270) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7271) + p.Id_() + } + + } + p.SetState(7275) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 906, p.GetParserRuleContext()) == 1 { + { + p.SetState(7274) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_xml_indexContext is an interface to support dynamic dispatch. +type ICreate_xml_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + AllXML() []antlr.TerminalNode + XML(i int) antlr.TerminalNode + AllINDEX() []antlr.TerminalNode + INDEX(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ON() antlr.TerminalNode + Table_name() ITable_nameContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + USING() antlr.TerminalNode + Xml_index_options() IXml_index_optionsContext + SEMI() antlr.TerminalNode + FOR() antlr.TerminalNode + VALUE() antlr.TerminalNode + PATH() antlr.TerminalNode + PROPERTY() antlr.TerminalNode + + // IsCreate_xml_indexContext differentiates from other interfaces. + IsCreate_xml_indexContext() +} + +type Create_xml_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_xml_indexContext() *Create_xml_indexContext { + var p = new(Create_xml_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_xml_index + return p +} + +func InitEmptyCreate_xml_indexContext(p *Create_xml_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_xml_index +} + +func (*Create_xml_indexContext) IsCreate_xml_indexContext() {} + +func NewCreate_xml_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_xml_indexContext { + var p = new(Create_xml_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_xml_index + + return p +} + +func (s *Create_xml_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_xml_indexContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_xml_indexContext) AllXML() []antlr.TerminalNode { + return s.GetTokens(TSqlParserXML) +} + +func (s *Create_xml_indexContext) XML(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserXML, i) +} + +func (s *Create_xml_indexContext) AllINDEX() []antlr.TerminalNode { + return s.GetTokens(TSqlParserINDEX) +} + +func (s *Create_xml_indexContext) INDEX(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, i) +} + +func (s *Create_xml_indexContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_xml_indexContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_xml_indexContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Create_xml_indexContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Create_xml_indexContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_xml_indexContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_xml_indexContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIMARY, 0) +} + +func (s *Create_xml_indexContext) USING() antlr.TerminalNode { + return s.GetToken(TSqlParserUSING, 0) +} + +func (s *Create_xml_indexContext) Xml_index_options() IXml_index_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_index_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_index_optionsContext) +} + +func (s *Create_xml_indexContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Create_xml_indexContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_xml_indexContext) VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserVALUE, 0) +} + +func (s *Create_xml_indexContext) PATH() antlr.TerminalNode { + return s.GetToken(TSqlParserPATH, 0) +} + +func (s *Create_xml_indexContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserPROPERTY, 0) +} + +func (s *Create_xml_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_xml_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_xml_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_xml_index(s) + } +} + +func (s *Create_xml_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_xml_index(s) + } +} + +func (s *Create_xml_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_xml_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_xml_index() (localctx ICreate_xml_indexContext) { + localctx = NewCreate_xml_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 552, TSqlParserRULE_create_xml_index) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7277) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPRIMARY { + { + p.SetState(7278) + p.Match(TSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7281) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7282) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7283) + p.Id_() + } + { + p.SetState(7284) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7285) + p.Table_name() + } + { + p.SetState(7286) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7287) + p.Id_() + } + { + p.SetState(7288) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7299) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 910, p.GetParserRuleContext()) == 1 { + { + p.SetState(7289) + p.Match(TSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7290) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7291) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7292) + p.Id_() + } + p.SetState(7297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR { + { + p.SetState(7293) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7295) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 908, p.GetParserRuleContext()) == 1 { + { + p.SetState(7294) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserPATH || _la == TSqlParserPROPERTY || _la == TSqlParserVALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7302) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 911, p.GetParserRuleContext()) == 1 { + { + p.SetState(7301) + p.Xml_index_options() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7305) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 912, p.GetParserRuleContext()) == 1 { + { + p.SetState(7304) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_index_optionsContext is an interface to support dynamic dispatch. +type IXml_index_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllXml_index_option() []IXml_index_optionContext + Xml_index_option(i int) IXml_index_optionContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsXml_index_optionsContext differentiates from other interfaces. + IsXml_index_optionsContext() +} + +type Xml_index_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_index_optionsContext() *Xml_index_optionsContext { + var p = new(Xml_index_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_index_options + return p +} + +func InitEmptyXml_index_optionsContext(p *Xml_index_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_index_options +} + +func (*Xml_index_optionsContext) IsXml_index_optionsContext() {} + +func NewXml_index_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_index_optionsContext { + var p = new(Xml_index_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_xml_index_options + + return p +} + +func (s *Xml_index_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_index_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Xml_index_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Xml_index_optionsContext) AllXml_index_option() []IXml_index_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_index_optionContext); ok { + len++ + } + } + + tst := make([]IXml_index_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_index_optionContext); ok { + tst[i] = t.(IXml_index_optionContext) + i++ + } + } + + return tst +} + +func (s *Xml_index_optionsContext) Xml_index_option(i int) IXml_index_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_index_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_index_optionContext) +} + +func (s *Xml_index_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Xml_index_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Xml_index_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Xml_index_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_index_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_index_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterXml_index_options(s) + } +} + +func (s *Xml_index_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitXml_index_options(s) + } +} + +func (s *Xml_index_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitXml_index_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Xml_index_options() (localctx IXml_index_optionsContext) { + localctx = NewXml_index_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 554, TSqlParserRULE_xml_index_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7307) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7308) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7309) + p.Xml_index_option() + } + p.SetState(7314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7310) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7311) + p.Xml_index_option() + } + + p.SetState(7316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7317) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_index_optionContext is an interface to support dynamic dispatch. +type IXml_index_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMax_degree_of_parallelism returns the max_degree_of_parallelism token. + GetMax_degree_of_parallelism() antlr.Token + + // SetMax_degree_of_parallelism sets the max_degree_of_parallelism token. + SetMax_degree_of_parallelism(antlr.Token) + + // Getter signatures + PAD_INDEX() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + FILLFACTOR() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + SORT_IN_TEMPDB() antlr.TerminalNode + IGNORE_DUP_KEY() antlr.TerminalNode + DROP_EXISTING() antlr.TerminalNode + ONLINE() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Low_priority_lock_wait() ILow_priority_lock_waitContext + RR_BRACKET() antlr.TerminalNode + ALLOW_ROW_LOCKS() antlr.TerminalNode + ALLOW_PAGE_LOCKS() antlr.TerminalNode + MAXDOP() antlr.TerminalNode + XML_COMPRESSION() antlr.TerminalNode + + // IsXml_index_optionContext differentiates from other interfaces. + IsXml_index_optionContext() +} + +type Xml_index_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + max_degree_of_parallelism antlr.Token +} + +func NewEmptyXml_index_optionContext() *Xml_index_optionContext { + var p = new(Xml_index_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_index_option + return p +} + +func InitEmptyXml_index_optionContext(p *Xml_index_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_index_option +} + +func (*Xml_index_optionContext) IsXml_index_optionContext() {} + +func NewXml_index_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_index_optionContext { + var p = new(Xml_index_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_xml_index_option + + return p +} + +func (s *Xml_index_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_index_optionContext) GetMax_degree_of_parallelism() antlr.Token { + return s.max_degree_of_parallelism +} + +func (s *Xml_index_optionContext) SetMax_degree_of_parallelism(v antlr.Token) { + s.max_degree_of_parallelism = v +} + +func (s *Xml_index_optionContext) PAD_INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserPAD_INDEX, 0) +} + +func (s *Xml_index_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Xml_index_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Xml_index_optionContext) FILLFACTOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFILLFACTOR, 0) +} + +func (s *Xml_index_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Xml_index_optionContext) SORT_IN_TEMPDB() antlr.TerminalNode { + return s.GetToken(TSqlParserSORT_IN_TEMPDB, 0) +} + +func (s *Xml_index_optionContext) IGNORE_DUP_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_DUP_KEY, 0) +} + +func (s *Xml_index_optionContext) DROP_EXISTING() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP_EXISTING, 0) +} + +func (s *Xml_index_optionContext) ONLINE() antlr.TerminalNode { + return s.GetToken(TSqlParserONLINE, 0) +} + +func (s *Xml_index_optionContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Xml_index_optionContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Xml_index_optionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Xml_index_optionContext) Low_priority_lock_wait() ILow_priority_lock_waitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILow_priority_lock_waitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILow_priority_lock_waitContext) +} + +func (s *Xml_index_optionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Xml_index_optionContext) ALLOW_ROW_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_ROW_LOCKS, 0) +} + +func (s *Xml_index_optionContext) ALLOW_PAGE_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_PAGE_LOCKS, 0) +} + +func (s *Xml_index_optionContext) MAXDOP() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXDOP, 0) +} + +func (s *Xml_index_optionContext) XML_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserXML_COMPRESSION, 0) +} + +func (s *Xml_index_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_index_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_index_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterXml_index_option(s) + } +} + +func (s *Xml_index_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitXml_index_option(s) + } +} + +func (s *Xml_index_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitXml_index_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Xml_index_option() (localctx IXml_index_optionContext) { + localctx = NewXml_index_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 556, TSqlParserRULE_xml_index_option) + var _la int + + p.SetState(7358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPAD_INDEX: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7319) + p.Match(TSqlParserPAD_INDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7320) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7321) + p.On_off() + } + + case TSqlParserFILLFACTOR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7322) + p.Match(TSqlParserFILLFACTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7323) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7324) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSORT_IN_TEMPDB: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7325) + p.Match(TSqlParserSORT_IN_TEMPDB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7326) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7327) + p.On_off() + } + + case TSqlParserIGNORE_DUP_KEY: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7328) + p.Match(TSqlParserIGNORE_DUP_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7329) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7330) + p.On_off() + } + + case TSqlParserDROP_EXISTING: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7331) + p.Match(TSqlParserDROP_EXISTING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7332) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7333) + p.On_off() + } + + case TSqlParserONLINE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7334) + p.Match(TSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7335) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7344) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserON: + { + p.SetState(7336) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLR_BRACKET { + { + p.SetState(7337) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7338) + p.Low_priority_lock_wait() + } + { + p.SetState(7339) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserOFF: + { + p.SetState(7343) + p.Match(TSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserALLOW_ROW_LOCKS: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7346) + p.Match(TSqlParserALLOW_ROW_LOCKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7347) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7348) + p.On_off() + } + + case TSqlParserALLOW_PAGE_LOCKS: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(7349) + p.Match(TSqlParserALLOW_PAGE_LOCKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7350) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7351) + p.On_off() + } + + case TSqlParserMAXDOP: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(7352) + p.Match(TSqlParserMAXDOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7353) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7354) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Xml_index_optionContext).max_degree_of_parallelism = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserXML_COMPRESSION: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(7355) + p.Match(TSqlParserXML_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7356) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7357) + p.On_off() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_or_alter_procedureContext is an interface to support dynamic dispatch. +type ICreate_or_alter_procedureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetProc returns the proc token. + GetProc() antlr.Token + + // SetProc sets the proc token. + SetProc(antlr.Token) + + // GetProcName returns the procName rule contexts. + GetProcName() IFunc_proc_name_schemaContext + + // SetProcName sets the procName rule contexts. + SetProcName(IFunc_proc_name_schemaContext) + + // Getter signatures + AS() antlr.TerminalNode + Func_proc_name_schema() IFunc_proc_name_schemaContext + ALTER() antlr.TerminalNode + PROC() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + As_external_name() IAs_external_nameContext + SEMI() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + AllProcedure_param() []IProcedure_paramContext + Procedure_param(i int) IProcedure_paramContext + WITH() antlr.TerminalNode + AllProcedure_option() []IProcedure_optionContext + Procedure_option(i int) IProcedure_optionContext + FOR() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + CREATE() antlr.TerminalNode + AllSql_clauses() []ISql_clausesContext + Sql_clauses(i int) ISql_clausesContext + LR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + + // IsCreate_or_alter_procedureContext differentiates from other interfaces. + IsCreate_or_alter_procedureContext() +} + +type Create_or_alter_procedureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + proc antlr.Token + procName IFunc_proc_name_schemaContext +} + +func NewEmptyCreate_or_alter_procedureContext() *Create_or_alter_procedureContext { + var p = new(Create_or_alter_procedureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_procedure + return p +} + +func InitEmptyCreate_or_alter_procedureContext(p *Create_or_alter_procedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_procedure +} + +func (*Create_or_alter_procedureContext) IsCreate_or_alter_procedureContext() {} + +func NewCreate_or_alter_procedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_procedureContext { + var p = new(Create_or_alter_procedureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_or_alter_procedure + + return p +} + +func (s *Create_or_alter_procedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_or_alter_procedureContext) GetProc() antlr.Token { return s.proc } + +func (s *Create_or_alter_procedureContext) SetProc(v antlr.Token) { s.proc = v } + +func (s *Create_or_alter_procedureContext) GetProcName() IFunc_proc_name_schemaContext { + return s.procName +} + +func (s *Create_or_alter_procedureContext) SetProcName(v IFunc_proc_name_schemaContext) { + s.procName = v +} + +func (s *Create_or_alter_procedureContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Create_or_alter_procedureContext) Func_proc_name_schema() IFunc_proc_name_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_proc_name_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_proc_name_schemaContext) +} + +func (s *Create_or_alter_procedureContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Create_or_alter_procedureContext) PROC() antlr.TerminalNode { + return s.GetToken(TSqlParserPROC, 0) +} + +func (s *Create_or_alter_procedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(TSqlParserPROCEDURE, 0) +} + +func (s *Create_or_alter_procedureContext) As_external_name() IAs_external_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_external_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_external_nameContext) +} + +func (s *Create_or_alter_procedureContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Create_or_alter_procedureContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Create_or_alter_procedureContext) AllProcedure_param() []IProcedure_paramContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedure_paramContext); ok { + len++ + } + } + + tst := make([]IProcedure_paramContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedure_paramContext); ok { + tst[i] = t.(IProcedure_paramContext) + i++ + } + } + + return tst +} + +func (s *Create_or_alter_procedureContext) Procedure_param(i int) IProcedure_paramContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_paramContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_paramContext) +} + +func (s *Create_or_alter_procedureContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_or_alter_procedureContext) AllProcedure_option() []IProcedure_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedure_optionContext); ok { + len++ + } + } + + tst := make([]IProcedure_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedure_optionContext); ok { + tst[i] = t.(IProcedure_optionContext) + i++ + } + } + + return tst +} + +func (s *Create_or_alter_procedureContext) Procedure_option(i int) IProcedure_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_optionContext) +} + +func (s *Create_or_alter_procedureContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_or_alter_procedureContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLICATION, 0) +} + +func (s *Create_or_alter_procedureContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_or_alter_procedureContext) AllSql_clauses() []ISql_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_clausesContext); ok { + len++ + } + } + + tst := make([]ISql_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_clausesContext); ok { + tst[i] = t.(ISql_clausesContext) + i++ + } + } + + return tst +} + +func (s *Create_or_alter_procedureContext) Sql_clauses(i int) ISql_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_clausesContext) +} + +func (s *Create_or_alter_procedureContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_or_alter_procedureContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_or_alter_procedureContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_or_alter_procedureContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_or_alter_procedureContext) OR() antlr.TerminalNode { + return s.GetToken(TSqlParserOR, 0) +} + +func (s *Create_or_alter_procedureContext) REPLACE() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLACE, 0) +} + +func (s *Create_or_alter_procedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_or_alter_procedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_or_alter_procedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_or_alter_procedure(s) + } +} + +func (s *Create_or_alter_procedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_or_alter_procedure(s) + } +} + +func (s *Create_or_alter_procedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_or_alter_procedure(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_or_alter_procedure() (localctx ICreate_or_alter_procedureContext) { + localctx = NewCreate_or_alter_procedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 558, TSqlParserRULE_create_or_alter_procedure) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCREATE: + { + p.SetState(7360) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOR { + { + p.SetState(7361) + p.Match(TSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7362) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALTER || _la == TSqlParserREPLACE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case TSqlParserALTER: + { + p.SetState(7365) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7368) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Create_or_alter_procedureContext).proc = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserPROC || _la == TSqlParserPROCEDURE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Create_or_alter_procedureContext).proc = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7369) + + var _x = p.Func_proc_name_schema() + + localctx.(*Create_or_alter_procedureContext).procName = _x + } + p.SetState(7372) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSEMI { + { + p.SetState(7370) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7371) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7388) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLOCAL_ID || _la == TSqlParserLR_BRACKET { + p.SetState(7375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLR_BRACKET { + { + p.SetState(7374) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7377) + p.Procedure_param() + } + p.SetState(7382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7378) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7379) + p.Procedure_param() + } + + p.SetState(7384) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(7386) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserRR_BRACKET { + { + p.SetState(7385) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(7399) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(7390) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7391) + p.Procedure_option() + } + p.SetState(7396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7392) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7393) + p.Procedure_option() + } + + p.SetState(7398) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(7403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR { + { + p.SetState(7401) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7402) + p.Match(TSqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7405) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserEXTERNAL: + { + p.SetState(7406) + p.As_external_name() + } + + case TSqlParserEOF, TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALTER, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBREAK, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKPOINT, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLOSE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMIT, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDEALLOCATE, TSqlParserDECLARE, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETE, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROP, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserEND, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXECUTE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFETCH, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOTO, TSqlParserGOVERNOR, TSqlParserGRANT, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIF, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERT, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserKILL, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMERGE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPEN, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRINT, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRAISERROR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECONFIGURE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURN, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREVERT, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROLLBACK, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSAVE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELECT, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSET, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSETUSER, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSHUTDOWN, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUNCATE, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDATE, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSE, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAITFOR, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWHILE, TSqlParserWINDOWS, TSqlParserWITH, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserLR_BRACKET, TSqlParserSEMI: + p.SetState(7410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 927, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7407) + p.Sql_clauses() + } + + } + p.SetState(7412) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 927, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAs_external_nameContext is an interface to support dynamic dispatch. +type IAs_external_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAssembly_name returns the assembly_name rule contexts. + GetAssembly_name() IId_Context + + // GetClass_name returns the class_name rule contexts. + GetClass_name() IId_Context + + // GetMethod_name returns the method_name rule contexts. + GetMethod_name() IId_Context + + // SetAssembly_name sets the assembly_name rule contexts. + SetAssembly_name(IId_Context) + + // SetClass_name sets the class_name rule contexts. + SetClass_name(IId_Context) + + // SetMethod_name sets the method_name rule contexts. + SetMethod_name(IId_Context) + + // Getter signatures + EXTERNAL() antlr.TerminalNode + NAME() antlr.TerminalNode + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + + // IsAs_external_nameContext differentiates from other interfaces. + IsAs_external_nameContext() +} + +type As_external_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + assembly_name IId_Context + class_name IId_Context + method_name IId_Context +} + +func NewEmptyAs_external_nameContext() *As_external_nameContext { + var p = new(As_external_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_as_external_name + return p +} + +func InitEmptyAs_external_nameContext(p *As_external_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_as_external_name +} + +func (*As_external_nameContext) IsAs_external_nameContext() {} + +func NewAs_external_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *As_external_nameContext { + var p = new(As_external_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_as_external_name + + return p +} + +func (s *As_external_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *As_external_nameContext) GetAssembly_name() IId_Context { return s.assembly_name } + +func (s *As_external_nameContext) GetClass_name() IId_Context { return s.class_name } + +func (s *As_external_nameContext) GetMethod_name() IId_Context { return s.method_name } + +func (s *As_external_nameContext) SetAssembly_name(v IId_Context) { s.assembly_name = v } + +func (s *As_external_nameContext) SetClass_name(v IId_Context) { s.class_name = v } + +func (s *As_external_nameContext) SetMethod_name(v IId_Context) { s.method_name = v } + +func (s *As_external_nameContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *As_external_nameContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *As_external_nameContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *As_external_nameContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *As_external_nameContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *As_external_nameContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *As_external_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *As_external_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *As_external_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAs_external_name(s) + } +} + +func (s *As_external_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAs_external_name(s) + } +} + +func (s *As_external_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAs_external_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) As_external_name() (localctx IAs_external_nameContext) { + localctx = NewAs_external_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 560, TSqlParserRULE_as_external_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7415) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7416) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7417) + + var _x = p.Id_() + + localctx.(*As_external_nameContext).assembly_name = _x + } + { + p.SetState(7418) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7419) + + var _x = p.Id_() + + localctx.(*As_external_nameContext).class_name = _x + } + { + p.SetState(7420) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7421) + + var _x = p.Id_() + + localctx.(*As_external_nameContext).method_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_or_alter_triggerContext is an interface to support dynamic dispatch. +type ICreate_or_alter_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Create_or_alter_dml_trigger() ICreate_or_alter_dml_triggerContext + Create_or_alter_ddl_trigger() ICreate_or_alter_ddl_triggerContext + + // IsCreate_or_alter_triggerContext differentiates from other interfaces. + IsCreate_or_alter_triggerContext() +} + +type Create_or_alter_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_or_alter_triggerContext() *Create_or_alter_triggerContext { + var p = new(Create_or_alter_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_trigger + return p +} + +func InitEmptyCreate_or_alter_triggerContext(p *Create_or_alter_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_trigger +} + +func (*Create_or_alter_triggerContext) IsCreate_or_alter_triggerContext() {} + +func NewCreate_or_alter_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_triggerContext { + var p = new(Create_or_alter_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_or_alter_trigger + + return p +} + +func (s *Create_or_alter_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_or_alter_triggerContext) Create_or_alter_dml_trigger() ICreate_or_alter_dml_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_or_alter_dml_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_or_alter_dml_triggerContext) +} + +func (s *Create_or_alter_triggerContext) Create_or_alter_ddl_trigger() ICreate_or_alter_ddl_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_or_alter_ddl_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_or_alter_ddl_triggerContext) +} + +func (s *Create_or_alter_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_or_alter_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_or_alter_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_or_alter_trigger(s) + } +} + +func (s *Create_or_alter_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_or_alter_trigger(s) + } +} + +func (s *Create_or_alter_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_or_alter_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_or_alter_trigger() (localctx ICreate_or_alter_triggerContext) { + localctx = NewCreate_or_alter_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 562, TSqlParserRULE_create_or_alter_trigger) + p.SetState(7425) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 929, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7423) + p.Create_or_alter_dml_trigger() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7424) + p.Create_or_alter_ddl_trigger() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_or_alter_dml_triggerContext is an interface to support dynamic dispatch. +type ICreate_or_alter_dml_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRIGGER() antlr.TerminalNode + Simple_name() ISimple_nameContext + ON() antlr.TerminalNode + Table_name() ITable_nameContext + AllDml_trigger_operation() []IDml_trigger_operationContext + Dml_trigger_operation(i int) IDml_trigger_operationContext + AS() antlr.TerminalNode + CREATE() antlr.TerminalNode + ALTER() antlr.TerminalNode + AllFOR() []antlr.TerminalNode + FOR(i int) antlr.TerminalNode + AFTER() antlr.TerminalNode + INSTEAD() antlr.TerminalNode + OF() antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AllDml_trigger_option() []IDml_trigger_optionContext + Dml_trigger_option(i int) IDml_trigger_optionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + APPEND() antlr.TerminalNode + NOT() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + AllSql_clauses() []ISql_clausesContext + Sql_clauses(i int) ISql_clausesContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + + // IsCreate_or_alter_dml_triggerContext differentiates from other interfaces. + IsCreate_or_alter_dml_triggerContext() +} + +type Create_or_alter_dml_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_or_alter_dml_triggerContext() *Create_or_alter_dml_triggerContext { + var p = new(Create_or_alter_dml_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_dml_trigger + return p +} + +func InitEmptyCreate_or_alter_dml_triggerContext(p *Create_or_alter_dml_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_dml_trigger +} + +func (*Create_or_alter_dml_triggerContext) IsCreate_or_alter_dml_triggerContext() {} + +func NewCreate_or_alter_dml_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_dml_triggerContext { + var p = new(Create_or_alter_dml_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_or_alter_dml_trigger + + return p +} + +func (s *Create_or_alter_dml_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_or_alter_dml_triggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIGGER, 0) +} + +func (s *Create_or_alter_dml_triggerContext) Simple_name() ISimple_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimple_nameContext) +} + +func (s *Create_or_alter_dml_triggerContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Create_or_alter_dml_triggerContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Create_or_alter_dml_triggerContext) AllDml_trigger_operation() []IDml_trigger_operationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDml_trigger_operationContext); ok { + len++ + } + } + + tst := make([]IDml_trigger_operationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDml_trigger_operationContext); ok { + tst[i] = t.(IDml_trigger_operationContext) + i++ + } + } + + return tst +} + +func (s *Create_or_alter_dml_triggerContext) Dml_trigger_operation(i int) IDml_trigger_operationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_trigger_operationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDml_trigger_operationContext) +} + +func (s *Create_or_alter_dml_triggerContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Create_or_alter_dml_triggerContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_or_alter_dml_triggerContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Create_or_alter_dml_triggerContext) AllFOR() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFOR) +} + +func (s *Create_or_alter_dml_triggerContext) FOR(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, i) +} + +func (s *Create_or_alter_dml_triggerContext) AFTER() antlr.TerminalNode { + return s.GetToken(TSqlParserAFTER, 0) +} + +func (s *Create_or_alter_dml_triggerContext) INSTEAD() antlr.TerminalNode { + return s.GetToken(TSqlParserINSTEAD, 0) +} + +func (s *Create_or_alter_dml_triggerContext) OF() antlr.TerminalNode { + return s.GetToken(TSqlParserOF, 0) +} + +func (s *Create_or_alter_dml_triggerContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(TSqlParserWITH) +} + +func (s *Create_or_alter_dml_triggerContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, i) +} + +func (s *Create_or_alter_dml_triggerContext) AllDml_trigger_option() []IDml_trigger_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDml_trigger_optionContext); ok { + len++ + } + } + + tst := make([]IDml_trigger_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDml_trigger_optionContext); ok { + tst[i] = t.(IDml_trigger_optionContext) + i++ + } + } + + return tst +} + +func (s *Create_or_alter_dml_triggerContext) Dml_trigger_option(i int) IDml_trigger_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_trigger_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDml_trigger_optionContext) +} + +func (s *Create_or_alter_dml_triggerContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_or_alter_dml_triggerContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_or_alter_dml_triggerContext) APPEND() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPEND, 0) +} + +func (s *Create_or_alter_dml_triggerContext) NOT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, 0) +} + +func (s *Create_or_alter_dml_triggerContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLICATION, 0) +} + +func (s *Create_or_alter_dml_triggerContext) AllSql_clauses() []ISql_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_clausesContext); ok { + len++ + } + } + + tst := make([]ISql_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_clausesContext); ok { + tst[i] = t.(ISql_clausesContext) + i++ + } + } + + return tst +} + +func (s *Create_or_alter_dml_triggerContext) Sql_clauses(i int) ISql_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_clausesContext) +} + +func (s *Create_or_alter_dml_triggerContext) OR() antlr.TerminalNode { + return s.GetToken(TSqlParserOR, 0) +} + +func (s *Create_or_alter_dml_triggerContext) REPLACE() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLACE, 0) +} + +func (s *Create_or_alter_dml_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_or_alter_dml_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_or_alter_dml_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_or_alter_dml_trigger(s) + } +} + +func (s *Create_or_alter_dml_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_or_alter_dml_trigger(s) + } +} + +func (s *Create_or_alter_dml_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_or_alter_dml_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_or_alter_dml_trigger() (localctx ICreate_or_alter_dml_triggerContext) { + localctx = NewCreate_or_alter_dml_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 564, TSqlParserRULE_create_or_alter_dml_trigger) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7433) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCREATE: + { + p.SetState(7427) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7430) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOR { + { + p.SetState(7428) + p.Match(TSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7429) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALTER || _la == TSqlParserREPLACE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case TSqlParserALTER: + { + p.SetState(7432) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7435) + p.Match(TSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7436) + p.Simple_name() + } + { + p.SetState(7437) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7438) + p.Table_name() + } + p.SetState(7448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(7439) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7440) + p.Dml_trigger_option() + } + p.SetState(7445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7441) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7442) + p.Dml_trigger_option() + } + + p.SetState(7447) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(7454) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFOR: + { + p.SetState(7450) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserAFTER: + { + p.SetState(7451) + p.Match(TSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserINSTEAD: + { + p.SetState(7452) + p.Match(TSqlParserINSTEAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7453) + p.Match(TSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7456) + p.Dml_trigger_operation() + } + p.SetState(7461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7457) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7458) + p.Dml_trigger_operation() + } + + p.SetState(7463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(7466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(7464) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7465) + p.Match(TSqlParserAPPEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserNOT { + { + p.SetState(7468) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7469) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7470) + p.Match(TSqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7473) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7475) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(7474) + p.Sql_clauses() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(7477) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 938, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDml_trigger_optionContext is an interface to support dynamic dispatch. +type IDml_trigger_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTION() antlr.TerminalNode + Execute_clause() IExecute_clauseContext + + // IsDml_trigger_optionContext differentiates from other interfaces. + IsDml_trigger_optionContext() +} + +type Dml_trigger_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDml_trigger_optionContext() *Dml_trigger_optionContext { + var p = new(Dml_trigger_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dml_trigger_option + return p +} + +func InitEmptyDml_trigger_optionContext(p *Dml_trigger_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dml_trigger_option +} + +func (*Dml_trigger_optionContext) IsDml_trigger_optionContext() {} + +func NewDml_trigger_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_trigger_optionContext { + var p = new(Dml_trigger_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dml_trigger_option + + return p +} + +func (s *Dml_trigger_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dml_trigger_optionContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Dml_trigger_optionContext) Execute_clause() IExecute_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_clauseContext) +} + +func (s *Dml_trigger_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dml_trigger_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dml_trigger_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDml_trigger_option(s) + } +} + +func (s *Dml_trigger_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDml_trigger_option(s) + } +} + +func (s *Dml_trigger_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDml_trigger_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dml_trigger_option() (localctx IDml_trigger_optionContext) { + localctx = NewDml_trigger_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 566, TSqlParserRULE_dml_trigger_option) + p.SetState(7481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserENCRYPTION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7479) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEXECUTE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7480) + p.Execute_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDml_trigger_operationContext is an interface to support dynamic dispatch. +type IDml_trigger_operationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSERT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + DELETE() antlr.TerminalNode + + // IsDml_trigger_operationContext differentiates from other interfaces. + IsDml_trigger_operationContext() +} + +type Dml_trigger_operationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDml_trigger_operationContext() *Dml_trigger_operationContext { + var p = new(Dml_trigger_operationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dml_trigger_operation + return p +} + +func InitEmptyDml_trigger_operationContext(p *Dml_trigger_operationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dml_trigger_operation +} + +func (*Dml_trigger_operationContext) IsDml_trigger_operationContext() {} + +func NewDml_trigger_operationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_trigger_operationContext { + var p = new(Dml_trigger_operationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dml_trigger_operation + + return p +} + +func (s *Dml_trigger_operationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dml_trigger_operationContext) INSERT() antlr.TerminalNode { + return s.GetToken(TSqlParserINSERT, 0) +} + +func (s *Dml_trigger_operationContext) UPDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserUPDATE, 0) +} + +func (s *Dml_trigger_operationContext) DELETE() antlr.TerminalNode { + return s.GetToken(TSqlParserDELETE, 0) +} + +func (s *Dml_trigger_operationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dml_trigger_operationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dml_trigger_operationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDml_trigger_operation(s) + } +} + +func (s *Dml_trigger_operationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDml_trigger_operation(s) + } +} + +func (s *Dml_trigger_operationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDml_trigger_operation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dml_trigger_operation() (localctx IDml_trigger_operationContext) { + localctx = NewDml_trigger_operationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 568, TSqlParserRULE_dml_trigger_operation) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7483) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDELETE || _la == TSqlParserINSERT || _la == TSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_or_alter_ddl_triggerContext is an interface to support dynamic dispatch. +type ICreate_or_alter_ddl_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRIGGER() antlr.TerminalNode + Simple_name() ISimple_nameContext + ON() antlr.TerminalNode + AllDdl_trigger_operation() []IDdl_trigger_operationContext + Ddl_trigger_operation(i int) IDdl_trigger_operationContext + AS() antlr.TerminalNode + FOR() antlr.TerminalNode + AFTER() antlr.TerminalNode + CREATE() antlr.TerminalNode + ALTER() antlr.TerminalNode + ALL() antlr.TerminalNode + SERVER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + WITH() antlr.TerminalNode + AllDml_trigger_option() []IDml_trigger_optionContext + Dml_trigger_option(i int) IDml_trigger_optionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllSql_clauses() []ISql_clausesContext + Sql_clauses(i int) ISql_clausesContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + + // IsCreate_or_alter_ddl_triggerContext differentiates from other interfaces. + IsCreate_or_alter_ddl_triggerContext() +} + +type Create_or_alter_ddl_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_or_alter_ddl_triggerContext() *Create_or_alter_ddl_triggerContext { + var p = new(Create_or_alter_ddl_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_ddl_trigger + return p +} + +func InitEmptyCreate_or_alter_ddl_triggerContext(p *Create_or_alter_ddl_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_ddl_trigger +} + +func (*Create_or_alter_ddl_triggerContext) IsCreate_or_alter_ddl_triggerContext() {} + +func NewCreate_or_alter_ddl_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_ddl_triggerContext { + var p = new(Create_or_alter_ddl_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_or_alter_ddl_trigger + + return p +} + +func (s *Create_or_alter_ddl_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_or_alter_ddl_triggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIGGER, 0) +} + +func (s *Create_or_alter_ddl_triggerContext) Simple_name() ISimple_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimple_nameContext) +} + +func (s *Create_or_alter_ddl_triggerContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Create_or_alter_ddl_triggerContext) AllDdl_trigger_operation() []IDdl_trigger_operationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDdl_trigger_operationContext); ok { + len++ + } + } + + tst := make([]IDdl_trigger_operationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDdl_trigger_operationContext); ok { + tst[i] = t.(IDdl_trigger_operationContext) + i++ + } + } + + return tst +} + +func (s *Create_or_alter_ddl_triggerContext) Ddl_trigger_operation(i int) IDdl_trigger_operationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDdl_trigger_operationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDdl_trigger_operationContext) +} + +func (s *Create_or_alter_ddl_triggerContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Create_or_alter_ddl_triggerContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_or_alter_ddl_triggerContext) AFTER() antlr.TerminalNode { + return s.GetToken(TSqlParserAFTER, 0) +} + +func (s *Create_or_alter_ddl_triggerContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_or_alter_ddl_triggerContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Create_or_alter_ddl_triggerContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Create_or_alter_ddl_triggerContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Create_or_alter_ddl_triggerContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Create_or_alter_ddl_triggerContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_or_alter_ddl_triggerContext) AllDml_trigger_option() []IDml_trigger_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDml_trigger_optionContext); ok { + len++ + } + } + + tst := make([]IDml_trigger_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDml_trigger_optionContext); ok { + tst[i] = t.(IDml_trigger_optionContext) + i++ + } + } + + return tst +} + +func (s *Create_or_alter_ddl_triggerContext) Dml_trigger_option(i int) IDml_trigger_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_trigger_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDml_trigger_optionContext) +} + +func (s *Create_or_alter_ddl_triggerContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_or_alter_ddl_triggerContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_or_alter_ddl_triggerContext) AllSql_clauses() []ISql_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_clausesContext); ok { + len++ + } + } + + tst := make([]ISql_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_clausesContext); ok { + tst[i] = t.(ISql_clausesContext) + i++ + } + } + + return tst +} + +func (s *Create_or_alter_ddl_triggerContext) Sql_clauses(i int) ISql_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_clausesContext) +} + +func (s *Create_or_alter_ddl_triggerContext) OR() antlr.TerminalNode { + return s.GetToken(TSqlParserOR, 0) +} + +func (s *Create_or_alter_ddl_triggerContext) REPLACE() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLACE, 0) +} + +func (s *Create_or_alter_ddl_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_or_alter_ddl_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_or_alter_ddl_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_or_alter_ddl_trigger(s) + } +} + +func (s *Create_or_alter_ddl_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_or_alter_ddl_trigger(s) + } +} + +func (s *Create_or_alter_ddl_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_or_alter_ddl_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_or_alter_ddl_trigger() (localctx ICreate_or_alter_ddl_triggerContext) { + localctx = NewCreate_or_alter_ddl_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 570, TSqlParserRULE_create_or_alter_ddl_trigger) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7491) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCREATE: + { + p.SetState(7485) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7488) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOR { + { + p.SetState(7486) + p.Match(TSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7487) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALTER || _la == TSqlParserREPLACE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case TSqlParserALTER: + { + p.SetState(7490) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7493) + p.Match(TSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7494) + p.Simple_name() + } + { + p.SetState(7495) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALL: + { + p.SetState(7496) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7497) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDATABASE: + { + p.SetState(7498) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(7510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(7501) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7502) + p.Dml_trigger_option() + } + p.SetState(7507) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7503) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7504) + p.Dml_trigger_option() + } + + p.SetState(7509) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(7512) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAFTER || _la == TSqlParserFOR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7513) + p.Ddl_trigger_operation() + } + p.SetState(7518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7514) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7515) + p.Ddl_trigger_operation() + } + + p.SetState(7520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7521) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7523) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(7522) + p.Sql_clauses() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(7525) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 946, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDdl_trigger_operationContext is an interface to support dynamic dispatch. +type IDdl_trigger_operationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Simple_id() ISimple_idContext + + // IsDdl_trigger_operationContext differentiates from other interfaces. + IsDdl_trigger_operationContext() +} + +type Ddl_trigger_operationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDdl_trigger_operationContext() *Ddl_trigger_operationContext { + var p = new(Ddl_trigger_operationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_ddl_trigger_operation + return p +} + +func InitEmptyDdl_trigger_operationContext(p *Ddl_trigger_operationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_ddl_trigger_operation +} + +func (*Ddl_trigger_operationContext) IsDdl_trigger_operationContext() {} + +func NewDdl_trigger_operationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ddl_trigger_operationContext { + var p = new(Ddl_trigger_operationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_ddl_trigger_operation + + return p +} + +func (s *Ddl_trigger_operationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ddl_trigger_operationContext) Simple_id() ISimple_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimple_idContext) +} + +func (s *Ddl_trigger_operationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ddl_trigger_operationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ddl_trigger_operationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDdl_trigger_operation(s) + } +} + +func (s *Ddl_trigger_operationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDdl_trigger_operation(s) + } +} + +func (s *Ddl_trigger_operationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDdl_trigger_operation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Ddl_trigger_operation() (localctx IDdl_trigger_operationContext) { + localctx = NewDdl_trigger_operationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 572, TSqlParserRULE_ddl_trigger_operation) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7527) + p.Simple_id() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_or_alter_functionContext is an interface to support dynamic dispatch. +type ICreate_or_alter_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFuncName returns the funcName rule contexts. + GetFuncName() IFunc_proc_name_schemaContext + + // SetFuncName sets the funcName rule contexts. + SetFuncName(IFunc_proc_name_schemaContext) + + // Getter signatures + FUNCTION() antlr.TerminalNode + Func_proc_name_schema() IFunc_proc_name_schemaContext + ALTER() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Func_body_returns_select() IFunc_body_returns_selectContext + Func_body_returns_table() IFunc_body_returns_tableContext + Func_body_returns_scalar() IFunc_body_returns_scalarContext + SEMI() antlr.TerminalNode + CREATE() antlr.TerminalNode + AllProcedure_param() []IProcedure_paramContext + Procedure_param(i int) IProcedure_paramContext + OR() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_or_alter_functionContext differentiates from other interfaces. + IsCreate_or_alter_functionContext() +} + +type Create_or_alter_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + funcName IFunc_proc_name_schemaContext +} + +func NewEmptyCreate_or_alter_functionContext() *Create_or_alter_functionContext { + var p = new(Create_or_alter_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_function + return p +} + +func InitEmptyCreate_or_alter_functionContext(p *Create_or_alter_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_or_alter_function +} + +func (*Create_or_alter_functionContext) IsCreate_or_alter_functionContext() {} + +func NewCreate_or_alter_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_functionContext { + var p = new(Create_or_alter_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_or_alter_function + + return p +} + +func (s *Create_or_alter_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_or_alter_functionContext) GetFuncName() IFunc_proc_name_schemaContext { + return s.funcName +} + +func (s *Create_or_alter_functionContext) SetFuncName(v IFunc_proc_name_schemaContext) { + s.funcName = v +} + +func (s *Create_or_alter_functionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(TSqlParserFUNCTION, 0) +} + +func (s *Create_or_alter_functionContext) Func_proc_name_schema() IFunc_proc_name_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_proc_name_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_proc_name_schemaContext) +} + +func (s *Create_or_alter_functionContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Create_or_alter_functionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_or_alter_functionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_or_alter_functionContext) Func_body_returns_select() IFunc_body_returns_selectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_body_returns_selectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_body_returns_selectContext) +} + +func (s *Create_or_alter_functionContext) Func_body_returns_table() IFunc_body_returns_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_body_returns_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_body_returns_tableContext) +} + +func (s *Create_or_alter_functionContext) Func_body_returns_scalar() IFunc_body_returns_scalarContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_body_returns_scalarContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_body_returns_scalarContext) +} + +func (s *Create_or_alter_functionContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Create_or_alter_functionContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_or_alter_functionContext) AllProcedure_param() []IProcedure_paramContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProcedure_paramContext); ok { + len++ + } + } + + tst := make([]IProcedure_paramContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProcedure_paramContext); ok { + tst[i] = t.(IProcedure_paramContext) + i++ + } + } + + return tst +} + +func (s *Create_or_alter_functionContext) Procedure_param(i int) IProcedure_paramContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_paramContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_paramContext) +} + +func (s *Create_or_alter_functionContext) OR() antlr.TerminalNode { + return s.GetToken(TSqlParserOR, 0) +} + +func (s *Create_or_alter_functionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_or_alter_functionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_or_alter_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_or_alter_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_or_alter_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_or_alter_function(s) + } +} + +func (s *Create_or_alter_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_or_alter_function(s) + } +} + +func (s *Create_or_alter_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_or_alter_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_or_alter_function() (localctx ICreate_or_alter_functionContext) { + localctx = NewCreate_or_alter_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 574, TSqlParserRULE_create_or_alter_function) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7535) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCREATE: + { + p.SetState(7529) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7532) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOR { + { + p.SetState(7530) + p.Match(TSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7531) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserALTER: + { + p.SetState(7534) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7537) + p.Match(TSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7538) + + var _x = p.Func_proc_name_schema() + + localctx.(*Create_or_alter_functionContext).funcName = _x + } + p.SetState(7552) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 950, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7539) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7540) + p.Procedure_param() + } + p.SetState(7545) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7541) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7542) + p.Procedure_param() + } + + p.SetState(7547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7548) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(7550) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7551) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(7557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 951, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7554) + p.Func_body_returns_select() + } + + case 2: + { + p.SetState(7555) + p.Func_body_returns_table() + } + + case 3: + { + p.SetState(7556) + p.Func_body_returns_scalar() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(7560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSEMI { + { + p.SetState(7559) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_body_returns_selectContext is an interface to support dynamic dispatch. +type IFunc_body_returns_selectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURNS() antlr.TerminalNode + TABLE() antlr.TerminalNode + As_external_name() IAs_external_nameContext + RETURN() antlr.TerminalNode + WITH() antlr.TerminalNode + AllFunction_option() []IFunction_optionContext + Function_option(i int) IFunction_optionContext + AS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Select_statement_standalone() ISelect_statement_standaloneContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunc_body_returns_selectContext differentiates from other interfaces. + IsFunc_body_returns_selectContext() +} + +type Func_body_returns_selectContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_body_returns_selectContext() *Func_body_returns_selectContext { + var p = new(Func_body_returns_selectContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_func_body_returns_select + return p +} + +func InitEmptyFunc_body_returns_selectContext(p *Func_body_returns_selectContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_func_body_returns_select +} + +func (*Func_body_returns_selectContext) IsFunc_body_returns_selectContext() {} + +func NewFunc_body_returns_selectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_body_returns_selectContext { + var p = new(Func_body_returns_selectContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_func_body_returns_select + + return p +} + +func (s *Func_body_returns_selectContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_body_returns_selectContext) RETURNS() antlr.TerminalNode { + return s.GetToken(TSqlParserRETURNS, 0) +} + +func (s *Func_body_returns_selectContext) TABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLE, 0) +} + +func (s *Func_body_returns_selectContext) As_external_name() IAs_external_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_external_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_external_nameContext) +} + +func (s *Func_body_returns_selectContext) RETURN() antlr.TerminalNode { + return s.GetToken(TSqlParserRETURN, 0) +} + +func (s *Func_body_returns_selectContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Func_body_returns_selectContext) AllFunction_option() []IFunction_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_optionContext); ok { + len++ + } + } + + tst := make([]IFunction_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_optionContext); ok { + tst[i] = t.(IFunction_optionContext) + i++ + } + } + + return tst +} + +func (s *Func_body_returns_selectContext) Function_option(i int) IFunction_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_optionContext) +} + +func (s *Func_body_returns_selectContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Func_body_returns_selectContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Func_body_returns_selectContext) Select_statement_standalone() ISelect_statement_standaloneContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statement_standaloneContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statement_standaloneContext) +} + +func (s *Func_body_returns_selectContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Func_body_returns_selectContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Func_body_returns_selectContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Func_body_returns_selectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_body_returns_selectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_body_returns_selectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFunc_body_returns_select(s) + } +} + +func (s *Func_body_returns_selectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFunc_body_returns_select(s) + } +} + +func (s *Func_body_returns_selectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFunc_body_returns_select(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Func_body_returns_select() (localctx IFunc_body_returns_selectContext) { + localctx = NewFunc_body_returns_selectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 576, TSqlParserRULE_func_body_returns_select) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7562) + p.Match(TSqlParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7563) + p.Match(TSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(7564) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7565) + p.Function_option() + } + p.SetState(7570) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7566) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7567) + p.Function_option() + } + + p.SetState(7572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(7576) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(7575) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserEXTERNAL: + { + p.SetState(7578) + p.As_external_name() + } + + case TSqlParserRETURN: + { + p.SetState(7579) + p.Match(TSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 956, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7580) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7581) + p.Select_statement_standalone() + } + { + p.SetState(7582) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(7584) + p.Select_statement_standalone() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_body_returns_tableContext is an interface to support dynamic dispatch. +type IFunc_body_returns_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURNS() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + Table_type_definition() ITable_type_definitionContext + As_external_name() IAs_external_nameContext + BEGIN() antlr.TerminalNode + RETURN() antlr.TerminalNode + END() antlr.TerminalNode + WITH() antlr.TerminalNode + AllFunction_option() []IFunction_optionContext + Function_option(i int) IFunction_optionContext + AS() antlr.TerminalNode + AllSql_clauses() []ISql_clausesContext + Sql_clauses(i int) ISql_clausesContext + AllSEMI() []antlr.TerminalNode + SEMI(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunc_body_returns_tableContext differentiates from other interfaces. + IsFunc_body_returns_tableContext() +} + +type Func_body_returns_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_body_returns_tableContext() *Func_body_returns_tableContext { + var p = new(Func_body_returns_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_func_body_returns_table + return p +} + +func InitEmptyFunc_body_returns_tableContext(p *Func_body_returns_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_func_body_returns_table +} + +func (*Func_body_returns_tableContext) IsFunc_body_returns_tableContext() {} + +func NewFunc_body_returns_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_body_returns_tableContext { + var p = new(Func_body_returns_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_func_body_returns_table + + return p +} + +func (s *Func_body_returns_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_body_returns_tableContext) RETURNS() antlr.TerminalNode { + return s.GetToken(TSqlParserRETURNS, 0) +} + +func (s *Func_body_returns_tableContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Func_body_returns_tableContext) Table_type_definition() ITable_type_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_type_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_type_definitionContext) +} + +func (s *Func_body_returns_tableContext) As_external_name() IAs_external_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_external_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_external_nameContext) +} + +func (s *Func_body_returns_tableContext) BEGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserBEGIN, 0) +} + +func (s *Func_body_returns_tableContext) RETURN() antlr.TerminalNode { + return s.GetToken(TSqlParserRETURN, 0) +} + +func (s *Func_body_returns_tableContext) END() antlr.TerminalNode { + return s.GetToken(TSqlParserEND, 0) +} + +func (s *Func_body_returns_tableContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Func_body_returns_tableContext) AllFunction_option() []IFunction_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_optionContext); ok { + len++ + } + } + + tst := make([]IFunction_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_optionContext); ok { + tst[i] = t.(IFunction_optionContext) + i++ + } + } + + return tst +} + +func (s *Func_body_returns_tableContext) Function_option(i int) IFunction_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_optionContext) +} + +func (s *Func_body_returns_tableContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Func_body_returns_tableContext) AllSql_clauses() []ISql_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_clausesContext); ok { + len++ + } + } + + tst := make([]ISql_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_clausesContext); ok { + tst[i] = t.(ISql_clausesContext) + i++ + } + } + + return tst +} + +func (s *Func_body_returns_tableContext) Sql_clauses(i int) ISql_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_clausesContext) +} + +func (s *Func_body_returns_tableContext) AllSEMI() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSEMI) +} + +func (s *Func_body_returns_tableContext) SEMI(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, i) +} + +func (s *Func_body_returns_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Func_body_returns_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Func_body_returns_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_body_returns_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_body_returns_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFunc_body_returns_table(s) + } +} + +func (s *Func_body_returns_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFunc_body_returns_table(s) + } +} + +func (s *Func_body_returns_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFunc_body_returns_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Func_body_returns_table() (localctx IFunc_body_returns_tableContext) { + localctx = NewFunc_body_returns_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 578, TSqlParserRULE_func_body_returns_table) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7589) + p.Match(TSqlParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7590) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7591) + p.Table_type_definition() + } + p.SetState(7601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(7592) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7593) + p.Function_option() + } + p.SetState(7598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7594) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7595) + p.Function_option() + } + + p.SetState(7600) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(7604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(7603) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7622) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserEXTERNAL: + { + p.SetState(7606) + p.As_external_name() + } + + case TSqlParserBEGIN: + { + p.SetState(7607) + p.Match(TSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 961, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7608) + p.Sql_clauses() + } + + } + p.SetState(7613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 961, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(7614) + p.Match(TSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSEMI { + { + p.SetState(7615) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7618) + p.Match(TSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7620) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 963, p.GetParserRuleContext()) == 1 { + { + p.SetState(7619) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_body_returns_scalarContext is an interface to support dynamic dispatch. +type IFunc_body_returns_scalarContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRet returns the ret rule contexts. + GetRet() IExpressionContext + + // SetRet sets the ret rule contexts. + SetRet(IExpressionContext) + + // Getter signatures + RETURNS() antlr.TerminalNode + Data_type() IData_typeContext + As_external_name() IAs_external_nameContext + BEGIN() antlr.TerminalNode + RETURN() antlr.TerminalNode + END() antlr.TerminalNode + WITH() antlr.TerminalNode + AllFunction_option() []IFunction_optionContext + Function_option(i int) IFunction_optionContext + AS() antlr.TerminalNode + Expression() IExpressionContext + AllSql_clauses() []ISql_clausesContext + Sql_clauses(i int) ISql_clausesContext + SEMI() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunc_body_returns_scalarContext differentiates from other interfaces. + IsFunc_body_returns_scalarContext() +} + +type Func_body_returns_scalarContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ret IExpressionContext +} + +func NewEmptyFunc_body_returns_scalarContext() *Func_body_returns_scalarContext { + var p = new(Func_body_returns_scalarContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_func_body_returns_scalar + return p +} + +func InitEmptyFunc_body_returns_scalarContext(p *Func_body_returns_scalarContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_func_body_returns_scalar +} + +func (*Func_body_returns_scalarContext) IsFunc_body_returns_scalarContext() {} + +func NewFunc_body_returns_scalarContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_body_returns_scalarContext { + var p = new(Func_body_returns_scalarContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_func_body_returns_scalar + + return p +} + +func (s *Func_body_returns_scalarContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_body_returns_scalarContext) GetRet() IExpressionContext { return s.ret } + +func (s *Func_body_returns_scalarContext) SetRet(v IExpressionContext) { s.ret = v } + +func (s *Func_body_returns_scalarContext) RETURNS() antlr.TerminalNode { + return s.GetToken(TSqlParserRETURNS, 0) +} + +func (s *Func_body_returns_scalarContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Func_body_returns_scalarContext) As_external_name() IAs_external_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_external_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_external_nameContext) +} + +func (s *Func_body_returns_scalarContext) BEGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserBEGIN, 0) +} + +func (s *Func_body_returns_scalarContext) RETURN() antlr.TerminalNode { + return s.GetToken(TSqlParserRETURN, 0) +} + +func (s *Func_body_returns_scalarContext) END() antlr.TerminalNode { + return s.GetToken(TSqlParserEND, 0) +} + +func (s *Func_body_returns_scalarContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Func_body_returns_scalarContext) AllFunction_option() []IFunction_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_optionContext); ok { + len++ + } + } + + tst := make([]IFunction_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_optionContext); ok { + tst[i] = t.(IFunction_optionContext) + i++ + } + } + + return tst +} + +func (s *Func_body_returns_scalarContext) Function_option(i int) IFunction_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_optionContext) +} + +func (s *Func_body_returns_scalarContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Func_body_returns_scalarContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Func_body_returns_scalarContext) AllSql_clauses() []ISql_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_clausesContext); ok { + len++ + } + } + + tst := make([]ISql_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_clausesContext); ok { + tst[i] = t.(ISql_clausesContext) + i++ + } + } + + return tst +} + +func (s *Func_body_returns_scalarContext) Sql_clauses(i int) ISql_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_clausesContext) +} + +func (s *Func_body_returns_scalarContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Func_body_returns_scalarContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Func_body_returns_scalarContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Func_body_returns_scalarContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_body_returns_scalarContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_body_returns_scalarContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFunc_body_returns_scalar(s) + } +} + +func (s *Func_body_returns_scalarContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFunc_body_returns_scalar(s) + } +} + +func (s *Func_body_returns_scalarContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFunc_body_returns_scalar(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Func_body_returns_scalar() (localctx IFunc_body_returns_scalarContext) { + localctx = NewFunc_body_returns_scalarContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 580, TSqlParserRULE_func_body_returns_scalar) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7624) + p.Match(TSqlParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7625) + p.Data_type() + } + p.SetState(7635) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(7626) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7627) + p.Function_option() + } + p.SetState(7632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7628) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7629) + p.Function_option() + } + + p.SetState(7634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(7638) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(7637) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserEXTERNAL: + { + p.SetState(7640) + p.As_external_name() + } + + case TSqlParserBEGIN: + { + p.SetState(7641) + p.Match(TSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7645) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 968, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7642) + p.Sql_clauses() + } + + } + p.SetState(7647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 968, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(7648) + p.Match(TSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7649) + + var _x = p.expression(0) + + localctx.(*Func_body_returns_scalarContext).ret = _x + } + p.SetState(7651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSEMI { + { + p.SetState(7650) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7653) + p.Match(TSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProcedure_param_default_valueContext is an interface to support dynamic dispatch. +type IProcedure_param_default_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + Constant() IConstantContext + LOCAL_ID() antlr.TerminalNode + + // IsProcedure_param_default_valueContext differentiates from other interfaces. + IsProcedure_param_default_valueContext() +} + +type Procedure_param_default_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_param_default_valueContext() *Procedure_param_default_valueContext { + var p = new(Procedure_param_default_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_procedure_param_default_value + return p +} + +func InitEmptyProcedure_param_default_valueContext(p *Procedure_param_default_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_procedure_param_default_value +} + +func (*Procedure_param_default_valueContext) IsProcedure_param_default_valueContext() {} + +func NewProcedure_param_default_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_param_default_valueContext { + var p = new(Procedure_param_default_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_procedure_param_default_value + + return p +} + +func (s *Procedure_param_default_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_param_default_valueContext) NULL_() antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_, 0) +} + +func (s *Procedure_param_default_valueContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Procedure_param_default_valueContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *Procedure_param_default_valueContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Procedure_param_default_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_param_default_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_param_default_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterProcedure_param_default_value(s) + } +} + +func (s *Procedure_param_default_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitProcedure_param_default_value(s) + } +} + +func (s *Procedure_param_default_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitProcedure_param_default_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Procedure_param_default_value() (localctx IProcedure_param_default_valueContext) { + localctx = NewProcedure_param_default_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 582, TSqlParserRULE_procedure_param_default_value) + p.SetState(7661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserNULL_: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7657) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDEFAULT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7658) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL, TSqlParserSTRING, TSqlParserBINARY, TSqlParserFLOAT, TSqlParserREAL, TSqlParserDOLLAR, TSqlParserMINUS, TSqlParserPLACEHOLDER: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7659) + p.Constant() + } + + case TSqlParserLOCAL_ID: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7660) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProcedure_paramContext is an interface to support dynamic dispatch. +type IProcedure_paramContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetType_schema returns the type_schema rule contexts. + GetType_schema() IId_Context + + // GetDefault_val returns the default_val rule contexts. + GetDefault_val() IProcedure_param_default_valueContext + + // SetType_schema sets the type_schema rule contexts. + SetType_schema(IId_Context) + + // SetDefault_val sets the default_val rule contexts. + SetDefault_val(IProcedure_param_default_valueContext) + + // Getter signatures + LOCAL_ID() antlr.TerminalNode + Data_type() IData_typeContext + AS() antlr.TerminalNode + DOT() antlr.TerminalNode + VARYING() antlr.TerminalNode + EQUAL() antlr.TerminalNode + Id_() IId_Context + Procedure_param_default_value() IProcedure_param_default_valueContext + OUT() antlr.TerminalNode + OUTPUT() antlr.TerminalNode + READONLY() antlr.TerminalNode + + // IsProcedure_paramContext differentiates from other interfaces. + IsProcedure_paramContext() +} + +type Procedure_paramContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + type_schema IId_Context + default_val IProcedure_param_default_valueContext +} + +func NewEmptyProcedure_paramContext() *Procedure_paramContext { + var p = new(Procedure_paramContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_procedure_param + return p +} + +func InitEmptyProcedure_paramContext(p *Procedure_paramContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_procedure_param +} + +func (*Procedure_paramContext) IsProcedure_paramContext() {} + +func NewProcedure_paramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_paramContext { + var p = new(Procedure_paramContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_procedure_param + + return p +} + +func (s *Procedure_paramContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_paramContext) GetType_schema() IId_Context { return s.type_schema } + +func (s *Procedure_paramContext) GetDefault_val() IProcedure_param_default_valueContext { + return s.default_val +} + +func (s *Procedure_paramContext) SetType_schema(v IId_Context) { s.type_schema = v } + +func (s *Procedure_paramContext) SetDefault_val(v IProcedure_param_default_valueContext) { + s.default_val = v +} + +func (s *Procedure_paramContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Procedure_paramContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Procedure_paramContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Procedure_paramContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Procedure_paramContext) VARYING() antlr.TerminalNode { + return s.GetToken(TSqlParserVARYING, 0) +} + +func (s *Procedure_paramContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Procedure_paramContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Procedure_paramContext) Procedure_param_default_value() IProcedure_param_default_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_param_default_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_param_default_valueContext) +} + +func (s *Procedure_paramContext) OUT() antlr.TerminalNode { + return s.GetToken(TSqlParserOUT, 0) +} + +func (s *Procedure_paramContext) OUTPUT() antlr.TerminalNode { + return s.GetToken(TSqlParserOUTPUT, 0) +} + +func (s *Procedure_paramContext) READONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserREADONLY, 0) +} + +func (s *Procedure_paramContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_paramContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_paramContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterProcedure_param(s) + } +} + +func (s *Procedure_paramContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitProcedure_param(s) + } +} + +func (s *Procedure_paramContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitProcedure_param(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Procedure_param() (localctx IProcedure_paramContext) { + localctx = NewProcedure_paramContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 584, TSqlParserRULE_procedure_param) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7663) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7665) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(7664) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7670) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 973, p.GetParserRuleContext()) == 1 { + { + p.SetState(7667) + + var _x = p.Id_() + + localctx.(*Procedure_paramContext).type_schema = _x + } + { + p.SetState(7668) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7672) + p.Data_type() + } + p.SetState(7674) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserVARYING { + { + p.SetState(7673) + p.Match(TSqlParserVARYING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7678) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserEQUAL { + { + p.SetState(7676) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7677) + + var _x = p.Procedure_param_default_value() + + localctx.(*Procedure_paramContext).default_val = _x + } + + } + p.SetState(7681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOUT || _la == TSqlParserOUTPUT || _la == TSqlParserREADONLY { + { + p.SetState(7680) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOUT || _la == TSqlParserOUTPUT || _la == TSqlParserREADONLY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProcedure_optionContext is an interface to support dynamic dispatch. +type IProcedure_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTION() antlr.TerminalNode + RECOMPILE() antlr.TerminalNode + Execute_clause() IExecute_clauseContext + + // IsProcedure_optionContext differentiates from other interfaces. + IsProcedure_optionContext() +} + +type Procedure_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_optionContext() *Procedure_optionContext { + var p = new(Procedure_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_procedure_option + return p +} + +func InitEmptyProcedure_optionContext(p *Procedure_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_procedure_option +} + +func (*Procedure_optionContext) IsProcedure_optionContext() {} + +func NewProcedure_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_optionContext { + var p = new(Procedure_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_procedure_option + + return p +} + +func (s *Procedure_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_optionContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Procedure_optionContext) RECOMPILE() antlr.TerminalNode { + return s.GetToken(TSqlParserRECOMPILE, 0) +} + +func (s *Procedure_optionContext) Execute_clause() IExecute_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_clauseContext) +} + +func (s *Procedure_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterProcedure_option(s) + } +} + +func (s *Procedure_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitProcedure_option(s) + } +} + +func (s *Procedure_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitProcedure_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Procedure_option() (localctx IProcedure_optionContext) { + localctx = NewProcedure_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 586, TSqlParserRULE_procedure_option) + p.SetState(7686) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserENCRYPTION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7683) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserRECOMPILE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7684) + p.Match(TSqlParserRECOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEXECUTE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7685) + p.Execute_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_optionContext is an interface to support dynamic dispatch. +type IFunction_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTION() antlr.TerminalNode + SCHEMABINDING() antlr.TerminalNode + RETURNS() antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + ON() antlr.TerminalNode + INPUT() antlr.TerminalNode + CALLED() antlr.TerminalNode + Execute_clause() IExecute_clauseContext + + // IsFunction_optionContext differentiates from other interfaces. + IsFunction_optionContext() +} + +type Function_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_optionContext() *Function_optionContext { + var p = new(Function_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_function_option + return p +} + +func InitEmptyFunction_optionContext(p *Function_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_function_option +} + +func (*Function_optionContext) IsFunction_optionContext() {} + +func NewFunction_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_optionContext { + var p = new(Function_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_function_option + + return p +} + +func (s *Function_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_optionContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Function_optionContext) SCHEMABINDING() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMABINDING, 0) +} + +func (s *Function_optionContext) RETURNS() antlr.TerminalNode { + return s.GetToken(TSqlParserRETURNS, 0) +} + +func (s *Function_optionContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNULL_) +} + +func (s *Function_optionContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_, i) +} + +func (s *Function_optionContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Function_optionContext) INPUT() antlr.TerminalNode { + return s.GetToken(TSqlParserINPUT, 0) +} + +func (s *Function_optionContext) CALLED() antlr.TerminalNode { + return s.GetToken(TSqlParserCALLED, 0) +} + +func (s *Function_optionContext) Execute_clause() IExecute_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_clauseContext) +} + +func (s *Function_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFunction_option(s) + } +} + +func (s *Function_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFunction_option(s) + } +} + +func (s *Function_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFunction_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Function_option() (localctx IFunction_optionContext) { + localctx = NewFunction_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 588, TSqlParserRULE_function_option) + p.SetState(7700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserENCRYPTION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7688) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSCHEMABINDING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7689) + p.Match(TSqlParserSCHEMABINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserRETURNS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7690) + p.Match(TSqlParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7691) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7692) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7693) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7694) + p.Match(TSqlParserINPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCALLED: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7695) + p.Match(TSqlParserCALLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7696) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7697) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7698) + p.Match(TSqlParserINPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEXECUTE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7699) + p.Execute_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_statisticsContext is an interface to support dynamic dispatch. +type ICreate_statisticsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + Id_() IId_Context + ON() antlr.TerminalNode + Table_name() ITable_nameContext + LR_BRACKET() antlr.TerminalNode + Column_name_list() IColumn_name_listContext + RR_BRACKET() antlr.TerminalNode + WITH() antlr.TerminalNode + SEMI() antlr.TerminalNode + FULLSCAN() antlr.TerminalNode + SAMPLE() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + STATS_STREAM() antlr.TerminalNode + PERCENT() antlr.TerminalNode + ROWS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + NORECOMPUTE() antlr.TerminalNode + INCREMENTAL() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + + // IsCreate_statisticsContext differentiates from other interfaces. + IsCreate_statisticsContext() +} + +type Create_statisticsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_statisticsContext() *Create_statisticsContext { + var p = new(Create_statisticsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_statistics + return p +} + +func InitEmptyCreate_statisticsContext(p *Create_statisticsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_statistics +} + +func (*Create_statisticsContext) IsCreate_statisticsContext() {} + +func NewCreate_statisticsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_statisticsContext { + var p = new(Create_statisticsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_statistics + + return p +} + +func (s *Create_statisticsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_statisticsContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_statisticsContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS, 0) +} + +func (s *Create_statisticsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_statisticsContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Create_statisticsContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Create_statisticsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_statisticsContext) Column_name_list() IColumn_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Create_statisticsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_statisticsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_statisticsContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Create_statisticsContext) FULLSCAN() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLSCAN, 0) +} + +func (s *Create_statisticsContext) SAMPLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSAMPLE, 0) +} + +func (s *Create_statisticsContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Create_statisticsContext) STATS_STREAM() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATS_STREAM, 0) +} + +func (s *Create_statisticsContext) PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserPERCENT, 0) +} + +func (s *Create_statisticsContext) ROWS() antlr.TerminalNode { + return s.GetToken(TSqlParserROWS, 0) +} + +func (s *Create_statisticsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_statisticsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_statisticsContext) NORECOMPUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserNORECOMPUTE, 0) +} + +func (s *Create_statisticsContext) INCREMENTAL() antlr.TerminalNode { + return s.GetToken(TSqlParserINCREMENTAL, 0) +} + +func (s *Create_statisticsContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_statisticsContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Create_statisticsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_statisticsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_statisticsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_statistics(s) + } +} + +func (s *Create_statisticsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_statistics(s) + } +} + +func (s *Create_statisticsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_statistics(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_statistics() (localctx ICreate_statisticsContext) { + localctx = NewCreate_statisticsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 590, TSqlParserRULE_create_statistics) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7702) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7703) + p.Match(TSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7704) + p.Id_() + } + { + p.SetState(7705) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7706) + p.Table_name() + } + { + p.SetState(7707) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7708) + p.Column_name_list() + } + { + p.SetState(7709) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7728) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 982, p.GetParserRuleContext()) == 1 { + { + p.SetState(7710) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7716) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFULLSCAN: + { + p.SetState(7711) + p.Match(TSqlParserFULLSCAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSAMPLE: + { + p.SetState(7712) + p.Match(TSqlParserSAMPLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7713) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7714) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserPERCENT || _la == TSqlParserROWS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserSTATS_STREAM: + { + p.SetState(7715) + p.Match(TSqlParserSTATS_STREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(7720) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 980, p.GetParserRuleContext()) == 1 { + { + p.SetState(7718) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7719) + p.Match(TSqlParserNORECOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7726) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(7722) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7723) + p.Match(TSqlParserINCREMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7724) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7725) + p.On_off() + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7731) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 983, p.GetParserRuleContext()) == 1 { + { + p.SetState(7730) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_statisticsContext is an interface to support dynamic dispatch. +type IUpdate_statisticsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPDATE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + Full_table_name() IFull_table_nameContext + AllId_() []IId_Context + Id_(i int) IId_Context + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Update_statistics_options() IUpdate_statistics_optionsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUpdate_statisticsContext differentiates from other interfaces. + IsUpdate_statisticsContext() +} + +type Update_statisticsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_statisticsContext() *Update_statisticsContext { + var p = new(Update_statisticsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_update_statistics + return p +} + +func InitEmptyUpdate_statisticsContext(p *Update_statisticsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_update_statistics +} + +func (*Update_statisticsContext) IsUpdate_statisticsContext() {} + +func NewUpdate_statisticsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_statisticsContext { + var p = new(Update_statisticsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_update_statistics + + return p +} + +func (s *Update_statisticsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_statisticsContext) UPDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserUPDATE, 0) +} + +func (s *Update_statisticsContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS, 0) +} + +func (s *Update_statisticsContext) Full_table_name() IFull_table_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_table_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_table_nameContext) +} + +func (s *Update_statisticsContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Update_statisticsContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Update_statisticsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Update_statisticsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Update_statisticsContext) Update_statistics_options() IUpdate_statistics_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_statistics_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_statistics_optionsContext) +} + +func (s *Update_statisticsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Update_statisticsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Update_statisticsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_statisticsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_statisticsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUpdate_statistics(s) + } +} + +func (s *Update_statisticsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUpdate_statistics(s) + } +} + +func (s *Update_statisticsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUpdate_statistics(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Update_statistics() (localctx IUpdate_statisticsContext) { + localctx = NewUpdate_statisticsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 592, TSqlParserRULE_update_statistics) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7733) + p.Match(TSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7734) + p.Match(TSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7735) + p.Full_table_name() + } + p.SetState(7748) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 985, p.GetParserRuleContext()) == 1 { + { + p.SetState(7736) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 985, p.GetParserRuleContext()) == 2 { + { + p.SetState(7737) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7738) + p.Id_() + } + p.SetState(7743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7739) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7740) + p.Id_() + } + + p.SetState(7745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7746) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7751) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 986, p.GetParserRuleContext()) == 1 { + { + p.SetState(7750) + p.Update_statistics_options() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_statistics_optionsContext is an interface to support dynamic dispatch. +type IUpdate_statistics_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + AllUpdate_statistics_option() []IUpdate_statistics_optionContext + Update_statistics_option(i int) IUpdate_statistics_optionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUpdate_statistics_optionsContext differentiates from other interfaces. + IsUpdate_statistics_optionsContext() +} + +type Update_statistics_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_statistics_optionsContext() *Update_statistics_optionsContext { + var p = new(Update_statistics_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_update_statistics_options + return p +} + +func InitEmptyUpdate_statistics_optionsContext(p *Update_statistics_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_update_statistics_options +} + +func (*Update_statistics_optionsContext) IsUpdate_statistics_optionsContext() {} + +func NewUpdate_statistics_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_statistics_optionsContext { + var p = new(Update_statistics_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_update_statistics_options + + return p +} + +func (s *Update_statistics_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_statistics_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Update_statistics_optionsContext) AllUpdate_statistics_option() []IUpdate_statistics_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdate_statistics_optionContext); ok { + len++ + } + } + + tst := make([]IUpdate_statistics_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdate_statistics_optionContext); ok { + tst[i] = t.(IUpdate_statistics_optionContext) + i++ + } + } + + return tst +} + +func (s *Update_statistics_optionsContext) Update_statistics_option(i int) IUpdate_statistics_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_statistics_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_statistics_optionContext) +} + +func (s *Update_statistics_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Update_statistics_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Update_statistics_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_statistics_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_statistics_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUpdate_statistics_options(s) + } +} + +func (s *Update_statistics_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUpdate_statistics_options(s) + } +} + +func (s *Update_statistics_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUpdate_statistics_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Update_statistics_options() (localctx IUpdate_statistics_optionsContext) { + localctx = NewUpdate_statistics_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 594, TSqlParserRULE_update_statistics_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7753) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7754) + p.Update_statistics_option() + } + p.SetState(7759) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7755) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7756) + p.Update_statistics_option() + } + + p.SetState(7761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_statistics_optionContext is an interface to support dynamic dispatch. +type IUpdate_statistics_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNumber returns the number token. + GetNumber() antlr.Token + + // GetMax_dregree_of_parallelism returns the max_dregree_of_parallelism token. + GetMax_dregree_of_parallelism() antlr.Token + + // SetNumber sets the number token. + SetNumber(antlr.Token) + + // SetMax_dregree_of_parallelism sets the max_dregree_of_parallelism token. + SetMax_dregree_of_parallelism(antlr.Token) + + // GetStats_stream_ returns the stats_stream_ rule contexts. + GetStats_stream_() IExpressionContext + + // SetStats_stream_ sets the stats_stream_ rule contexts. + SetStats_stream_(IExpressionContext) + + // Getter signatures + FULLSCAN() antlr.TerminalNode + PERSIST_SAMPLE_PERCENT() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + COMMA() antlr.TerminalNode + SAMPLE() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + PERCENT() antlr.TerminalNode + ROWS() antlr.TerminalNode + RESAMPLE() antlr.TerminalNode + On_partitions() IOn_partitionsContext + STATS_STREAM() antlr.TerminalNode + Expression() IExpressionContext + ROWCOUNT() antlr.TerminalNode + PAGECOUNT() antlr.TerminalNode + ALL() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + INDEX() antlr.TerminalNode + NORECOMPUTE() antlr.TerminalNode + INCREMENTAL() antlr.TerminalNode + MAXDOP() antlr.TerminalNode + AUTO_DROP() antlr.TerminalNode + + // IsUpdate_statistics_optionContext differentiates from other interfaces. + IsUpdate_statistics_optionContext() +} + +type Update_statistics_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + number antlr.Token + stats_stream_ IExpressionContext + max_dregree_of_parallelism antlr.Token +} + +func NewEmptyUpdate_statistics_optionContext() *Update_statistics_optionContext { + var p = new(Update_statistics_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_update_statistics_option + return p +} + +func InitEmptyUpdate_statistics_optionContext(p *Update_statistics_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_update_statistics_option +} + +func (*Update_statistics_optionContext) IsUpdate_statistics_optionContext() {} + +func NewUpdate_statistics_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_statistics_optionContext { + var p = new(Update_statistics_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_update_statistics_option + + return p +} + +func (s *Update_statistics_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_statistics_optionContext) GetNumber() antlr.Token { return s.number } + +func (s *Update_statistics_optionContext) GetMax_dregree_of_parallelism() antlr.Token { + return s.max_dregree_of_parallelism +} + +func (s *Update_statistics_optionContext) SetNumber(v antlr.Token) { s.number = v } + +func (s *Update_statistics_optionContext) SetMax_dregree_of_parallelism(v antlr.Token) { + s.max_dregree_of_parallelism = v +} + +func (s *Update_statistics_optionContext) GetStats_stream_() IExpressionContext { + return s.stats_stream_ +} + +func (s *Update_statistics_optionContext) SetStats_stream_(v IExpressionContext) { s.stats_stream_ = v } + +func (s *Update_statistics_optionContext) FULLSCAN() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLSCAN, 0) +} + +func (s *Update_statistics_optionContext) PERSIST_SAMPLE_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserPERSIST_SAMPLE_PERCENT, 0) +} + +func (s *Update_statistics_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Update_statistics_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Update_statistics_optionContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Update_statistics_optionContext) SAMPLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSAMPLE, 0) +} + +func (s *Update_statistics_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Update_statistics_optionContext) PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserPERCENT, 0) +} + +func (s *Update_statistics_optionContext) ROWS() antlr.TerminalNode { + return s.GetToken(TSqlParserROWS, 0) +} + +func (s *Update_statistics_optionContext) RESAMPLE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESAMPLE, 0) +} + +func (s *Update_statistics_optionContext) On_partitions() IOn_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_partitionsContext) +} + +func (s *Update_statistics_optionContext) STATS_STREAM() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATS_STREAM, 0) +} + +func (s *Update_statistics_optionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Update_statistics_optionContext) ROWCOUNT() antlr.TerminalNode { + return s.GetToken(TSqlParserROWCOUNT, 0) +} + +func (s *Update_statistics_optionContext) PAGECOUNT() antlr.TerminalNode { + return s.GetToken(TSqlParserPAGECOUNT, 0) +} + +func (s *Update_statistics_optionContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Update_statistics_optionContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNS, 0) +} + +func (s *Update_statistics_optionContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Update_statistics_optionContext) NORECOMPUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserNORECOMPUTE, 0) +} + +func (s *Update_statistics_optionContext) INCREMENTAL() antlr.TerminalNode { + return s.GetToken(TSqlParserINCREMENTAL, 0) +} + +func (s *Update_statistics_optionContext) MAXDOP() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXDOP, 0) +} + +func (s *Update_statistics_optionContext) AUTO_DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_DROP, 0) +} + +func (s *Update_statistics_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_statistics_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_statistics_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUpdate_statistics_option(s) + } +} + +func (s *Update_statistics_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUpdate_statistics_option(s) + } +} + +func (s *Update_statistics_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUpdate_statistics_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Update_statistics_option() (localctx IUpdate_statistics_optionContext) { + localctx = NewUpdate_statistics_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 596, TSqlParserRULE_update_statistics_option) + var _la int + + p.SetState(7808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFULLSCAN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7762) + p.Match(TSqlParserFULLSCAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7769) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 989, p.GetParserRuleContext()) == 1 { + p.SetState(7764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(7763) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7766) + p.Match(TSqlParserPERSIST_SAMPLE_PERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7767) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7768) + p.On_off() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserSAMPLE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7771) + p.Match(TSqlParserSAMPLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7772) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Update_statistics_optionContext).number = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7773) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserPERCENT || _la == TSqlParserROWS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(7780) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 991, p.GetParserRuleContext()) == 1 { + p.SetState(7775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(7774) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7777) + p.Match(TSqlParserPERSIST_SAMPLE_PERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7778) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7779) + p.On_off() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserRESAMPLE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7782) + p.Match(TSqlParserRESAMPLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(7783) + p.On_partitions() + } + + } + + case TSqlParserSTATS_STREAM: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7786) + p.Match(TSqlParserSTATS_STREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7787) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7788) + + var _x = p.expression(0) + + localctx.(*Update_statistics_optionContext).stats_stream_ = _x + } + + case TSqlParserROWCOUNT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7789) + p.Match(TSqlParserROWCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7790) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7791) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPAGECOUNT: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7792) + p.Match(TSqlParserPAGECOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7793) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7794) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserALL: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7795) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCOLUMNS: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(7796) + p.Match(TSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserINDEX: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(7797) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNORECOMPUTE: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(7798) + p.Match(TSqlParserNORECOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserINCREMENTAL: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(7799) + p.Match(TSqlParserINCREMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7800) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7801) + p.On_off() + } + + case TSqlParserMAXDOP: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(7802) + p.Match(TSqlParserMAXDOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7803) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7804) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Update_statistics_optionContext).max_dregree_of_parallelism = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserAUTO_DROP: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(7805) + p.Match(TSqlParserAUTO_DROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7806) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7807) + p.On_off() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_tableContext is an interface to support dynamic dispatch. +type ICreate_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TABLE() antlr.TerminalNode + Table_name() ITable_nameContext + LR_BRACKET() antlr.TerminalNode + Column_def_table_constraints() IColumn_def_table_constraintsContext + RR_BRACKET() antlr.TerminalNode + AllTable_indices() []ITable_indicesContext + Table_indices(i int) ITable_indicesContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + LOCK() antlr.TerminalNode + Simple_id() ISimple_idContext + AllTable_options() []ITable_optionsContext + Table_options(i int) ITable_optionsContext + ON() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + On_partition_or_filegroup() IOn_partition_or_filegroupContext + TEXTIMAGE_ON() antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsCreate_tableContext differentiates from other interfaces. + IsCreate_tableContext() +} + +type Create_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_tableContext() *Create_tableContext { + var p = new(Create_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_table + return p +} + +func InitEmptyCreate_tableContext(p *Create_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_table +} + +func (*Create_tableContext) IsCreate_tableContext() {} + +func NewCreate_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_tableContext { + var p = new(Create_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_table + + return p +} + +func (s *Create_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_tableContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLE, 0) +} + +func (s *Create_tableContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Create_tableContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_tableContext) Column_def_table_constraints() IColumn_def_table_constraintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_def_table_constraintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_def_table_constraintsContext) +} + +func (s *Create_tableContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_tableContext) AllTable_indices() []ITable_indicesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_indicesContext); ok { + len++ + } + } + + tst := make([]ITable_indicesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_indicesContext); ok { + tst[i] = t.(ITable_indicesContext) + i++ + } + } + + return tst +} + +func (s *Create_tableContext) Table_indices(i int) ITable_indicesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_indicesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_indicesContext) +} + +func (s *Create_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_tableContext) LOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCK, 0) +} + +func (s *Create_tableContext) Simple_id() ISimple_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimple_idContext) +} + +func (s *Create_tableContext) AllTable_options() []ITable_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_optionsContext); ok { + len++ + } + } + + tst := make([]ITable_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_optionsContext); ok { + tst[i] = t.(ITable_optionsContext) + i++ + } + } + + return tst +} + +func (s *Create_tableContext) Table_options(i int) ITable_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_optionsContext) +} + +func (s *Create_tableContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Create_tableContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_tableContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_tableContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDEFAULT) +} + +func (s *Create_tableContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, i) +} + +func (s *Create_tableContext) On_partition_or_filegroup() IOn_partition_or_filegroupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_partition_or_filegroupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_partition_or_filegroupContext) +} + +func (s *Create_tableContext) TEXTIMAGE_ON() antlr.TerminalNode { + return s.GetToken(TSqlParserTEXTIMAGE_ON, 0) +} + +func (s *Create_tableContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Create_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_table(s) + } +} + +func (s *Create_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_table(s) + } +} + +func (s *Create_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_table() (localctx ICreate_tableContext) { + localctx = NewCreate_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 598, TSqlParserRULE_create_table) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7810) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7811) + p.Match(TSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7812) + p.Table_name() + } + { + p.SetState(7813) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7814) + p.Column_def_table_constraints() + } + p.SetState(7821) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 995, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(7816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(7815) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7818) + p.Table_indices() + } + + } + p.SetState(7823) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 995, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(7825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(7824) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7827) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7830) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 997, p.GetParserRuleContext()) == 1 { + { + p.SetState(7828) + p.Match(TSqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7829) + p.Simple_id() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7835) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 998, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7832) + p.Table_options() + } + + } + p.SetState(7837) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 998, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(7842) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 999, p.GetParserRuleContext()) == 1 { + { + p.SetState(7838) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7839) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 999, p.GetParserRuleContext()) == 2 { + { + p.SetState(7840) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 999, p.GetParserRuleContext()) == 3 { + { + p.SetState(7841) + p.On_partition_or_filegroup() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7847) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1000, p.GetParserRuleContext()) == 1 { + { + p.SetState(7844) + p.Match(TSqlParserTEXTIMAGE_ON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7845) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1000, p.GetParserRuleContext()) == 2 { + { + p.SetState(7846) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7850) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1001, p.GetParserRuleContext()) == 1 { + { + p.SetState(7849) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_indicesContext is an interface to support dynamic dispatch. +type ITable_indicesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INDEX() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + LR_BRACKET() antlr.TerminalNode + Column_name_list_with_order() IColumn_name_list_with_orderContext + RR_BRACKET() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + Clustered() IClusteredContext + CLUSTERED() antlr.TerminalNode + COLUMNSTORE() antlr.TerminalNode + Column_name_list() IColumn_name_listContext + NONCLUSTERED() antlr.TerminalNode + Create_table_index_options() ICreate_table_index_optionsContext + ON() antlr.TerminalNode + + // IsTable_indicesContext differentiates from other interfaces. + IsTable_indicesContext() +} + +type Table_indicesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_indicesContext() *Table_indicesContext { + var p = new(Table_indicesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_indices + return p +} + +func InitEmptyTable_indicesContext(p *Table_indicesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_indices +} + +func (*Table_indicesContext) IsTable_indicesContext() {} + +func NewTable_indicesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_indicesContext { + var p = new(Table_indicesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_table_indices + + return p +} + +func (s *Table_indicesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_indicesContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Table_indicesContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Table_indicesContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Table_indicesContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Table_indicesContext) Column_name_list_with_order() IColumn_name_list_with_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_list_with_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_list_with_orderContext) +} + +func (s *Table_indicesContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Table_indicesContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(TSqlParserUNIQUE, 0) +} + +func (s *Table_indicesContext) Clustered() IClusteredContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClusteredContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClusteredContext) +} + +func (s *Table_indicesContext) CLUSTERED() antlr.TerminalNode { + return s.GetToken(TSqlParserCLUSTERED, 0) +} + +func (s *Table_indicesContext) COLUMNSTORE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE, 0) +} + +func (s *Table_indicesContext) Column_name_list() IColumn_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Table_indicesContext) NONCLUSTERED() antlr.TerminalNode { + return s.GetToken(TSqlParserNONCLUSTERED, 0) +} + +func (s *Table_indicesContext) Create_table_index_options() ICreate_table_index_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_table_index_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_table_index_optionsContext) +} + +func (s *Table_indicesContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Table_indicesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_indicesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_indicesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTable_indices(s) + } +} + +func (s *Table_indicesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTable_indices(s) + } +} + +func (s *Table_indicesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTable_indices(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Table_indices() (localctx ITable_indicesContext) { + localctx = NewTable_indicesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 600, TSqlParserRULE_table_indices) + var _la int + + p.SetState(7885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1007, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7852) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7853) + p.Id_() + } + p.SetState(7855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserUNIQUE { + { + p.SetState(7854) + p.Match(TSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7858) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCLUSTERED || _la == TSqlParserNONCLUSTERED { + { + p.SetState(7857) + p.Clustered() + } + + } + { + p.SetState(7860) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7861) + p.Column_name_list_with_order() + } + { + p.SetState(7862) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7864) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7865) + p.Id_() + } + { + p.SetState(7866) + p.Match(TSqlParserCLUSTERED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7867) + p.Match(TSqlParserCOLUMNSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7869) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7870) + p.Id_() + } + p.SetState(7872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserNONCLUSTERED { + { + p.SetState(7871) + p.Match(TSqlParserNONCLUSTERED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7874) + p.Match(TSqlParserCOLUMNSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7875) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7876) + p.Column_name_list() + } + { + p.SetState(7877) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7879) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(7878) + p.Create_table_index_options() + } + + } + p.SetState(7883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(7881) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7882) + p.Id_() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_optionsContext is an interface to support dynamic dispatch. +type ITable_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllTable_option() []ITable_optionContext + Table_option(i int) ITable_optionContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTable_optionsContext differentiates from other interfaces. + IsTable_optionsContext() +} + +type Table_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_optionsContext() *Table_optionsContext { + var p = new(Table_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_options + return p +} + +func InitEmptyTable_optionsContext(p *Table_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_options +} + +func (*Table_optionsContext) IsTable_optionsContext() {} + +func NewTable_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_optionsContext { + var p = new(Table_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_table_options + + return p +} + +func (s *Table_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Table_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Table_optionsContext) AllTable_option() []ITable_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_optionContext); ok { + len++ + } + } + + tst := make([]ITable_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_optionContext); ok { + tst[i] = t.(ITable_optionContext) + i++ + } + } + + return tst +} + +func (s *Table_optionsContext) Table_option(i int) ITable_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_optionContext) +} + +func (s *Table_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Table_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Table_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Table_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTable_options(s) + } +} + +func (s *Table_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTable_options(s) + } +} + +func (s *Table_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTable_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Table_options() (localctx ITable_optionsContext) { + localctx = NewTable_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 602, TSqlParserRULE_table_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7887) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7907) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLR_BRACKET: + { + p.SetState(7888) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7889) + p.Table_option() + } + p.SetState(7894) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7890) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7891) + p.Table_option() + } + + p.SetState(7896) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7897) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCLUSTERED, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILLFACTOR, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserID: + { + p.SetState(7899) + p.Table_option() + } + p.SetState(7904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7900) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7901) + p.Table_option() + } + + p.SetState(7906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_optionContext is an interface to support dynamic dispatch. +type ITable_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQUAL() antlr.TerminalNode + AllSimple_id() []ISimple_idContext + Simple_id(i int) ISimple_idContext + AllKeyword() []IKeywordContext + Keyword(i int) IKeywordContext + On_off() IOn_offContext + DECIMAL() antlr.TerminalNode + CLUSTERED() antlr.TerminalNode + COLUMNSTORE() antlr.TerminalNode + INDEX() antlr.TerminalNode + HEAP() antlr.TerminalNode + FILLFACTOR() antlr.TerminalNode + DISTRIBUTION() antlr.TerminalNode + HASH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllASC() []antlr.TerminalNode + ASC(i int) antlr.TerminalNode + AllDESC() []antlr.TerminalNode + DESC(i int) antlr.TerminalNode + DATA_COMPRESSION() antlr.TerminalNode + NONE() antlr.TerminalNode + ROW() antlr.TerminalNode + PAGE() antlr.TerminalNode + On_partitions() IOn_partitionsContext + XML_COMPRESSION() antlr.TerminalNode + + // IsTable_optionContext differentiates from other interfaces. + IsTable_optionContext() +} + +type Table_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_optionContext() *Table_optionContext { + var p = new(Table_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_option + return p +} + +func InitEmptyTable_optionContext(p *Table_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_option +} + +func (*Table_optionContext) IsTable_optionContext() {} + +func NewTable_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_optionContext { + var p = new(Table_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_table_option + + return p +} + +func (s *Table_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Table_optionContext) AllSimple_id() []ISimple_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISimple_idContext); ok { + len++ + } + } + + tst := make([]ISimple_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISimple_idContext); ok { + tst[i] = t.(ISimple_idContext) + i++ + } + } + + return tst +} + +func (s *Table_optionContext) Simple_id(i int) ISimple_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISimple_idContext) +} + +func (s *Table_optionContext) AllKeyword() []IKeywordContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKeywordContext); ok { + len++ + } + } + + tst := make([]IKeywordContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKeywordContext); ok { + tst[i] = t.(IKeywordContext) + i++ + } + } + + return tst +} + +func (s *Table_optionContext) Keyword(i int) IKeywordContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeywordContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKeywordContext) +} + +func (s *Table_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Table_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Table_optionContext) CLUSTERED() antlr.TerminalNode { + return s.GetToken(TSqlParserCLUSTERED, 0) +} + +func (s *Table_optionContext) COLUMNSTORE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE, 0) +} + +func (s *Table_optionContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Table_optionContext) HEAP() antlr.TerminalNode { + return s.GetToken(TSqlParserHEAP, 0) +} + +func (s *Table_optionContext) FILLFACTOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFILLFACTOR, 0) +} + +func (s *Table_optionContext) DISTRIBUTION() antlr.TerminalNode { + return s.GetToken(TSqlParserDISTRIBUTION, 0) +} + +func (s *Table_optionContext) HASH() antlr.TerminalNode { + return s.GetToken(TSqlParserHASH, 0) +} + +func (s *Table_optionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Table_optionContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Table_optionContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Table_optionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Table_optionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Table_optionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Table_optionContext) AllASC() []antlr.TerminalNode { + return s.GetTokens(TSqlParserASC) +} + +func (s *Table_optionContext) ASC(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserASC, i) +} + +func (s *Table_optionContext) AllDESC() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDESC) +} + +func (s *Table_optionContext) DESC(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDESC, i) +} + +func (s *Table_optionContext) DATA_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA_COMPRESSION, 0) +} + +func (s *Table_optionContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Table_optionContext) ROW() antlr.TerminalNode { + return s.GetToken(TSqlParserROW, 0) +} + +func (s *Table_optionContext) PAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserPAGE, 0) +} + +func (s *Table_optionContext) On_partitions() IOn_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_partitionsContext) +} + +func (s *Table_optionContext) XML_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserXML_COMPRESSION, 0) +} + +func (s *Table_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTable_option(s) + } +} + +func (s *Table_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTable_option(s) + } +} + +func (s *Table_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTable_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Table_option() (localctx ITable_optionContext) { + localctx = NewTable_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 604, TSqlParserRULE_table_option) + var _la int + + p.SetState(7965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1018, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(7911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserID: + { + p.SetState(7909) + p.Simple_id() + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR: + { + p.SetState(7910) + p.Keyword() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7913) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserID: + { + p.SetState(7914) + p.Simple_id() + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR: + { + p.SetState(7915) + p.Keyword() + } + + case TSqlParserOFF, TSqlParserON: + { + p.SetState(7916) + p.On_off() + } + + case TSqlParserDECIMAL: + { + p.SetState(7917) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7920) + p.Match(TSqlParserCLUSTERED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7921) + p.Match(TSqlParserCOLUMNSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7922) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7923) + p.Match(TSqlParserHEAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7924) + p.Match(TSqlParserFILLFACTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7925) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7926) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7927) + p.Match(TSqlParserDISTRIBUTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7928) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7929) + p.Match(TSqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7930) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7931) + p.Id_() + } + { + p.SetState(7932) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7934) + p.Match(TSqlParserCLUSTERED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7935) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7936) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7937) + p.Id_() + } + p.SetState(7939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserASC || _la == TSqlParserDESC { + { + p.SetState(7938) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserASC || _la == TSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(7948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7941) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7942) + p.Id_() + } + p.SetState(7944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserASC || _la == TSqlParserDESC { + { + p.SetState(7943) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserASC || _la == TSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + p.SetState(7950) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7951) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7953) + p.Match(TSqlParserDATA_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7954) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7955) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNONE || _la == TSqlParserPAGE || _la == TSqlParserROW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(7957) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1016, p.GetParserRuleContext()) == 1 { + { + p.SetState(7956) + p.On_partitions() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(7959) + p.Match(TSqlParserXML_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7960) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7961) + p.On_off() + } + p.SetState(7963) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1017, p.GetParserRuleContext()) == 1 { + { + p.SetState(7962) + p.On_partitions() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_table_index_optionsContext is an interface to support dynamic dispatch. +type ICreate_table_index_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllCreate_table_index_option() []ICreate_table_index_optionContext + Create_table_index_option(i int) ICreate_table_index_optionContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_table_index_optionsContext differentiates from other interfaces. + IsCreate_table_index_optionsContext() +} + +type Create_table_index_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_table_index_optionsContext() *Create_table_index_optionsContext { + var p = new(Create_table_index_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_table_index_options + return p +} + +func InitEmptyCreate_table_index_optionsContext(p *Create_table_index_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_table_index_options +} + +func (*Create_table_index_optionsContext) IsCreate_table_index_optionsContext() {} + +func NewCreate_table_index_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_table_index_optionsContext { + var p = new(Create_table_index_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_table_index_options + + return p +} + +func (s *Create_table_index_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_table_index_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_table_index_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_table_index_optionsContext) AllCreate_table_index_option() []ICreate_table_index_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreate_table_index_optionContext); ok { + len++ + } + } + + tst := make([]ICreate_table_index_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreate_table_index_optionContext); ok { + tst[i] = t.(ICreate_table_index_optionContext) + i++ + } + } + + return tst +} + +func (s *Create_table_index_optionsContext) Create_table_index_option(i int) ICreate_table_index_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_table_index_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreate_table_index_optionContext) +} + +func (s *Create_table_index_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_table_index_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_table_index_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_table_index_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_table_index_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_table_index_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_table_index_options(s) + } +} + +func (s *Create_table_index_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_table_index_options(s) + } +} + +func (s *Create_table_index_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_table_index_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_table_index_options() (localctx ICreate_table_index_optionsContext) { + localctx = NewCreate_table_index_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 606, TSqlParserRULE_create_table_index_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7967) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7968) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7969) + p.Create_table_index_option() + } + p.SetState(7974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(7970) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7971) + p.Create_table_index_option() + } + + p.SetState(7976) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7977) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_table_index_optionContext is an interface to support dynamic dispatch. +type ICreate_table_index_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PAD_INDEX() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + FILLFACTOR() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + IGNORE_DUP_KEY() antlr.TerminalNode + STATISTICS_NORECOMPUTE() antlr.TerminalNode + STATISTICS_INCREMENTAL() antlr.TerminalNode + ALLOW_ROW_LOCKS() antlr.TerminalNode + ALLOW_PAGE_LOCKS() antlr.TerminalNode + OPTIMIZE_FOR_SEQUENTIAL_KEY() antlr.TerminalNode + DATA_COMPRESSION() antlr.TerminalNode + NONE() antlr.TerminalNode + ROW() antlr.TerminalNode + PAGE() antlr.TerminalNode + COLUMNSTORE() antlr.TerminalNode + COLUMNSTORE_ARCHIVE() antlr.TerminalNode + On_partitions() IOn_partitionsContext + XML_COMPRESSION() antlr.TerminalNode + + // IsCreate_table_index_optionContext differentiates from other interfaces. + IsCreate_table_index_optionContext() +} + +type Create_table_index_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_table_index_optionContext() *Create_table_index_optionContext { + var p = new(Create_table_index_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_table_index_option + return p +} + +func InitEmptyCreate_table_index_optionContext(p *Create_table_index_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_table_index_option +} + +func (*Create_table_index_optionContext) IsCreate_table_index_optionContext() {} + +func NewCreate_table_index_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_table_index_optionContext { + var p = new(Create_table_index_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_table_index_option + + return p +} + +func (s *Create_table_index_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_table_index_optionContext) PAD_INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserPAD_INDEX, 0) +} + +func (s *Create_table_index_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_table_index_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Create_table_index_optionContext) FILLFACTOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFILLFACTOR, 0) +} + +func (s *Create_table_index_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Create_table_index_optionContext) IGNORE_DUP_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_DUP_KEY, 0) +} + +func (s *Create_table_index_optionContext) STATISTICS_NORECOMPUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS_NORECOMPUTE, 0) +} + +func (s *Create_table_index_optionContext) STATISTICS_INCREMENTAL() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS_INCREMENTAL, 0) +} + +func (s *Create_table_index_optionContext) ALLOW_ROW_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_ROW_LOCKS, 0) +} + +func (s *Create_table_index_optionContext) ALLOW_PAGE_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_PAGE_LOCKS, 0) +} + +func (s *Create_table_index_optionContext) OPTIMIZE_FOR_SEQUENTIAL_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, 0) +} + +func (s *Create_table_index_optionContext) DATA_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA_COMPRESSION, 0) +} + +func (s *Create_table_index_optionContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Create_table_index_optionContext) ROW() antlr.TerminalNode { + return s.GetToken(TSqlParserROW, 0) +} + +func (s *Create_table_index_optionContext) PAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserPAGE, 0) +} + +func (s *Create_table_index_optionContext) COLUMNSTORE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE, 0) +} + +func (s *Create_table_index_optionContext) COLUMNSTORE_ARCHIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE_ARCHIVE, 0) +} + +func (s *Create_table_index_optionContext) On_partitions() IOn_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_partitionsContext) +} + +func (s *Create_table_index_optionContext) XML_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserXML_COMPRESSION, 0) +} + +func (s *Create_table_index_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_table_index_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_table_index_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_table_index_option(s) + } +} + +func (s *Create_table_index_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_table_index_option(s) + } +} + +func (s *Create_table_index_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_table_index_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_table_index_option() (localctx ICreate_table_index_optionContext) { + localctx = NewCreate_table_index_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 608, TSqlParserRULE_create_table_index_option) + var _la int + + p.SetState(8015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPAD_INDEX: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7979) + p.Match(TSqlParserPAD_INDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7980) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7981) + p.On_off() + } + + case TSqlParserFILLFACTOR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7982) + p.Match(TSqlParserFILLFACTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7983) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7984) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserIGNORE_DUP_KEY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7985) + p.Match(TSqlParserIGNORE_DUP_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7986) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7987) + p.On_off() + } + + case TSqlParserSTATISTICS_NORECOMPUTE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7988) + p.Match(TSqlParserSTATISTICS_NORECOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7989) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7990) + p.On_off() + } + + case TSqlParserSTATISTICS_INCREMENTAL: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7991) + p.Match(TSqlParserSTATISTICS_INCREMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7992) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7993) + p.On_off() + } + + case TSqlParserALLOW_ROW_LOCKS: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7994) + p.Match(TSqlParserALLOW_ROW_LOCKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7995) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7996) + p.On_off() + } + + case TSqlParserALLOW_PAGE_LOCKS: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7997) + p.Match(TSqlParserALLOW_PAGE_LOCKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7998) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7999) + p.On_off() + } + + case TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(8000) + p.Match(TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8001) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8002) + p.On_off() + } + + case TSqlParserDATA_COMPRESSION: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(8003) + p.Match(TSqlParserDATA_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8004) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8005) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCOLUMNSTORE || _la == TSqlParserCOLUMNSTORE_ARCHIVE || _la == TSqlParserNONE || _la == TSqlParserPAGE || _la == TSqlParserROW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(8007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(8006) + p.On_partitions() + } + + } + + case TSqlParserXML_COMPRESSION: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(8009) + p.Match(TSqlParserXML_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8010) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8011) + p.On_off() + } + p.SetState(8013) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(8012) + p.On_partitions() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_viewContext is an interface to support dynamic dispatch. +type ICreate_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VIEW() antlr.TerminalNode + Simple_name() ISimple_nameContext + AS() antlr.TerminalNode + Select_statement_standalone() ISelect_statement_standaloneContext + CREATE() antlr.TerminalNode + ALTER() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Column_name_list() IColumn_name_listContext + RR_BRACKET() antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AllView_attribute() []IView_attributeContext + View_attribute(i int) IView_attributeContext + CHECK() antlr.TerminalNode + OPTION() antlr.TerminalNode + SEMI() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_viewContext differentiates from other interfaces. + IsCreate_viewContext() +} + +type Create_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_viewContext() *Create_viewContext { + var p = new(Create_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_view + return p +} + +func InitEmptyCreate_viewContext(p *Create_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_view +} + +func (*Create_viewContext) IsCreate_viewContext() {} + +func NewCreate_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_viewContext { + var p = new(Create_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_view + + return p +} + +func (s *Create_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(TSqlParserVIEW, 0) +} + +func (s *Create_viewContext) Simple_name() ISimple_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimple_nameContext) +} + +func (s *Create_viewContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Create_viewContext) Select_statement_standalone() ISelect_statement_standaloneContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statement_standaloneContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statement_standaloneContext) +} + +func (s *Create_viewContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_viewContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Create_viewContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_viewContext) Column_name_list() IColumn_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Create_viewContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_viewContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(TSqlParserWITH) +} + +func (s *Create_viewContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, i) +} + +func (s *Create_viewContext) AllView_attribute() []IView_attributeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IView_attributeContext); ok { + len++ + } + } + + tst := make([]IView_attributeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IView_attributeContext); ok { + tst[i] = t.(IView_attributeContext) + i++ + } + } + + return tst +} + +func (s *Create_viewContext) View_attribute(i int) IView_attributeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IView_attributeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IView_attributeContext) +} + +func (s *Create_viewContext) CHECK() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECK, 0) +} + +func (s *Create_viewContext) OPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserOPTION, 0) +} + +func (s *Create_viewContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Create_viewContext) OR() antlr.TerminalNode { + return s.GetToken(TSqlParserOR, 0) +} + +func (s *Create_viewContext) REPLACE() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLACE, 0) +} + +func (s *Create_viewContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_viewContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_view(s) + } +} + +func (s *Create_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_view(s) + } +} + +func (s *Create_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_view() (localctx ICreate_viewContext) { + localctx = NewCreate_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 610, TSqlParserRULE_create_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8023) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCREATE: + { + p.SetState(8017) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8020) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOR { + { + p.SetState(8018) + p.Match(TSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8019) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALTER || _la == TSqlParserREPLACE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case TSqlParserALTER: + { + p.SetState(8022) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(8025) + p.Match(TSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8026) + p.Simple_name() + } + p.SetState(8031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLR_BRACKET { + { + p.SetState(8027) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8028) + p.Column_name_list() + } + { + p.SetState(8029) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8042) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(8033) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8034) + p.View_attribute() + } + p.SetState(8039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8035) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8036) + p.View_attribute() + } + + p.SetState(8041) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(8044) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8045) + p.Select_statement_standalone() + } + p.SetState(8049) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1028, p.GetParserRuleContext()) == 1 { + { + p.SetState(8046) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8047) + p.Match(TSqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8048) + p.Match(TSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8052) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1029, p.GetParserRuleContext()) == 1 { + { + p.SetState(8051) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IView_attributeContext is an interface to support dynamic dispatch. +type IView_attributeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTION() antlr.TerminalNode + SCHEMABINDING() antlr.TerminalNode + VIEW_METADATA() antlr.TerminalNode + + // IsView_attributeContext differentiates from other interfaces. + IsView_attributeContext() +} + +type View_attributeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyView_attributeContext() *View_attributeContext { + var p = new(View_attributeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_view_attribute + return p +} + +func InitEmptyView_attributeContext(p *View_attributeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_view_attribute +} + +func (*View_attributeContext) IsView_attributeContext() {} + +func NewView_attributeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *View_attributeContext { + var p = new(View_attributeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_view_attribute + + return p +} + +func (s *View_attributeContext) GetParser() antlr.Parser { return s.parser } + +func (s *View_attributeContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *View_attributeContext) SCHEMABINDING() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMABINDING, 0) +} + +func (s *View_attributeContext) VIEW_METADATA() antlr.TerminalNode { + return s.GetToken(TSqlParserVIEW_METADATA, 0) +} + +func (s *View_attributeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *View_attributeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *View_attributeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterView_attribute(s) + } +} + +func (s *View_attributeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitView_attribute(s) + } +} + +func (s *View_attributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitView_attribute(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) View_attribute() (localctx IView_attributeContext) { + localctx = NewView_attributeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 612, TSqlParserRULE_view_attribute) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8054) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserENCRYPTION || _la == TSqlParserSCHEMABINDING || _la == TSqlParserVIEW_METADATA) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_tableContext is an interface to support dynamic dispatch. +type IAlter_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetConstraint returns the constraint rule contexts. + GetConstraint() IId_Context + + // GetFk returns the fk rule contexts. + GetFk() IColumn_name_listContext + + // GetPk returns the pk rule contexts. + GetPk() IColumn_name_listContext + + // SetConstraint sets the constraint rule contexts. + SetConstraint(IId_Context) + + // SetFk sets the fk rule contexts. + SetFk(IColumn_name_listContext) + + // SetPk sets the pk rule contexts. + SetPk(IColumn_name_listContext) + + // Getter signatures + AllALTER() []antlr.TerminalNode + ALTER(i int) antlr.TerminalNode + AllTABLE() []antlr.TerminalNode + TABLE(i int) antlr.TerminalNode + AllTable_name() []ITable_nameContext + Table_name(i int) ITable_nameContext + SET() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + LOCK_ESCALATION() antlr.TerminalNode + EQUAL() antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + ADD() antlr.TerminalNode + Column_def_table_constraints() IColumn_def_table_constraintsContext + COLUMN() antlr.TerminalNode + DROP() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + CONSTRAINT() antlr.TerminalNode + WITH() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + REBUILD() antlr.TerminalNode + Table_options() ITable_optionsContext + SWITCH() antlr.TerminalNode + Switch_partition() ISwitch_partitionContext + AUTO() antlr.TerminalNode + DISABLE() antlr.TerminalNode + AllCHECK() []antlr.TerminalNode + CHECK(i int) antlr.TerminalNode + NOCHECK() antlr.TerminalNode + ENABLE() antlr.TerminalNode + SEMI() antlr.TerminalNode + Column_definition() IColumn_definitionContext + Column_modifier() IColumn_modifierContext + FOREIGN() antlr.TerminalNode + KEY() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + Search_condition() ISearch_conditionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllColumn_name_list() []IColumn_name_listContext + Column_name_list(i int) IColumn_name_listContext + AllOn_delete() []IOn_deleteContext + On_delete(i int) IOn_deleteContext + AllOn_update() []IOn_updateContext + On_update(i int) IOn_updateContext + + // IsAlter_tableContext differentiates from other interfaces. + IsAlter_tableContext() +} + +type Alter_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + constraint IId_Context + fk IColumn_name_listContext + pk IColumn_name_listContext +} + +func NewEmptyAlter_tableContext() *Alter_tableContext { + var p = new(Alter_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_table + return p +} + +func InitEmptyAlter_tableContext(p *Alter_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_table +} + +func (*Alter_tableContext) IsAlter_tableContext() {} + +func NewAlter_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tableContext { + var p = new(Alter_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_table + + return p +} + +func (s *Alter_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tableContext) GetConstraint() IId_Context { return s.constraint } + +func (s *Alter_tableContext) GetFk() IColumn_name_listContext { return s.fk } + +func (s *Alter_tableContext) GetPk() IColumn_name_listContext { return s.pk } + +func (s *Alter_tableContext) SetConstraint(v IId_Context) { s.constraint = v } + +func (s *Alter_tableContext) SetFk(v IColumn_name_listContext) { s.fk = v } + +func (s *Alter_tableContext) SetPk(v IColumn_name_listContext) { s.pk = v } + +func (s *Alter_tableContext) AllALTER() []antlr.TerminalNode { + return s.GetTokens(TSqlParserALTER) +} + +func (s *Alter_tableContext) ALTER(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, i) +} + +func (s *Alter_tableContext) AllTABLE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTABLE) +} + +func (s *Alter_tableContext) TABLE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTABLE, i) +} + +func (s *Alter_tableContext) AllTable_name() []ITable_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_nameContext); ok { + len++ + } + } + + tst := make([]ITable_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_nameContext); ok { + tst[i] = t.(ITable_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) Table_name(i int) ITable_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Alter_tableContext) SET() antlr.TerminalNode { + return s.GetToken(TSqlParserSET, 0) +} + +func (s *Alter_tableContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Alter_tableContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Alter_tableContext) LOCK_ESCALATION() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCK_ESCALATION, 0) +} + +func (s *Alter_tableContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_tableContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Alter_tableContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Alter_tableContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Alter_tableContext) Column_def_table_constraints() IColumn_def_table_constraintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_def_table_constraintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_def_table_constraintsContext) +} + +func (s *Alter_tableContext) COLUMN() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMN, 0) +} + +func (s *Alter_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Alter_tableContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_tableContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONSTRAINT, 0) +} + +func (s *Alter_tableContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_tableContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIGGER, 0) +} + +func (s *Alter_tableContext) REBUILD() antlr.TerminalNode { + return s.GetToken(TSqlParserREBUILD, 0) +} + +func (s *Alter_tableContext) Table_options() ITable_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_optionsContext) +} + +func (s *Alter_tableContext) SWITCH() antlr.TerminalNode { + return s.GetToken(TSqlParserSWITCH, 0) +} + +func (s *Alter_tableContext) Switch_partition() ISwitch_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISwitch_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISwitch_partitionContext) +} + +func (s *Alter_tableContext) AUTO() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO, 0) +} + +func (s *Alter_tableContext) DISABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLE, 0) +} + +func (s *Alter_tableContext) AllCHECK() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCHECK) +} + +func (s *Alter_tableContext) CHECK(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCHECK, i) +} + +func (s *Alter_tableContext) NOCHECK() antlr.TerminalNode { + return s.GetToken(TSqlParserNOCHECK, 0) +} + +func (s *Alter_tableContext) ENABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserENABLE, 0) +} + +func (s *Alter_tableContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Alter_tableContext) Column_definition() IColumn_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_definitionContext) +} + +func (s *Alter_tableContext) Column_modifier() IColumn_modifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_modifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_modifierContext) +} + +func (s *Alter_tableContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserFOREIGN, 0) +} + +func (s *Alter_tableContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Alter_tableContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(TSqlParserREFERENCES, 0) +} + +func (s *Alter_tableContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Alter_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_tableContext) AllColumn_name_list() []IColumn_name_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_name_listContext); ok { + len++ + } + } + + tst := make([]IColumn_name_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_name_listContext); ok { + tst[i] = t.(IColumn_name_listContext) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) Column_name_list(i int) IColumn_name_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Alter_tableContext) AllOn_delete() []IOn_deleteContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOn_deleteContext); ok { + len++ + } + } + + tst := make([]IOn_deleteContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOn_deleteContext); ok { + tst[i] = t.(IOn_deleteContext) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) On_delete(i int) IOn_deleteContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_deleteContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOn_deleteContext) +} + +func (s *Alter_tableContext) AllOn_update() []IOn_updateContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOn_updateContext); ok { + len++ + } + } + + tst := make([]IOn_updateContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOn_updateContext); ok { + tst[i] = t.(IOn_updateContext) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) On_update(i int) IOn_updateContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_updateContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOn_updateContext) +} + +func (s *Alter_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_table(s) + } +} + +func (s *Alter_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_table(s) + } +} + +func (s *Alter_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_table() (localctx IAlter_tableContext) { + localctx = NewAlter_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 614, TSqlParserRULE_alter_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8056) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8057) + p.Match(TSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8058) + p.Table_name() + } + p.SetState(8132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1038, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8059) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8060) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8061) + p.Match(TSqlParserLOCK_ESCALATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8062) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8063) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAUTO || _la == TSqlParserDISABLE || _la == TSqlParserTABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8064) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(8065) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8066) + p.Column_def_table_constraints() + } + + case 3: + { + p.SetState(8067) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8068) + p.Match(TSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1030, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8069) + p.Column_definition() + } + + case 2: + { + p.SetState(8070) + p.Column_modifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 4: + { + p.SetState(8073) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8074) + p.Match(TSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8075) + p.Id_() + } + p.SetState(8080) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8076) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8077) + p.Id_() + } + + p.SetState(8082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 5: + { + p.SetState(8083) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8084) + p.Match(TSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8085) + + var _x = p.Id_() + + localctx.(*Alter_tableContext).constraint = _x + } + + case 6: + { + p.SetState(8086) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8087) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCHECK || _la == TSqlParserNOCHECK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8088) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8091) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCONSTRAINT { + { + p.SetState(8089) + p.Match(TSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8090) + + var _x = p.Id_() + + localctx.(*Alter_tableContext).constraint = _x + } + + } + p.SetState(8118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFOREIGN: + { + p.SetState(8093) + p.Match(TSqlParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8094) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8095) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8096) + + var _x = p.Column_name_list() + + localctx.(*Alter_tableContext).fk = _x + } + { + p.SetState(8097) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8098) + p.Match(TSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8099) + p.Table_name() + } + p.SetState(8104) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1033, p.GetParserRuleContext()) == 1 { + { + p.SetState(8100) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8101) + + var _x = p.Column_name_list() + + localctx.(*Alter_tableContext).pk = _x + } + { + p.SetState(8102) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8110) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserON { + p.SetState(8108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1034, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8106) + p.On_delete() + } + + case 2: + { + p.SetState(8107) + p.On_update() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(8112) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case TSqlParserCHECK: + { + p.SetState(8113) + p.Match(TSqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8114) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8115) + p.search_condition(0) + } + { + p.SetState(8116) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 7: + { + p.SetState(8120) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCHECK || _la == TSqlParserNOCHECK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8121) + p.Match(TSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8122) + + var _x = p.Id_() + + localctx.(*Alter_tableContext).constraint = _x + } + + case 8: + { + p.SetState(8123) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISABLE || _la == TSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8124) + p.Match(TSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8126) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1037, p.GetParserRuleContext()) == 1 { + { + p.SetState(8125) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 9: + { + p.SetState(8128) + p.Match(TSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8129) + p.Table_options() + } + + case 10: + { + p.SetState(8130) + p.Match(TSqlParserSWITCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8131) + p.Switch_partition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8135) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1039, p.GetParserRuleContext()) == 1 { + { + p.SetState(8134) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISwitch_partitionContext is an interface to support dynamic dispatch. +type ISwitch_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSource_partition_number_expression returns the source_partition_number_expression rule contexts. + GetSource_partition_number_expression() IExpressionContext + + // GetTarget_table returns the target_table rule contexts. + GetTarget_table() ITable_nameContext + + // GetTarget_partition_number_expression returns the target_partition_number_expression rule contexts. + GetTarget_partition_number_expression() IExpressionContext + + // SetSource_partition_number_expression sets the source_partition_number_expression rule contexts. + SetSource_partition_number_expression(IExpressionContext) + + // SetTarget_table sets the target_table rule contexts. + SetTarget_table(ITable_nameContext) + + // SetTarget_partition_number_expression sets the target_partition_number_expression rule contexts. + SetTarget_partition_number_expression(IExpressionContext) + + // Getter signatures + TO() antlr.TerminalNode + Table_name() ITable_nameContext + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + Low_priority_lock_wait() ILow_priority_lock_waitContext + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + + // IsSwitch_partitionContext differentiates from other interfaces. + IsSwitch_partitionContext() +} + +type Switch_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + source_partition_number_expression IExpressionContext + target_table ITable_nameContext + target_partition_number_expression IExpressionContext +} + +func NewEmptySwitch_partitionContext() *Switch_partitionContext { + var p = new(Switch_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_switch_partition + return p +} + +func InitEmptySwitch_partitionContext(p *Switch_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_switch_partition +} + +func (*Switch_partitionContext) IsSwitch_partitionContext() {} + +func NewSwitch_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Switch_partitionContext { + var p = new(Switch_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_switch_partition + + return p +} + +func (s *Switch_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Switch_partitionContext) GetSource_partition_number_expression() IExpressionContext { + return s.source_partition_number_expression +} + +func (s *Switch_partitionContext) GetTarget_table() ITable_nameContext { return s.target_table } + +func (s *Switch_partitionContext) GetTarget_partition_number_expression() IExpressionContext { + return s.target_partition_number_expression +} + +func (s *Switch_partitionContext) SetSource_partition_number_expression(v IExpressionContext) { + s.source_partition_number_expression = v +} + +func (s *Switch_partitionContext) SetTarget_table(v ITable_nameContext) { s.target_table = v } + +func (s *Switch_partitionContext) SetTarget_partition_number_expression(v IExpressionContext) { + s.target_partition_number_expression = v +} + +func (s *Switch_partitionContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Switch_partitionContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Switch_partitionContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserPARTITION) +} + +func (s *Switch_partitionContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITION, i) +} + +func (s *Switch_partitionContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Switch_partitionContext) Low_priority_lock_wait() ILow_priority_lock_waitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILow_priority_lock_waitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILow_priority_lock_waitContext) +} + +func (s *Switch_partitionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Switch_partitionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Switch_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Switch_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Switch_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSwitch_partition(s) + } +} + +func (s *Switch_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSwitch_partition(s) + } +} + +func (s *Switch_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSwitch_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Switch_partition() (localctx ISwitch_partitionContext) { + localctx = NewSwitch_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 616, TSqlParserRULE_switch_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8141) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + p.SetState(8138) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1040, p.GetParserRuleContext()) == 1 { + { + p.SetState(8137) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8140) + + var _x = p.expression(0) + + localctx.(*Switch_partitionContext).source_partition_number_expression = _x + } + + } + { + p.SetState(8143) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8144) + + var _x = p.Table_name() + + localctx.(*Switch_partitionContext).target_table = _x + } + p.SetState(8147) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1042, p.GetParserRuleContext()) == 1 { + { + p.SetState(8145) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8146) + + var _x = p.expression(0) + + localctx.(*Switch_partitionContext).target_partition_number_expression = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8151) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1043, p.GetParserRuleContext()) == 1 { + { + p.SetState(8149) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8150) + p.Low_priority_lock_wait() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILow_priority_lock_waitContext is an interface to support dynamic dispatch. +type ILow_priority_lock_waitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAbort_after_wait returns the abort_after_wait token. + GetAbort_after_wait() antlr.Token + + // SetAbort_after_wait sets the abort_after_wait token. + SetAbort_after_wait(antlr.Token) + + // GetMax_duration returns the max_duration rule contexts. + GetMax_duration() ITimeContext + + // SetMax_duration sets the max_duration rule contexts. + SetMax_duration(ITimeContext) + + // Getter signatures + WAIT_AT_LOW_PRIORITY() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + MAX_DURATION() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + ABORT_AFTER_WAIT() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Time() ITimeContext + NONE() antlr.TerminalNode + SELF() antlr.TerminalNode + BLOCKERS() antlr.TerminalNode + MINUTES() antlr.TerminalNode + + // IsLow_priority_lock_waitContext differentiates from other interfaces. + IsLow_priority_lock_waitContext() +} + +type Low_priority_lock_waitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + max_duration ITimeContext + abort_after_wait antlr.Token +} + +func NewEmptyLow_priority_lock_waitContext() *Low_priority_lock_waitContext { + var p = new(Low_priority_lock_waitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_low_priority_lock_wait + return p +} + +func InitEmptyLow_priority_lock_waitContext(p *Low_priority_lock_waitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_low_priority_lock_wait +} + +func (*Low_priority_lock_waitContext) IsLow_priority_lock_waitContext() {} + +func NewLow_priority_lock_waitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Low_priority_lock_waitContext { + var p = new(Low_priority_lock_waitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_low_priority_lock_wait + + return p +} + +func (s *Low_priority_lock_waitContext) GetParser() antlr.Parser { return s.parser } + +func (s *Low_priority_lock_waitContext) GetAbort_after_wait() antlr.Token { return s.abort_after_wait } + +func (s *Low_priority_lock_waitContext) SetAbort_after_wait(v antlr.Token) { s.abort_after_wait = v } + +func (s *Low_priority_lock_waitContext) GetMax_duration() ITimeContext { return s.max_duration } + +func (s *Low_priority_lock_waitContext) SetMax_duration(v ITimeContext) { s.max_duration = v } + +func (s *Low_priority_lock_waitContext) WAIT_AT_LOW_PRIORITY() antlr.TerminalNode { + return s.GetToken(TSqlParserWAIT_AT_LOW_PRIORITY, 0) +} + +func (s *Low_priority_lock_waitContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Low_priority_lock_waitContext) MAX_DURATION() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_DURATION, 0) +} + +func (s *Low_priority_lock_waitContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Low_priority_lock_waitContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Low_priority_lock_waitContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Low_priority_lock_waitContext) ABORT_AFTER_WAIT() antlr.TerminalNode { + return s.GetToken(TSqlParserABORT_AFTER_WAIT, 0) +} + +func (s *Low_priority_lock_waitContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Low_priority_lock_waitContext) Time() ITimeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITimeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITimeContext) +} + +func (s *Low_priority_lock_waitContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Low_priority_lock_waitContext) SELF() antlr.TerminalNode { + return s.GetToken(TSqlParserSELF, 0) +} + +func (s *Low_priority_lock_waitContext) BLOCKERS() antlr.TerminalNode { + return s.GetToken(TSqlParserBLOCKERS, 0) +} + +func (s *Low_priority_lock_waitContext) MINUTES() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUTES, 0) +} + +func (s *Low_priority_lock_waitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Low_priority_lock_waitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Low_priority_lock_waitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterLow_priority_lock_wait(s) + } +} + +func (s *Low_priority_lock_waitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitLow_priority_lock_wait(s) + } +} + +func (s *Low_priority_lock_waitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitLow_priority_lock_wait(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Low_priority_lock_wait() (localctx ILow_priority_lock_waitContext) { + localctx = NewLow_priority_lock_waitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 618, TSqlParserRULE_low_priority_lock_wait) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8153) + p.Match(TSqlParserWAIT_AT_LOW_PRIORITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8154) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8155) + p.Match(TSqlParserMAX_DURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8156) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8157) + + var _x = p.Time() + + localctx.(*Low_priority_lock_waitContext).max_duration = _x + } + p.SetState(8159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMINUTES { + { + p.SetState(8158) + p.Match(TSqlParserMINUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8161) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8162) + p.Match(TSqlParserABORT_AFTER_WAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8163) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8164) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Low_priority_lock_waitContext).abort_after_wait = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserBLOCKERS || _la == TSqlParserNONE || _la == TSqlParserSELF) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Low_priority_lock_waitContext).abort_after_wait = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8165) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_databaseContext is an interface to support dynamic dispatch. +type IAlter_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatabase returns the database rule contexts. + GetDatabase() IId_Context + + // GetNew_name returns the new_name rule contexts. + GetNew_name() IId_Context + + // GetCollation returns the collation rule contexts. + GetCollation() IId_Context + + // SetDatabase sets the database rule contexts. + SetDatabase(IId_Context) + + // SetNew_name sets the new_name rule contexts. + SetNew_name(IId_Context) + + // SetCollation sets the collation rule contexts. + SetCollation(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + CURRENT() antlr.TerminalNode + MODIFY() antlr.TerminalNode + NAME() antlr.TerminalNode + EQUAL() antlr.TerminalNode + COLLATE() antlr.TerminalNode + SET() antlr.TerminalNode + Database_optionspec() IDatabase_optionspecContext + Add_or_modify_files() IAdd_or_modify_filesContext + Add_or_modify_filegroups() IAdd_or_modify_filegroupsContext + AllId_() []IId_Context + Id_(i int) IId_Context + SEMI() antlr.TerminalNode + WITH() antlr.TerminalNode + Termination() ITerminationContext + + // IsAlter_databaseContext differentiates from other interfaces. + IsAlter_databaseContext() +} + +type Alter_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database IId_Context + new_name IId_Context + collation IId_Context +} + +func NewEmptyAlter_databaseContext() *Alter_databaseContext { + var p = new(Alter_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_database + return p +} + +func InitEmptyAlter_databaseContext(p *Alter_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_database +} + +func (*Alter_databaseContext) IsAlter_databaseContext() {} + +func NewAlter_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_databaseContext { + var p = new(Alter_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_database + + return p +} + +func (s *Alter_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_databaseContext) GetDatabase() IId_Context { return s.database } + +func (s *Alter_databaseContext) GetNew_name() IId_Context { return s.new_name } + +func (s *Alter_databaseContext) GetCollation() IId_Context { return s.collation } + +func (s *Alter_databaseContext) SetDatabase(v IId_Context) { s.database = v } + +func (s *Alter_databaseContext) SetNew_name(v IId_Context) { s.new_name = v } + +func (s *Alter_databaseContext) SetCollation(v IId_Context) { s.collation = v } + +func (s *Alter_databaseContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Alter_databaseContext) CURRENT() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT, 0) +} + +func (s *Alter_databaseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(TSqlParserMODIFY, 0) +} + +func (s *Alter_databaseContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *Alter_databaseContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_databaseContext) COLLATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLATE, 0) +} + +func (s *Alter_databaseContext) SET() antlr.TerminalNode { + return s.GetToken(TSqlParserSET, 0) +} + +func (s *Alter_databaseContext) Database_optionspec() IDatabase_optionspecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_optionspecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_optionspecContext) +} + +func (s *Alter_databaseContext) Add_or_modify_files() IAdd_or_modify_filesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_or_modify_filesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_or_modify_filesContext) +} + +func (s *Alter_databaseContext) Add_or_modify_filegroups() IAdd_or_modify_filegroupsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_or_modify_filegroupsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_or_modify_filegroupsContext) +} + +func (s *Alter_databaseContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_databaseContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_databaseContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Alter_databaseContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_databaseContext) Termination() ITerminationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITerminationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITerminationContext) +} + +func (s *Alter_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_database(s) + } +} + +func (s *Alter_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_database(s) + } +} + +func (s *Alter_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_database() (localctx IAlter_databaseContext) { + localctx = NewAlter_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 620, TSqlParserRULE_alter_database) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8167) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8168) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8171) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(8169) + + var _x = p.Id_() + + localctx.(*Alter_databaseContext).database = _x + } + + case TSqlParserCURRENT: + { + p.SetState(8170) + p.Match(TSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(8187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1047, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8173) + p.Match(TSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8174) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8175) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8176) + + var _x = p.Id_() + + localctx.(*Alter_databaseContext).new_name = _x + } + + case 2: + { + p.SetState(8177) + p.Match(TSqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8178) + + var _x = p.Id_() + + localctx.(*Alter_databaseContext).collation = _x + } + + case 3: + { + p.SetState(8179) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8180) + p.Database_optionspec() + } + p.SetState(8183) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1046, p.GetParserRuleContext()) == 1 { + { + p.SetState(8181) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8182) + p.Termination() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + { + p.SetState(8185) + p.Add_or_modify_files() + } + + case 5: + { + p.SetState(8186) + p.Add_or_modify_filegroups() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8190) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1048, p.GetParserRuleContext()) == 1 { + { + p.SetState(8189) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_or_modify_filesContext is an interface to support dynamic dispatch. +type IAdd_or_modify_filesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFilegroup_name returns the filegroup_name rule contexts. + GetFilegroup_name() IId_Context + + // GetLogical_file_name returns the logical_file_name rule contexts. + GetLogical_file_name() IId_Context + + // SetFilegroup_name sets the filegroup_name rule contexts. + SetFilegroup_name(IId_Context) + + // SetLogical_file_name sets the logical_file_name rule contexts. + SetLogical_file_name(IId_Context) + + // Getter signatures + ADD() antlr.TerminalNode + FILE() antlr.TerminalNode + AllFilespec() []IFilespecContext + Filespec(i int) IFilespecContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + TO() antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + Id_() IId_Context + LOG() antlr.TerminalNode + REMOVE() antlr.TerminalNode + MODIFY() antlr.TerminalNode + + // IsAdd_or_modify_filesContext differentiates from other interfaces. + IsAdd_or_modify_filesContext() +} + +type Add_or_modify_filesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + filegroup_name IId_Context + logical_file_name IId_Context +} + +func NewEmptyAdd_or_modify_filesContext() *Add_or_modify_filesContext { + var p = new(Add_or_modify_filesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_add_or_modify_files + return p +} + +func InitEmptyAdd_or_modify_filesContext(p *Add_or_modify_filesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_add_or_modify_files +} + +func (*Add_or_modify_filesContext) IsAdd_or_modify_filesContext() {} + +func NewAdd_or_modify_filesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_or_modify_filesContext { + var p = new(Add_or_modify_filesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_add_or_modify_files + + return p +} + +func (s *Add_or_modify_filesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_or_modify_filesContext) GetFilegroup_name() IId_Context { return s.filegroup_name } + +func (s *Add_or_modify_filesContext) GetLogical_file_name() IId_Context { return s.logical_file_name } + +func (s *Add_or_modify_filesContext) SetFilegroup_name(v IId_Context) { s.filegroup_name = v } + +func (s *Add_or_modify_filesContext) SetLogical_file_name(v IId_Context) { s.logical_file_name = v } + +func (s *Add_or_modify_filesContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Add_or_modify_filesContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Add_or_modify_filesContext) AllFilespec() []IFilespecContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilespecContext); ok { + len++ + } + } + + tst := make([]IFilespecContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilespecContext); ok { + tst[i] = t.(IFilespecContext) + i++ + } + } + + return tst +} + +func (s *Add_or_modify_filesContext) Filespec(i int) IFilespecContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilespecContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilespecContext) +} + +func (s *Add_or_modify_filesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Add_or_modify_filesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Add_or_modify_filesContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Add_or_modify_filesContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROUP, 0) +} + +func (s *Add_or_modify_filesContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Add_or_modify_filesContext) LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserLOG, 0) +} + +func (s *Add_or_modify_filesContext) REMOVE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOVE, 0) +} + +func (s *Add_or_modify_filesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(TSqlParserMODIFY, 0) +} + +func (s *Add_or_modify_filesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_or_modify_filesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_or_modify_filesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAdd_or_modify_files(s) + } +} + +func (s *Add_or_modify_filesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAdd_or_modify_files(s) + } +} + +func (s *Add_or_modify_filesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAdd_or_modify_files(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Add_or_modify_files() (localctx IAdd_or_modify_filesContext) { + localctx = NewAdd_or_modify_filesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 622, TSqlParserRULE_add_or_modify_files) + var _la int + + p.SetState(8224) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1052, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8192) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8193) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8194) + p.Filespec() + } + p.SetState(8199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8195) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8196) + p.Filespec() + } + + p.SetState(8201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8205) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserTO { + { + p.SetState(8202) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8203) + p.Match(TSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8204) + + var _x = p.Id_() + + localctx.(*Add_or_modify_filesContext).filegroup_name = _x + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8207) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8208) + p.Match(TSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8209) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8210) + p.Filespec() + } + p.SetState(8215) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8211) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8212) + p.Filespec() + } + + p.SetState(8217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8218) + p.Match(TSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8219) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8220) + + var _x = p.Id_() + + localctx.(*Add_or_modify_filesContext).logical_file_name = _x + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8221) + p.Match(TSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8222) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8223) + p.Filespec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFilespecContext is an interface to support dynamic dispatch. +type IFilespecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFile_name returns the file_name token. + GetFile_name() antlr.Token + + // SetFile_name sets the file_name token. + SetFile_name(antlr.Token) + + // GetName returns the name rule contexts. + GetName() IId_or_stringContext + + // GetNew_name returns the new_name rule contexts. + GetNew_name() IId_or_stringContext + + // GetSize returns the size rule contexts. + GetSize() IFile_sizeContext + + // GetMax_size returns the max_size rule contexts. + GetMax_size() IFile_sizeContext + + // GetGrowth_increment returns the growth_increment rule contexts. + GetGrowth_increment() IFile_sizeContext + + // SetName sets the name rule contexts. + SetName(IId_or_stringContext) + + // SetNew_name sets the new_name rule contexts. + SetNew_name(IId_or_stringContext) + + // SetSize sets the size rule contexts. + SetSize(IFile_sizeContext) + + // SetMax_size sets the max_size rule contexts. + SetMax_size(IFile_sizeContext) + + // SetGrowth_increment sets the growth_increment rule contexts. + SetGrowth_increment(IFile_sizeContext) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + NAME() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllId_or_string() []IId_or_stringContext + Id_or_string(i int) IId_or_stringContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + NEWNAME() antlr.TerminalNode + FILENAME() antlr.TerminalNode + SIZE() antlr.TerminalNode + MAXSIZE() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + FILEGROWTH() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + STRING() antlr.TerminalNode + AllFile_size() []IFile_sizeContext + File_size(i int) IFile_sizeContext + + // IsFilespecContext differentiates from other interfaces. + IsFilespecContext() +} + +type FilespecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name IId_or_stringContext + new_name IId_or_stringContext + file_name antlr.Token + size IFile_sizeContext + max_size IFile_sizeContext + growth_increment IFile_sizeContext +} + +func NewEmptyFilespecContext() *FilespecContext { + var p = new(FilespecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_filespec + return p +} + +func InitEmptyFilespecContext(p *FilespecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_filespec +} + +func (*FilespecContext) IsFilespecContext() {} + +func NewFilespecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilespecContext { + var p = new(FilespecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_filespec + + return p +} + +func (s *FilespecContext) GetParser() antlr.Parser { return s.parser } + +func (s *FilespecContext) GetFile_name() antlr.Token { return s.file_name } + +func (s *FilespecContext) SetFile_name(v antlr.Token) { s.file_name = v } + +func (s *FilespecContext) GetName() IId_or_stringContext { return s.name } + +func (s *FilespecContext) GetNew_name() IId_or_stringContext { return s.new_name } + +func (s *FilespecContext) GetSize() IFile_sizeContext { return s.size } + +func (s *FilespecContext) GetMax_size() IFile_sizeContext { return s.max_size } + +func (s *FilespecContext) GetGrowth_increment() IFile_sizeContext { return s.growth_increment } + +func (s *FilespecContext) SetName(v IId_or_stringContext) { s.name = v } + +func (s *FilespecContext) SetNew_name(v IId_or_stringContext) { s.new_name = v } + +func (s *FilespecContext) SetSize(v IFile_sizeContext) { s.size = v } + +func (s *FilespecContext) SetMax_size(v IFile_sizeContext) { s.max_size = v } + +func (s *FilespecContext) SetGrowth_increment(v IFile_sizeContext) { s.growth_increment = v } + +func (s *FilespecContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FilespecContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *FilespecContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *FilespecContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *FilespecContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FilespecContext) AllId_or_string() []IId_or_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_or_stringContext); ok { + len++ + } + } + + tst := make([]IId_or_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_or_stringContext); ok { + tst[i] = t.(IId_or_stringContext) + i++ + } + } + + return tst +} + +func (s *FilespecContext) Id_or_string(i int) IId_or_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_or_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_or_stringContext) +} + +func (s *FilespecContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *FilespecContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *FilespecContext) NEWNAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNEWNAME, 0) +} + +func (s *FilespecContext) FILENAME() antlr.TerminalNode { + return s.GetToken(TSqlParserFILENAME, 0) +} + +func (s *FilespecContext) SIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserSIZE, 0) +} + +func (s *FilespecContext) MAXSIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXSIZE, 0) +} + +func (s *FilespecContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(TSqlParserUNLIMITED, 0) +} + +func (s *FilespecContext) FILEGROWTH() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROWTH, 0) +} + +func (s *FilespecContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(TSqlParserOFFLINE, 0) +} + +func (s *FilespecContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *FilespecContext) AllFile_size() []IFile_sizeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_sizeContext); ok { + len++ + } + } + + tst := make([]IFile_sizeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_sizeContext); ok { + tst[i] = t.(IFile_sizeContext) + i++ + } + } + + return tst +} + +func (s *FilespecContext) File_size(i int) IFile_sizeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_sizeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_sizeContext) +} + +func (s *FilespecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FilespecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FilespecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFilespec(s) + } +} + +func (s *FilespecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFilespec(s) + } +} + +func (s *FilespecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFilespec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Filespec() (localctx IFilespecContext) { + localctx = NewFilespecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 624, TSqlParserRULE_filespec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8226) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8227) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8228) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8229) + + var _x = p.Id_or_string() + + localctx.(*FilespecContext).name = _x + } + p.SetState(8234) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1053, p.GetParserRuleContext()) == 1 { + { + p.SetState(8230) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8231) + p.Match(TSqlParserNEWNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8232) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8233) + + var _x = p.Id_or_string() + + localctx.(*FilespecContext).new_name = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8240) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1054, p.GetParserRuleContext()) == 1 { + { + p.SetState(8236) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8237) + p.Match(TSqlParserFILENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8238) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8239) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*FilespecContext).file_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8246) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1055, p.GetParserRuleContext()) == 1 { + { + p.SetState(8242) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8243) + p.Match(TSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8244) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8245) + + var _x = p.File_size() + + localctx.(*FilespecContext).size = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8253) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1056, p.GetParserRuleContext()) == 1 { + { + p.SetState(8248) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8249) + p.Match(TSqlParserMAXSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8250) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(8251) + + var _x = p.File_size() + + localctx.(*FilespecContext).max_size = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1056, p.GetParserRuleContext()) == 2 { + { + p.SetState(8252) + p.Match(TSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8259) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1057, p.GetParserRuleContext()) == 1 { + { + p.SetState(8255) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8256) + p.Match(TSqlParserFILEGROWTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8257) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8258) + + var _x = p.File_size() + + localctx.(*FilespecContext).growth_increment = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8263) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(8261) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8262) + p.Match(TSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8265) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_or_modify_filegroupsContext is an interface to support dynamic dispatch. +type IAdd_or_modify_filegroupsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFilegroup_name returns the filegroup_name rule contexts. + GetFilegroup_name() IId_Context + + // GetFilegrou_name returns the filegrou_name rule contexts. + GetFilegrou_name() IId_Context + + // GetNew_filegroup_name returns the new_filegroup_name rule contexts. + GetNew_filegroup_name() IId_Context + + // SetFilegroup_name sets the filegroup_name rule contexts. + SetFilegroup_name(IId_Context) + + // SetFilegrou_name sets the filegrou_name rule contexts. + SetFilegrou_name(IId_Context) + + // SetNew_filegroup_name sets the new_filegroup_name rule contexts. + SetNew_filegroup_name(IId_Context) + + // Getter signatures + ADD() antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + CONTAINS() antlr.TerminalNode + FILESTREAM() antlr.TerminalNode + MEMORY_OPTIMIZED_DATA() antlr.TerminalNode + REMOVE() antlr.TerminalNode + MODIFY() antlr.TerminalNode + Filegroup_updatability_option() IFilegroup_updatability_optionContext + DEFAULT() antlr.TerminalNode + NAME() antlr.TerminalNode + EQUAL() antlr.TerminalNode + AUTOGROW_SINGLE_FILE() antlr.TerminalNode + AUTOGROW_ALL_FILES() antlr.TerminalNode + + // IsAdd_or_modify_filegroupsContext differentiates from other interfaces. + IsAdd_or_modify_filegroupsContext() +} + +type Add_or_modify_filegroupsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + filegroup_name IId_Context + filegrou_name IId_Context + new_filegroup_name IId_Context +} + +func NewEmptyAdd_or_modify_filegroupsContext() *Add_or_modify_filegroupsContext { + var p = new(Add_or_modify_filegroupsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_add_or_modify_filegroups + return p +} + +func InitEmptyAdd_or_modify_filegroupsContext(p *Add_or_modify_filegroupsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_add_or_modify_filegroups +} + +func (*Add_or_modify_filegroupsContext) IsAdd_or_modify_filegroupsContext() {} + +func NewAdd_or_modify_filegroupsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_or_modify_filegroupsContext { + var p = new(Add_or_modify_filegroupsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_add_or_modify_filegroups + + return p +} + +func (s *Add_or_modify_filegroupsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_or_modify_filegroupsContext) GetFilegroup_name() IId_Context { return s.filegroup_name } + +func (s *Add_or_modify_filegroupsContext) GetFilegrou_name() IId_Context { return s.filegrou_name } + +func (s *Add_or_modify_filegroupsContext) GetNew_filegroup_name() IId_Context { + return s.new_filegroup_name +} + +func (s *Add_or_modify_filegroupsContext) SetFilegroup_name(v IId_Context) { s.filegroup_name = v } + +func (s *Add_or_modify_filegroupsContext) SetFilegrou_name(v IId_Context) { s.filegrou_name = v } + +func (s *Add_or_modify_filegroupsContext) SetNew_filegroup_name(v IId_Context) { + s.new_filegroup_name = v +} + +func (s *Add_or_modify_filegroupsContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Add_or_modify_filegroupsContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROUP, 0) +} + +func (s *Add_or_modify_filegroupsContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Add_or_modify_filegroupsContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Add_or_modify_filegroupsContext) CONTAINS() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTAINS, 0) +} + +func (s *Add_or_modify_filegroupsContext) FILESTREAM() antlr.TerminalNode { + return s.GetToken(TSqlParserFILESTREAM, 0) +} + +func (s *Add_or_modify_filegroupsContext) MEMORY_OPTIMIZED_DATA() antlr.TerminalNode { + return s.GetToken(TSqlParserMEMORY_OPTIMIZED_DATA, 0) +} + +func (s *Add_or_modify_filegroupsContext) REMOVE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOVE, 0) +} + +func (s *Add_or_modify_filegroupsContext) MODIFY() antlr.TerminalNode { + return s.GetToken(TSqlParserMODIFY, 0) +} + +func (s *Add_or_modify_filegroupsContext) Filegroup_updatability_option() IFilegroup_updatability_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilegroup_updatability_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilegroup_updatability_optionContext) +} + +func (s *Add_or_modify_filegroupsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Add_or_modify_filegroupsContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *Add_or_modify_filegroupsContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Add_or_modify_filegroupsContext) AUTOGROW_SINGLE_FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTOGROW_SINGLE_FILE, 0) +} + +func (s *Add_or_modify_filegroupsContext) AUTOGROW_ALL_FILES() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTOGROW_ALL_FILES, 0) +} + +func (s *Add_or_modify_filegroupsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_or_modify_filegroupsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_or_modify_filegroupsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAdd_or_modify_filegroups(s) + } +} + +func (s *Add_or_modify_filegroupsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAdd_or_modify_filegroups(s) + } +} + +func (s *Add_or_modify_filegroupsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAdd_or_modify_filegroups(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Add_or_modify_filegroups() (localctx IAdd_or_modify_filegroupsContext) { + localctx = NewAdd_or_modify_filegroupsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 626, TSqlParserRULE_add_or_modify_filegroups) + p.SetState(8291) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8267) + p.Match(TSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8268) + p.Match(TSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8269) + + var _x = p.Id_() + + localctx.(*Add_or_modify_filegroupsContext).filegroup_name = _x + } + p.SetState(8274) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1059, p.GetParserRuleContext()) == 1 { + { + p.SetState(8270) + p.Match(TSqlParserCONTAINS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8271) + p.Match(TSqlParserFILESTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1059, p.GetParserRuleContext()) == 2 { + { + p.SetState(8272) + p.Match(TSqlParserCONTAINS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8273) + p.Match(TSqlParserMEMORY_OPTIMIZED_DATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserREMOVE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8276) + p.Match(TSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8277) + p.Match(TSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8278) + + var _x = p.Id_() + + localctx.(*Add_or_modify_filegroupsContext).filegrou_name = _x + } + + case TSqlParserMODIFY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8279) + p.Match(TSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8280) + p.Match(TSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8281) + + var _x = p.Id_() + + localctx.(*Add_or_modify_filegroupsContext).filegrou_name = _x + } + p.SetState(8289) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserREADONLY, TSqlParserREADWRITE, TSqlParserREAD_ONLY, TSqlParserREAD_WRITE: + { + p.SetState(8282) + p.Filegroup_updatability_option() + } + + case TSqlParserDEFAULT: + { + p.SetState(8283) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNAME: + { + p.SetState(8284) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8285) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8286) + + var _x = p.Id_() + + localctx.(*Add_or_modify_filegroupsContext).new_filegroup_name = _x + } + + case TSqlParserAUTOGROW_SINGLE_FILE: + { + p.SetState(8287) + p.Match(TSqlParserAUTOGROW_SINGLE_FILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserAUTOGROW_ALL_FILES: + { + p.SetState(8288) + p.Match(TSqlParserAUTOGROW_ALL_FILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFilegroup_updatability_optionContext is an interface to support dynamic dispatch. +type IFilegroup_updatability_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + READONLY() antlr.TerminalNode + READWRITE() antlr.TerminalNode + READ_ONLY() antlr.TerminalNode + READ_WRITE() antlr.TerminalNode + + // IsFilegroup_updatability_optionContext differentiates from other interfaces. + IsFilegroup_updatability_optionContext() +} + +type Filegroup_updatability_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilegroup_updatability_optionContext() *Filegroup_updatability_optionContext { + var p = new(Filegroup_updatability_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_filegroup_updatability_option + return p +} + +func InitEmptyFilegroup_updatability_optionContext(p *Filegroup_updatability_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_filegroup_updatability_option +} + +func (*Filegroup_updatability_optionContext) IsFilegroup_updatability_optionContext() {} + +func NewFilegroup_updatability_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Filegroup_updatability_optionContext { + var p = new(Filegroup_updatability_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_filegroup_updatability_option + + return p +} + +func (s *Filegroup_updatability_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Filegroup_updatability_optionContext) READONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserREADONLY, 0) +} + +func (s *Filegroup_updatability_optionContext) READWRITE() antlr.TerminalNode { + return s.GetToken(TSqlParserREADWRITE, 0) +} + +func (s *Filegroup_updatability_optionContext) READ_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_ONLY, 0) +} + +func (s *Filegroup_updatability_optionContext) READ_WRITE() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_WRITE, 0) +} + +func (s *Filegroup_updatability_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Filegroup_updatability_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Filegroup_updatability_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFilegroup_updatability_option(s) + } +} + +func (s *Filegroup_updatability_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFilegroup_updatability_option(s) + } +} + +func (s *Filegroup_updatability_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFilegroup_updatability_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Filegroup_updatability_option() (localctx IFilegroup_updatability_optionContext) { + localctx = NewFilegroup_updatability_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 628, TSqlParserRULE_filegroup_updatability_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8293) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-770)) & ^0x3f) == 0 && ((int64(1)<<(_la-770))&337) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatabase_optionspecContext is an interface to support dynamic dispatch. +type IDatabase_optionspecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Auto_option() IAuto_optionContext + Change_tracking_option() IChange_tracking_optionContext + Containment_option() IContainment_optionContext + Cursor_option() ICursor_optionContext + Database_mirroring_option() IDatabase_mirroring_optionContext + Date_correlation_optimization_option() IDate_correlation_optimization_optionContext + Db_encryption_option() IDb_encryption_optionContext + Db_state_option() IDb_state_optionContext + Db_update_option() IDb_update_optionContext + Db_user_access_option() IDb_user_access_optionContext + Delayed_durability_option() IDelayed_durability_optionContext + External_access_option() IExternal_access_optionContext + FILESTREAM() antlr.TerminalNode + Database_filestream_option() IDatabase_filestream_optionContext + Hadr_options() IHadr_optionsContext + Mixed_page_allocation_option() IMixed_page_allocation_optionContext + Parameterization_option() IParameterization_optionContext + Recovery_option() IRecovery_optionContext + Service_broker_option() IService_broker_optionContext + Snapshot_option() ISnapshot_optionContext + Sql_option() ISql_optionContext + Target_recovery_time_option() ITarget_recovery_time_optionContext + Termination() ITerminationContext + + // IsDatabase_optionspecContext differentiates from other interfaces. + IsDatabase_optionspecContext() +} + +type Database_optionspecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_optionspecContext() *Database_optionspecContext { + var p = new(Database_optionspecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_database_optionspec + return p +} + +func InitEmptyDatabase_optionspecContext(p *Database_optionspecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_database_optionspec +} + +func (*Database_optionspecContext) IsDatabase_optionspecContext() {} + +func NewDatabase_optionspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_optionspecContext { + var p = new(Database_optionspecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_database_optionspec + + return p +} + +func (s *Database_optionspecContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_optionspecContext) Auto_option() IAuto_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuto_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuto_optionContext) +} + +func (s *Database_optionspecContext) Change_tracking_option() IChange_tracking_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChange_tracking_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChange_tracking_optionContext) +} + +func (s *Database_optionspecContext) Containment_option() IContainment_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainment_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainment_optionContext) +} + +func (s *Database_optionspecContext) Cursor_option() ICursor_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_optionContext) +} + +func (s *Database_optionspecContext) Database_mirroring_option() IDatabase_mirroring_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_mirroring_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_mirroring_optionContext) +} + +func (s *Database_optionspecContext) Date_correlation_optimization_option() IDate_correlation_optimization_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDate_correlation_optimization_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDate_correlation_optimization_optionContext) +} + +func (s *Database_optionspecContext) Db_encryption_option() IDb_encryption_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDb_encryption_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDb_encryption_optionContext) +} + +func (s *Database_optionspecContext) Db_state_option() IDb_state_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDb_state_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDb_state_optionContext) +} + +func (s *Database_optionspecContext) Db_update_option() IDb_update_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDb_update_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDb_update_optionContext) +} + +func (s *Database_optionspecContext) Db_user_access_option() IDb_user_access_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDb_user_access_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDb_user_access_optionContext) +} + +func (s *Database_optionspecContext) Delayed_durability_option() IDelayed_durability_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelayed_durability_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelayed_durability_optionContext) +} + +func (s *Database_optionspecContext) External_access_option() IExternal_access_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_access_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_access_optionContext) +} + +func (s *Database_optionspecContext) FILESTREAM() antlr.TerminalNode { + return s.GetToken(TSqlParserFILESTREAM, 0) +} + +func (s *Database_optionspecContext) Database_filestream_option() IDatabase_filestream_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_filestream_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_filestream_optionContext) +} + +func (s *Database_optionspecContext) Hadr_options() IHadr_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHadr_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHadr_optionsContext) +} + +func (s *Database_optionspecContext) Mixed_page_allocation_option() IMixed_page_allocation_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMixed_page_allocation_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMixed_page_allocation_optionContext) +} + +func (s *Database_optionspecContext) Parameterization_option() IParameterization_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterization_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameterization_optionContext) +} + +func (s *Database_optionspecContext) Recovery_option() IRecovery_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRecovery_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRecovery_optionContext) +} + +func (s *Database_optionspecContext) Service_broker_option() IService_broker_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IService_broker_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IService_broker_optionContext) +} + +func (s *Database_optionspecContext) Snapshot_option() ISnapshot_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISnapshot_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISnapshot_optionContext) +} + +func (s *Database_optionspecContext) Sql_option() ISql_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_optionContext) +} + +func (s *Database_optionspecContext) Target_recovery_time_option() ITarget_recovery_time_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITarget_recovery_time_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITarget_recovery_time_optionContext) +} + +func (s *Database_optionspecContext) Termination() ITerminationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITerminationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITerminationContext) +} + +func (s *Database_optionspecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_optionspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_optionspecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDatabase_optionspec(s) + } +} + +func (s *Database_optionspecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDatabase_optionspec(s) + } +} + +func (s *Database_optionspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDatabase_optionspec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Database_optionspec() (localctx IDatabase_optionspecContext) { + localctx = NewDatabase_optionspecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 630, TSqlParserRULE_database_optionspec) + p.SetState(8318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1062, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8295) + p.Auto_option() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8296) + p.Change_tracking_option() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8297) + p.Containment_option() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8298) + p.Cursor_option() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(8299) + p.Database_mirroring_option() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(8300) + p.Date_correlation_optimization_option() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(8301) + p.Db_encryption_option() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(8302) + p.Db_state_option() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(8303) + p.Db_update_option() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(8304) + p.Db_user_access_option() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(8305) + p.Delayed_durability_option() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(8306) + p.External_access_option() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(8307) + p.Match(TSqlParserFILESTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8308) + p.Database_filestream_option() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(8309) + p.Hadr_options() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(8310) + p.Mixed_page_allocation_option() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(8311) + p.Parameterization_option() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(8312) + p.Recovery_option() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(8313) + p.Service_broker_option() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(8314) + p.Snapshot_option() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(8315) + p.Sql_option() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(8316) + p.Target_recovery_time_option() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(8317) + p.Termination() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAuto_optionContext is an interface to support dynamic dispatch. +type IAuto_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUTO_CLOSE() antlr.TerminalNode + On_off() IOn_offContext + AUTO_CREATE_STATISTICS() antlr.TerminalNode + OFF() antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + INCREMENTAL() antlr.TerminalNode + EQUAL() antlr.TerminalNode + AUTO_SHRINK() antlr.TerminalNode + AUTO_UPDATE_STATISTICS() antlr.TerminalNode + AUTO_UPDATE_STATISTICS_ASYNC() antlr.TerminalNode + + // IsAuto_optionContext differentiates from other interfaces. + IsAuto_optionContext() +} + +type Auto_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAuto_optionContext() *Auto_optionContext { + var p = new(Auto_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_auto_option + return p +} + +func InitEmptyAuto_optionContext(p *Auto_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_auto_option +} + +func (*Auto_optionContext) IsAuto_optionContext() {} + +func NewAuto_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Auto_optionContext { + var p = new(Auto_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_auto_option + + return p +} + +func (s *Auto_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Auto_optionContext) AUTO_CLOSE() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_CLOSE, 0) +} + +func (s *Auto_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Auto_optionContext) AUTO_CREATE_STATISTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_CREATE_STATISTICS, 0) +} + +func (s *Auto_optionContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Auto_optionContext) AllON() []antlr.TerminalNode { + return s.GetTokens(TSqlParserON) +} + +func (s *Auto_optionContext) ON(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserON, i) +} + +func (s *Auto_optionContext) INCREMENTAL() antlr.TerminalNode { + return s.GetToken(TSqlParserINCREMENTAL, 0) +} + +func (s *Auto_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Auto_optionContext) AUTO_SHRINK() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_SHRINK, 0) +} + +func (s *Auto_optionContext) AUTO_UPDATE_STATISTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_UPDATE_STATISTICS, 0) +} + +func (s *Auto_optionContext) AUTO_UPDATE_STATISTICS_ASYNC() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, 0) +} + +func (s *Auto_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Auto_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Auto_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAuto_option(s) + } +} + +func (s *Auto_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAuto_option(s) + } +} + +func (s *Auto_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAuto_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Auto_option() (localctx IAuto_optionContext) { + localctx = NewAuto_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 632, TSqlParserRULE_auto_option) + var _la int + + p.SetState(8337) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAUTO_CLOSE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8320) + p.Match(TSqlParserAUTO_CLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8321) + p.On_off() + } + + case TSqlParserAUTO_CREATE_STATISTICS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8322) + p.Match(TSqlParserAUTO_CREATE_STATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8323) + p.Match(TSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserON: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8324) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8329) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserINCREMENTAL: + { + p.SetState(8325) + p.Match(TSqlParserINCREMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8326) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8327) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserOFF: + { + p.SetState(8328) + p.Match(TSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserAUTO_SHRINK: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8331) + p.Match(TSqlParserAUTO_SHRINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8332) + p.On_off() + } + + case TSqlParserAUTO_UPDATE_STATISTICS: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(8333) + p.Match(TSqlParserAUTO_UPDATE_STATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8334) + p.On_off() + } + + case TSqlParserAUTO_UPDATE_STATISTICS_ASYNC: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(8335) + p.Match(TSqlParserAUTO_UPDATE_STATISTICS_ASYNC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8336) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IChange_tracking_optionContext is an interface to support dynamic dispatch. +type IChange_tracking_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHANGE_TRACKING() antlr.TerminalNode + EQUAL() antlr.TerminalNode + OFF() antlr.TerminalNode + ON() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllChange_tracking_option_list() []IChange_tracking_option_listContext + Change_tracking_option_list(i int) IChange_tracking_option_listContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsChange_tracking_optionContext differentiates from other interfaces. + IsChange_tracking_optionContext() +} + +type Change_tracking_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyChange_tracking_optionContext() *Change_tracking_optionContext { + var p = new(Change_tracking_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_change_tracking_option + return p +} + +func InitEmptyChange_tracking_optionContext(p *Change_tracking_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_change_tracking_option +} + +func (*Change_tracking_optionContext) IsChange_tracking_optionContext() {} + +func NewChange_tracking_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Change_tracking_optionContext { + var p = new(Change_tracking_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_change_tracking_option + + return p +} + +func (s *Change_tracking_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Change_tracking_optionContext) CHANGE_TRACKING() antlr.TerminalNode { + return s.GetToken(TSqlParserCHANGE_TRACKING, 0) +} + +func (s *Change_tracking_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Change_tracking_optionContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Change_tracking_optionContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Change_tracking_optionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Change_tracking_optionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Change_tracking_optionContext) AllChange_tracking_option_list() []IChange_tracking_option_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IChange_tracking_option_listContext); ok { + len++ + } + } + + tst := make([]IChange_tracking_option_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IChange_tracking_option_listContext); ok { + tst[i] = t.(IChange_tracking_option_listContext) + i++ + } + } + + return tst +} + +func (s *Change_tracking_optionContext) Change_tracking_option_list(i int) IChange_tracking_option_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChange_tracking_option_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IChange_tracking_option_listContext) +} + +func (s *Change_tracking_optionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Change_tracking_optionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Change_tracking_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Change_tracking_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Change_tracking_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterChange_tracking_option(s) + } +} + +func (s *Change_tracking_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitChange_tracking_option(s) + } +} + +func (s *Change_tracking_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitChange_tracking_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Change_tracking_option() (localctx IChange_tracking_optionContext) { + localctx = NewChange_tracking_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 634, TSqlParserRULE_change_tracking_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8339) + p.Match(TSqlParserCHANGE_TRACKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8340) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserOFF: + { + p.SetState(8341) + p.Match(TSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserON: + { + p.SetState(8342) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8343) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8354) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserAUTO_CLEANUP || _la == TSqlParserCHANGE_RETENTION { + { + p.SetState(8344) + p.Change_tracking_option_list() + } + p.SetState(8349) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8345) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8346) + p.Change_tracking_option_list() + } + + p.SetState(8351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + p.SetState(8356) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8357) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IChange_tracking_option_listContext is an interface to support dynamic dispatch. +type IChange_tracking_option_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUTO_CLEANUP() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + CHANGE_RETENTION() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + DAYS() antlr.TerminalNode + HOURS() antlr.TerminalNode + MINUTES() antlr.TerminalNode + + // IsChange_tracking_option_listContext differentiates from other interfaces. + IsChange_tracking_option_listContext() +} + +type Change_tracking_option_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyChange_tracking_option_listContext() *Change_tracking_option_listContext { + var p = new(Change_tracking_option_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_change_tracking_option_list + return p +} + +func InitEmptyChange_tracking_option_listContext(p *Change_tracking_option_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_change_tracking_option_list +} + +func (*Change_tracking_option_listContext) IsChange_tracking_option_listContext() {} + +func NewChange_tracking_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Change_tracking_option_listContext { + var p = new(Change_tracking_option_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_change_tracking_option_list + + return p +} + +func (s *Change_tracking_option_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Change_tracking_option_listContext) AUTO_CLEANUP() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_CLEANUP, 0) +} + +func (s *Change_tracking_option_listContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Change_tracking_option_listContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Change_tracking_option_listContext) CHANGE_RETENTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCHANGE_RETENTION, 0) +} + +func (s *Change_tracking_option_listContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Change_tracking_option_listContext) DAYS() antlr.TerminalNode { + return s.GetToken(TSqlParserDAYS, 0) +} + +func (s *Change_tracking_option_listContext) HOURS() antlr.TerminalNode { + return s.GetToken(TSqlParserHOURS, 0) +} + +func (s *Change_tracking_option_listContext) MINUTES() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUTES, 0) +} + +func (s *Change_tracking_option_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Change_tracking_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Change_tracking_option_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterChange_tracking_option_list(s) + } +} + +func (s *Change_tracking_option_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitChange_tracking_option_list(s) + } +} + +func (s *Change_tracking_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitChange_tracking_option_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Change_tracking_option_list() (localctx IChange_tracking_option_listContext) { + localctx = NewChange_tracking_option_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 636, TSqlParserRULE_change_tracking_option_list) + var _la int + + p.SetState(8367) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAUTO_CLEANUP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8360) + p.Match(TSqlParserAUTO_CLEANUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8361) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8362) + p.On_off() + } + + case TSqlParserCHANGE_RETENTION: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8363) + p.Match(TSqlParserCHANGE_RETENTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8364) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8365) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8366) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDAYS || _la == TSqlParserHOURS || _la == TSqlParserMINUTES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IContainment_optionContext is an interface to support dynamic dispatch. +type IContainment_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONTAINMENT() antlr.TerminalNode + EQUAL() antlr.TerminalNode + NONE() antlr.TerminalNode + PARTIAL() antlr.TerminalNode + + // IsContainment_optionContext differentiates from other interfaces. + IsContainment_optionContext() +} + +type Containment_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContainment_optionContext() *Containment_optionContext { + var p = new(Containment_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_containment_option + return p +} + +func InitEmptyContainment_optionContext(p *Containment_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_containment_option +} + +func (*Containment_optionContext) IsContainment_optionContext() {} + +func NewContainment_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Containment_optionContext { + var p = new(Containment_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_containment_option + + return p +} + +func (s *Containment_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Containment_optionContext) CONTAINMENT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTAINMENT, 0) +} + +func (s *Containment_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Containment_optionContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Containment_optionContext) PARTIAL() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTIAL, 0) +} + +func (s *Containment_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Containment_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Containment_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterContainment_option(s) + } +} + +func (s *Containment_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitContainment_option(s) + } +} + +func (s *Containment_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitContainment_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Containment_option() (localctx IContainment_optionContext) { + localctx = NewContainment_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 638, TSqlParserRULE_containment_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8369) + p.Match(TSqlParserCONTAINMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8370) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8371) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNONE || _la == TSqlParserPARTIAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICursor_optionContext is an interface to support dynamic dispatch. +type ICursor_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CURSOR_CLOSE_ON_COMMIT() antlr.TerminalNode + On_off() IOn_offContext + CURSOR_DEFAULT() antlr.TerminalNode + LOCAL() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + + // IsCursor_optionContext differentiates from other interfaces. + IsCursor_optionContext() +} + +type Cursor_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_optionContext() *Cursor_optionContext { + var p = new(Cursor_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_cursor_option + return p +} + +func InitEmptyCursor_optionContext(p *Cursor_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_cursor_option +} + +func (*Cursor_optionContext) IsCursor_optionContext() {} + +func NewCursor_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_optionContext { + var p = new(Cursor_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_cursor_option + + return p +} + +func (s *Cursor_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_optionContext) CURSOR_CLOSE_ON_COMMIT() antlr.TerminalNode { + return s.GetToken(TSqlParserCURSOR_CLOSE_ON_COMMIT, 0) +} + +func (s *Cursor_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Cursor_optionContext) CURSOR_DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserCURSOR_DEFAULT, 0) +} + +func (s *Cursor_optionContext) LOCAL() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL, 0) +} + +func (s *Cursor_optionContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(TSqlParserGLOBAL, 0) +} + +func (s *Cursor_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCursor_option(s) + } +} + +func (s *Cursor_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCursor_option(s) + } +} + +func (s *Cursor_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCursor_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Cursor_option() (localctx ICursor_optionContext) { + localctx = NewCursor_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 640, TSqlParserRULE_cursor_option) + var _la int + + p.SetState(8377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCURSOR_CLOSE_ON_COMMIT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8373) + p.Match(TSqlParserCURSOR_CLOSE_ON_COMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8374) + p.On_off() + } + + case TSqlParserCURSOR_DEFAULT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8375) + p.Match(TSqlParserCURSOR_DEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8376) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserGLOBAL || _la == TSqlParserLOCAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_endpointContext is an interface to support dynamic dispatch. +type IAlter_endpointContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetState returns the state token. + GetState() antlr.Token + + // SetState sets the state token. + SetState(antlr.Token) + + // GetEndpointname returns the endpointname rule contexts. + GetEndpointname() IId_Context + + // GetLogin returns the login rule contexts. + GetLogin() IId_Context + + // SetEndpointname sets the endpointname rule contexts. + SetEndpointname(IId_Context) + + // SetLogin sets the login rule contexts. + SetLogin(IId_Context) + + // Getter signatures + ALTER() antlr.TerminalNode + ENDPOINT() antlr.TerminalNode + AS() antlr.TerminalNode + TCP() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + Endpoint_listener_clause() IEndpoint_listener_clauseContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + FOR() antlr.TerminalNode + TSQL() antlr.TerminalNode + SERVICE_BROKER() antlr.TerminalNode + Endpoint_authentication_clause() IEndpoint_authentication_clauseContext + DATABASE_MIRRORING() antlr.TerminalNode + ROLE() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + STATE() antlr.TerminalNode + WITNESS() antlr.TerminalNode + PARTNER() antlr.TerminalNode + ALL() antlr.TerminalNode + STARTED() antlr.TerminalNode + STOPPED() antlr.TerminalNode + AllDISABLED() []antlr.TerminalNode + DISABLED(i int) antlr.TerminalNode + Endpoint_encryption_alogorithm_clause() IEndpoint_encryption_alogorithm_clauseContext + MESSAGE_FORWARDING() antlr.TerminalNode + MESSAGE_FORWARD_SIZE() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ENABLED() antlr.TerminalNode + + // IsAlter_endpointContext differentiates from other interfaces. + IsAlter_endpointContext() +} + +type Alter_endpointContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + endpointname IId_Context + login IId_Context + state antlr.Token +} + +func NewEmptyAlter_endpointContext() *Alter_endpointContext { + var p = new(Alter_endpointContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_endpoint + return p +} + +func InitEmptyAlter_endpointContext(p *Alter_endpointContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_endpoint +} + +func (*Alter_endpointContext) IsAlter_endpointContext() {} + +func NewAlter_endpointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_endpointContext { + var p = new(Alter_endpointContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_endpoint + + return p +} + +func (s *Alter_endpointContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_endpointContext) GetState() antlr.Token { return s.state } + +func (s *Alter_endpointContext) SetState(v antlr.Token) { s.state = v } + +func (s *Alter_endpointContext) GetEndpointname() IId_Context { return s.endpointname } + +func (s *Alter_endpointContext) GetLogin() IId_Context { return s.login } + +func (s *Alter_endpointContext) SetEndpointname(v IId_Context) { s.endpointname = v } + +func (s *Alter_endpointContext) SetLogin(v IId_Context) { s.login = v } + +func (s *Alter_endpointContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Alter_endpointContext) ENDPOINT() antlr.TerminalNode { + return s.GetToken(TSqlParserENDPOINT, 0) +} + +func (s *Alter_endpointContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Alter_endpointContext) TCP() antlr.TerminalNode { + return s.GetToken(TSqlParserTCP, 0) +} + +func (s *Alter_endpointContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Alter_endpointContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Alter_endpointContext) Endpoint_listener_clause() IEndpoint_listener_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEndpoint_listener_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEndpoint_listener_clauseContext) +} + +func (s *Alter_endpointContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Alter_endpointContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Alter_endpointContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_endpointContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_endpointContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Alter_endpointContext) TSQL() antlr.TerminalNode { + return s.GetToken(TSqlParserTSQL, 0) +} + +func (s *Alter_endpointContext) SERVICE_BROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE_BROKER, 0) +} + +func (s *Alter_endpointContext) Endpoint_authentication_clause() IEndpoint_authentication_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEndpoint_authentication_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEndpoint_authentication_clauseContext) +} + +func (s *Alter_endpointContext) DATABASE_MIRRORING() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE_MIRRORING, 0) +} + +func (s *Alter_endpointContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Alter_endpointContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Alter_endpointContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Alter_endpointContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Alter_endpointContext) STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATE, 0) +} + +func (s *Alter_endpointContext) WITNESS() antlr.TerminalNode { + return s.GetToken(TSqlParserWITNESS, 0) +} + +func (s *Alter_endpointContext) PARTNER() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTNER, 0) +} + +func (s *Alter_endpointContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Alter_endpointContext) STARTED() antlr.TerminalNode { + return s.GetToken(TSqlParserSTARTED, 0) +} + +func (s *Alter_endpointContext) STOPPED() antlr.TerminalNode { + return s.GetToken(TSqlParserSTOPPED, 0) +} + +func (s *Alter_endpointContext) AllDISABLED() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDISABLED) +} + +func (s *Alter_endpointContext) DISABLED(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLED, i) +} + +func (s *Alter_endpointContext) Endpoint_encryption_alogorithm_clause() IEndpoint_encryption_alogorithm_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEndpoint_encryption_alogorithm_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEndpoint_encryption_alogorithm_clauseContext) +} + +func (s *Alter_endpointContext) MESSAGE_FORWARDING() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE_FORWARDING, 0) +} + +func (s *Alter_endpointContext) MESSAGE_FORWARD_SIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE_FORWARD_SIZE, 0) +} + +func (s *Alter_endpointContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Alter_endpointContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_endpointContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_endpointContext) ENABLED() antlr.TerminalNode { + return s.GetToken(TSqlParserENABLED, 0) +} + +func (s *Alter_endpointContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_endpointContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_endpointContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_endpoint(s) + } +} + +func (s *Alter_endpointContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_endpoint(s) + } +} + +func (s *Alter_endpointContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_endpoint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_endpoint() (localctx IAlter_endpointContext) { + localctx = NewAlter_endpointContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 642, TSqlParserRULE_alter_endpoint) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8379) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8380) + p.Match(TSqlParserENDPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8381) + + var _x = p.Id_() + + localctx.(*Alter_endpointContext).endpointname = _x + } + p.SetState(8384) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(8382) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8383) + + var _x = p.Id_() + + localctx.(*Alter_endpointContext).login = _x + } + + } + p.SetState(8389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSTATE { + { + p.SetState(8386) + p.Match(TSqlParserSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8387) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8388) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Alter_endpointContext).state = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISABLED || _la == TSqlParserSTARTED || _la == TSqlParserSTOPPED) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Alter_endpointContext).state = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(8391) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8392) + p.Match(TSqlParserTCP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8393) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8394) + p.Endpoint_listener_clause() + } + { + p.SetState(8395) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8446) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1081, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8396) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8397) + p.Match(TSqlParserTSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8398) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8399) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(8400) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8401) + p.Match(TSqlParserSERVICE_BROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8402) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8403) + p.Endpoint_authentication_clause() + } + p.SetState(8408) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1073, p.GetParserRuleContext()) == 1 { + p.SetState(8405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(8404) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8407) + p.Endpoint_encryption_alogorithm_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8416) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1075, p.GetParserRuleContext()) == 1 { + p.SetState(8411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(8410) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8413) + p.Match(TSqlParserMESSAGE_FORWARDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8414) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8415) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISABLED || _la == TSqlParserENABLED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMESSAGE_FORWARD_SIZE || _la == TSqlParserCOMMA { + p.SetState(8419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(8418) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8421) + p.Match(TSqlParserMESSAGE_FORWARD_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8422) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8423) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8426) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(8428) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8429) + p.Match(TSqlParserDATABASE_MIRRORING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8430) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8431) + p.Endpoint_authentication_clause() + } + p.SetState(8436) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1079, p.GetParserRuleContext()) == 1 { + p.SetState(8433) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(8432) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8435) + p.Endpoint_encryption_alogorithm_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(8438) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8441) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8442) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8443) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALL || _la == TSqlParserPARTNER || _la == TSqlParserWITNESS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8444) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatabase_mirroring_optionContext is an interface to support dynamic dispatch. +type IDatabase_mirroring_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Mirroring_set_option() IMirroring_set_optionContext + + // IsDatabase_mirroring_optionContext differentiates from other interfaces. + IsDatabase_mirroring_optionContext() +} + +type Database_mirroring_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_mirroring_optionContext() *Database_mirroring_optionContext { + var p = new(Database_mirroring_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_database_mirroring_option + return p +} + +func InitEmptyDatabase_mirroring_optionContext(p *Database_mirroring_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_database_mirroring_option +} + +func (*Database_mirroring_optionContext) IsDatabase_mirroring_optionContext() {} + +func NewDatabase_mirroring_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_mirroring_optionContext { + var p = new(Database_mirroring_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_database_mirroring_option + + return p +} + +func (s *Database_mirroring_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_mirroring_optionContext) Mirroring_set_option() IMirroring_set_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMirroring_set_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMirroring_set_optionContext) +} + +func (s *Database_mirroring_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_mirroring_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_mirroring_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDatabase_mirroring_option(s) + } +} + +func (s *Database_mirroring_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDatabase_mirroring_option(s) + } +} + +func (s *Database_mirroring_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDatabase_mirroring_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Database_mirroring_option() (localctx IDatabase_mirroring_optionContext) { + localctx = NewDatabase_mirroring_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 644, TSqlParserRULE_database_mirroring_option) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8448) + p.Mirroring_set_option() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMirroring_set_optionContext is an interface to support dynamic dispatch. +type IMirroring_set_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Mirroring_partner() IMirroring_partnerContext + Partner_option() IPartner_optionContext + Mirroring_witness() IMirroring_witnessContext + Witness_option() IWitness_optionContext + + // IsMirroring_set_optionContext differentiates from other interfaces. + IsMirroring_set_optionContext() +} + +type Mirroring_set_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMirroring_set_optionContext() *Mirroring_set_optionContext { + var p = new(Mirroring_set_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_mirroring_set_option + return p +} + +func InitEmptyMirroring_set_optionContext(p *Mirroring_set_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_mirroring_set_option +} + +func (*Mirroring_set_optionContext) IsMirroring_set_optionContext() {} + +func NewMirroring_set_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mirroring_set_optionContext { + var p = new(Mirroring_set_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_mirroring_set_option + + return p +} + +func (s *Mirroring_set_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Mirroring_set_optionContext) Mirroring_partner() IMirroring_partnerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMirroring_partnerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMirroring_partnerContext) +} + +func (s *Mirroring_set_optionContext) Partner_option() IPartner_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartner_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartner_optionContext) +} + +func (s *Mirroring_set_optionContext) Mirroring_witness() IMirroring_witnessContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMirroring_witnessContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMirroring_witnessContext) +} + +func (s *Mirroring_set_optionContext) Witness_option() IWitness_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWitness_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWitness_optionContext) +} + +func (s *Mirroring_set_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Mirroring_set_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Mirroring_set_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMirroring_set_option(s) + } +} + +func (s *Mirroring_set_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMirroring_set_option(s) + } +} + +func (s *Mirroring_set_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMirroring_set_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Mirroring_set_option() (localctx IMirroring_set_optionContext) { + localctx = NewMirroring_set_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 646, TSqlParserRULE_mirroring_set_option) + p.SetState(8456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPARTNER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8450) + p.Mirroring_partner() + } + { + p.SetState(8451) + p.Partner_option() + } + + case TSqlParserWITNESS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8453) + p.Mirroring_witness() + } + { + p.SetState(8454) + p.Witness_option() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMirroring_partnerContext is an interface to support dynamic dispatch. +type IMirroring_partnerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTNER() antlr.TerminalNode + + // IsMirroring_partnerContext differentiates from other interfaces. + IsMirroring_partnerContext() +} + +type Mirroring_partnerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMirroring_partnerContext() *Mirroring_partnerContext { + var p = new(Mirroring_partnerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_mirroring_partner + return p +} + +func InitEmptyMirroring_partnerContext(p *Mirroring_partnerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_mirroring_partner +} + +func (*Mirroring_partnerContext) IsMirroring_partnerContext() {} + +func NewMirroring_partnerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mirroring_partnerContext { + var p = new(Mirroring_partnerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_mirroring_partner + + return p +} + +func (s *Mirroring_partnerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Mirroring_partnerContext) PARTNER() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTNER, 0) +} + +func (s *Mirroring_partnerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Mirroring_partnerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Mirroring_partnerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMirroring_partner(s) + } +} + +func (s *Mirroring_partnerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMirroring_partner(s) + } +} + +func (s *Mirroring_partnerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMirroring_partner(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Mirroring_partner() (localctx IMirroring_partnerContext) { + localctx = NewMirroring_partnerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 648, TSqlParserRULE_mirroring_partner) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8458) + p.Match(TSqlParserPARTNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMirroring_witnessContext is an interface to support dynamic dispatch. +type IMirroring_witnessContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITNESS() antlr.TerminalNode + + // IsMirroring_witnessContext differentiates from other interfaces. + IsMirroring_witnessContext() +} + +type Mirroring_witnessContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMirroring_witnessContext() *Mirroring_witnessContext { + var p = new(Mirroring_witnessContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_mirroring_witness + return p +} + +func InitEmptyMirroring_witnessContext(p *Mirroring_witnessContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_mirroring_witness +} + +func (*Mirroring_witnessContext) IsMirroring_witnessContext() {} + +func NewMirroring_witnessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mirroring_witnessContext { + var p = new(Mirroring_witnessContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_mirroring_witness + + return p +} + +func (s *Mirroring_witnessContext) GetParser() antlr.Parser { return s.parser } + +func (s *Mirroring_witnessContext) WITNESS() antlr.TerminalNode { + return s.GetToken(TSqlParserWITNESS, 0) +} + +func (s *Mirroring_witnessContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Mirroring_witnessContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Mirroring_witnessContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMirroring_witness(s) + } +} + +func (s *Mirroring_witnessContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMirroring_witness(s) + } +} + +func (s *Mirroring_witnessContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMirroring_witness(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Mirroring_witness() (localctx IMirroring_witnessContext) { + localctx = NewMirroring_witnessContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 650, TSqlParserRULE_mirroring_witness) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8460) + p.Match(TSqlParserWITNESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWitness_partner_equalContext is an interface to support dynamic dispatch. +type IWitness_partner_equalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQUAL() antlr.TerminalNode + + // IsWitness_partner_equalContext differentiates from other interfaces. + IsWitness_partner_equalContext() +} + +type Witness_partner_equalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWitness_partner_equalContext() *Witness_partner_equalContext { + var p = new(Witness_partner_equalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_witness_partner_equal + return p +} + +func InitEmptyWitness_partner_equalContext(p *Witness_partner_equalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_witness_partner_equal +} + +func (*Witness_partner_equalContext) IsWitness_partner_equalContext() {} + +func NewWitness_partner_equalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Witness_partner_equalContext { + var p = new(Witness_partner_equalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_witness_partner_equal + + return p +} + +func (s *Witness_partner_equalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Witness_partner_equalContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Witness_partner_equalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Witness_partner_equalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Witness_partner_equalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterWitness_partner_equal(s) + } +} + +func (s *Witness_partner_equalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitWitness_partner_equal(s) + } +} + +func (s *Witness_partner_equalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitWitness_partner_equal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Witness_partner_equal() (localctx IWitness_partner_equalContext) { + localctx = NewWitness_partner_equalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 652, TSqlParserRULE_witness_partner_equal) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8462) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartner_optionContext is an interface to support dynamic dispatch. +type IPartner_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Witness_partner_equal() IWitness_partner_equalContext + Partner_server() IPartner_serverContext + FAILOVER() antlr.TerminalNode + FORCE_SERVICE_ALLOW_DATA_LOSS() antlr.TerminalNode + OFF() antlr.TerminalNode + RESUME() antlr.TerminalNode + SAFETY() antlr.TerminalNode + FULL() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + TIMEOUT() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + + // IsPartner_optionContext differentiates from other interfaces. + IsPartner_optionContext() +} + +type Partner_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartner_optionContext() *Partner_optionContext { + var p = new(Partner_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_partner_option + return p +} + +func InitEmptyPartner_optionContext(p *Partner_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_partner_option +} + +func (*Partner_optionContext) IsPartner_optionContext() {} + +func NewPartner_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partner_optionContext { + var p = new(Partner_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_partner_option + + return p +} + +func (s *Partner_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partner_optionContext) Witness_partner_equal() IWitness_partner_equalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWitness_partner_equalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWitness_partner_equalContext) +} + +func (s *Partner_optionContext) Partner_server() IPartner_serverContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartner_serverContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartner_serverContext) +} + +func (s *Partner_optionContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(TSqlParserFAILOVER, 0) +} + +func (s *Partner_optionContext) FORCE_SERVICE_ALLOW_DATA_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, 0) +} + +func (s *Partner_optionContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Partner_optionContext) RESUME() antlr.TerminalNode { + return s.GetToken(TSqlParserRESUME, 0) +} + +func (s *Partner_optionContext) SAFETY() antlr.TerminalNode { + return s.GetToken(TSqlParserSAFETY, 0) +} + +func (s *Partner_optionContext) FULL() antlr.TerminalNode { + return s.GetToken(TSqlParserFULL, 0) +} + +func (s *Partner_optionContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(TSqlParserSUSPEND, 0) +} + +func (s *Partner_optionContext) TIMEOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserTIMEOUT, 0) +} + +func (s *Partner_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Partner_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partner_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partner_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPartner_option(s) + } +} + +func (s *Partner_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPartner_option(s) + } +} + +func (s *Partner_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPartner_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Partner_option() (localctx IPartner_optionContext) { + localctx = NewPartner_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 654, TSqlParserRULE_partner_option) + var _la int + + p.SetState(8476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserEQUAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8464) + p.Witness_partner_equal() + } + { + p.SetState(8465) + p.Partner_server() + } + + case TSqlParserFAILOVER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8467) + p.Match(TSqlParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8468) + p.Match(TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserOFF: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8469) + p.Match(TSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserRESUME: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(8470) + p.Match(TSqlParserRESUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSAFETY: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(8471) + p.Match(TSqlParserSAFETY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8472) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFULL || _la == TSqlParserOFF) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserSUSPEND: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(8473) + p.Match(TSqlParserSUSPEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTIMEOUT: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(8474) + p.Match(TSqlParserTIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8475) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWitness_optionContext is an interface to support dynamic dispatch. +type IWitness_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Witness_partner_equal() IWitness_partner_equalContext + Witness_server() IWitness_serverContext + OFF() antlr.TerminalNode + + // IsWitness_optionContext differentiates from other interfaces. + IsWitness_optionContext() +} + +type Witness_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWitness_optionContext() *Witness_optionContext { + var p = new(Witness_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_witness_option + return p +} + +func InitEmptyWitness_optionContext(p *Witness_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_witness_option +} + +func (*Witness_optionContext) IsWitness_optionContext() {} + +func NewWitness_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Witness_optionContext { + var p = new(Witness_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_witness_option + + return p +} + +func (s *Witness_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Witness_optionContext) Witness_partner_equal() IWitness_partner_equalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWitness_partner_equalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWitness_partner_equalContext) +} + +func (s *Witness_optionContext) Witness_server() IWitness_serverContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWitness_serverContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWitness_serverContext) +} + +func (s *Witness_optionContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Witness_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Witness_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Witness_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterWitness_option(s) + } +} + +func (s *Witness_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitWitness_option(s) + } +} + +func (s *Witness_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitWitness_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Witness_option() (localctx IWitness_optionContext) { + localctx = NewWitness_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 656, TSqlParserRULE_witness_option) + p.SetState(8482) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserEQUAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8478) + p.Witness_partner_equal() + } + { + p.SetState(8479) + p.Witness_server() + } + + case TSqlParserOFF: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8481) + p.Match(TSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWitness_serverContext is an interface to support dynamic dispatch. +type IWitness_serverContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Partner_server() IPartner_serverContext + + // IsWitness_serverContext differentiates from other interfaces. + IsWitness_serverContext() +} + +type Witness_serverContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWitness_serverContext() *Witness_serverContext { + var p = new(Witness_serverContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_witness_server + return p +} + +func InitEmptyWitness_serverContext(p *Witness_serverContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_witness_server +} + +func (*Witness_serverContext) IsWitness_serverContext() {} + +func NewWitness_serverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Witness_serverContext { + var p = new(Witness_serverContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_witness_server + + return p +} + +func (s *Witness_serverContext) GetParser() antlr.Parser { return s.parser } + +func (s *Witness_serverContext) Partner_server() IPartner_serverContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartner_serverContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartner_serverContext) +} + +func (s *Witness_serverContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Witness_serverContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Witness_serverContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterWitness_server(s) + } +} + +func (s *Witness_serverContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitWitness_server(s) + } +} + +func (s *Witness_serverContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitWitness_server(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Witness_server() (localctx IWitness_serverContext) { + localctx = NewWitness_serverContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 658, TSqlParserRULE_witness_server) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8484) + p.Partner_server() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartner_serverContext is an interface to support dynamic dispatch. +type IPartner_serverContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Partner_server_tcp_prefix() IPartner_server_tcp_prefixContext + Host() IHostContext + Mirroring_host_port_seperator() IMirroring_host_port_seperatorContext + Port_number() IPort_numberContext + + // IsPartner_serverContext differentiates from other interfaces. + IsPartner_serverContext() +} + +type Partner_serverContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartner_serverContext() *Partner_serverContext { + var p = new(Partner_serverContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_partner_server + return p +} + +func InitEmptyPartner_serverContext(p *Partner_serverContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_partner_server +} + +func (*Partner_serverContext) IsPartner_serverContext() {} + +func NewPartner_serverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partner_serverContext { + var p = new(Partner_serverContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_partner_server + + return p +} + +func (s *Partner_serverContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partner_serverContext) Partner_server_tcp_prefix() IPartner_server_tcp_prefixContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartner_server_tcp_prefixContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartner_server_tcp_prefixContext) +} + +func (s *Partner_serverContext) Host() IHostContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHostContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHostContext) +} + +func (s *Partner_serverContext) Mirroring_host_port_seperator() IMirroring_host_port_seperatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMirroring_host_port_seperatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMirroring_host_port_seperatorContext) +} + +func (s *Partner_serverContext) Port_number() IPort_numberContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPort_numberContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPort_numberContext) +} + +func (s *Partner_serverContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partner_serverContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partner_serverContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPartner_server(s) + } +} + +func (s *Partner_serverContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPartner_server(s) + } +} + +func (s *Partner_serverContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPartner_server(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Partner_server() (localctx IPartner_serverContext) { + localctx = NewPartner_serverContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 660, TSqlParserRULE_partner_server) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8486) + p.Partner_server_tcp_prefix() + } + { + p.SetState(8487) + p.Host() + } + { + p.SetState(8488) + p.Mirroring_host_port_seperator() + } + { + p.SetState(8489) + p.Port_number() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMirroring_host_port_seperatorContext is an interface to support dynamic dispatch. +type IMirroring_host_port_seperatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLON() antlr.TerminalNode + + // IsMirroring_host_port_seperatorContext differentiates from other interfaces. + IsMirroring_host_port_seperatorContext() +} + +type Mirroring_host_port_seperatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMirroring_host_port_seperatorContext() *Mirroring_host_port_seperatorContext { + var p = new(Mirroring_host_port_seperatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_mirroring_host_port_seperator + return p +} + +func InitEmptyMirroring_host_port_seperatorContext(p *Mirroring_host_port_seperatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_mirroring_host_port_seperator +} + +func (*Mirroring_host_port_seperatorContext) IsMirroring_host_port_seperatorContext() {} + +func NewMirroring_host_port_seperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mirroring_host_port_seperatorContext { + var p = new(Mirroring_host_port_seperatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_mirroring_host_port_seperator + + return p +} + +func (s *Mirroring_host_port_seperatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Mirroring_host_port_seperatorContext) COLON() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLON, 0) +} + +func (s *Mirroring_host_port_seperatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Mirroring_host_port_seperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Mirroring_host_port_seperatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMirroring_host_port_seperator(s) + } +} + +func (s *Mirroring_host_port_seperatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMirroring_host_port_seperator(s) + } +} + +func (s *Mirroring_host_port_seperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMirroring_host_port_seperator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Mirroring_host_port_seperator() (localctx IMirroring_host_port_seperatorContext) { + localctx = NewMirroring_host_port_seperatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 662, TSqlParserRULE_mirroring_host_port_seperator) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8491) + p.Match(TSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartner_server_tcp_prefixContext is an interface to support dynamic dispatch. +type IPartner_server_tcp_prefixContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TCP() antlr.TerminalNode + COLON() antlr.TerminalNode + DOUBLE_FORWARD_SLASH() antlr.TerminalNode + + // IsPartner_server_tcp_prefixContext differentiates from other interfaces. + IsPartner_server_tcp_prefixContext() +} + +type Partner_server_tcp_prefixContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartner_server_tcp_prefixContext() *Partner_server_tcp_prefixContext { + var p = new(Partner_server_tcp_prefixContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_partner_server_tcp_prefix + return p +} + +func InitEmptyPartner_server_tcp_prefixContext(p *Partner_server_tcp_prefixContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_partner_server_tcp_prefix +} + +func (*Partner_server_tcp_prefixContext) IsPartner_server_tcp_prefixContext() {} + +func NewPartner_server_tcp_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partner_server_tcp_prefixContext { + var p = new(Partner_server_tcp_prefixContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_partner_server_tcp_prefix + + return p +} + +func (s *Partner_server_tcp_prefixContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partner_server_tcp_prefixContext) TCP() antlr.TerminalNode { + return s.GetToken(TSqlParserTCP, 0) +} + +func (s *Partner_server_tcp_prefixContext) COLON() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLON, 0) +} + +func (s *Partner_server_tcp_prefixContext) DOUBLE_FORWARD_SLASH() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_FORWARD_SLASH, 0) +} + +func (s *Partner_server_tcp_prefixContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partner_server_tcp_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partner_server_tcp_prefixContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPartner_server_tcp_prefix(s) + } +} + +func (s *Partner_server_tcp_prefixContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPartner_server_tcp_prefix(s) + } +} + +func (s *Partner_server_tcp_prefixContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPartner_server_tcp_prefix(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Partner_server_tcp_prefix() (localctx IPartner_server_tcp_prefixContext) { + localctx = NewPartner_server_tcp_prefixContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 664, TSqlParserRULE_partner_server_tcp_prefix) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8493) + p.Match(TSqlParserTCP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8494) + p.Match(TSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8495) + p.Match(TSqlParserDOUBLE_FORWARD_SLASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPort_numberContext is an interface to support dynamic dispatch. +type IPort_numberContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPort returns the port token. + GetPort() antlr.Token + + // SetPort sets the port token. + SetPort(antlr.Token) + + // Getter signatures + DECIMAL() antlr.TerminalNode + + // IsPort_numberContext differentiates from other interfaces. + IsPort_numberContext() +} + +type Port_numberContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + port antlr.Token +} + +func NewEmptyPort_numberContext() *Port_numberContext { + var p = new(Port_numberContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_port_number + return p +} + +func InitEmptyPort_numberContext(p *Port_numberContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_port_number +} + +func (*Port_numberContext) IsPort_numberContext() {} + +func NewPort_numberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Port_numberContext { + var p = new(Port_numberContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_port_number + + return p +} + +func (s *Port_numberContext) GetParser() antlr.Parser { return s.parser } + +func (s *Port_numberContext) GetPort() antlr.Token { return s.port } + +func (s *Port_numberContext) SetPort(v antlr.Token) { s.port = v } + +func (s *Port_numberContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Port_numberContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Port_numberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Port_numberContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPort_number(s) + } +} + +func (s *Port_numberContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPort_number(s) + } +} + +func (s *Port_numberContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPort_number(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Port_number() (localctx IPort_numberContext) { + localctx = NewPort_numberContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 666, TSqlParserRULE_port_number) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8497) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Port_numberContext).port = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHostContext is an interface to support dynamic dispatch. +type IHostContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + DOT() antlr.TerminalNode + Host() IHostContext + + // IsHostContext differentiates from other interfaces. + IsHostContext() +} + +type HostContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHostContext() *HostContext { + var p = new(HostContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_host + return p +} + +func InitEmptyHostContext(p *HostContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_host +} + +func (*HostContext) IsHostContext() {} + +func NewHostContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HostContext { + var p = new(HostContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_host + + return p +} + +func (s *HostContext) GetParser() antlr.Parser { return s.parser } + +func (s *HostContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *HostContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *HostContext) Host() IHostContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHostContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHostContext) +} + +func (s *HostContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HostContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HostContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterHost(s) + } +} + +func (s *HostContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitHost(s) + } +} + +func (s *HostContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitHost(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Host() (localctx IHostContext) { + localctx = NewHostContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 668, TSqlParserRULE_host) + p.SetState(8509) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1086, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8499) + p.Id_() + } + { + p.SetState(8500) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8501) + p.Host() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(8507) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1085, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8503) + p.Id_() + } + { + p.SetState(8504) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(8506) + p.Id_() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDate_correlation_optimization_optionContext is an interface to support dynamic dispatch. +type IDate_correlation_optimization_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATE_CORRELATION_OPTIMIZATION() antlr.TerminalNode + On_off() IOn_offContext + + // IsDate_correlation_optimization_optionContext differentiates from other interfaces. + IsDate_correlation_optimization_optionContext() +} + +type Date_correlation_optimization_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDate_correlation_optimization_optionContext() *Date_correlation_optimization_optionContext { + var p = new(Date_correlation_optimization_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_date_correlation_optimization_option + return p +} + +func InitEmptyDate_correlation_optimization_optionContext(p *Date_correlation_optimization_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_date_correlation_optimization_option +} + +func (*Date_correlation_optimization_optionContext) IsDate_correlation_optimization_optionContext() {} + +func NewDate_correlation_optimization_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Date_correlation_optimization_optionContext { + var p = new(Date_correlation_optimization_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_date_correlation_optimization_option + + return p +} + +func (s *Date_correlation_optimization_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Date_correlation_optimization_optionContext) DATE_CORRELATION_OPTIMIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserDATE_CORRELATION_OPTIMIZATION, 0) +} + +func (s *Date_correlation_optimization_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Date_correlation_optimization_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Date_correlation_optimization_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Date_correlation_optimization_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDate_correlation_optimization_option(s) + } +} + +func (s *Date_correlation_optimization_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDate_correlation_optimization_option(s) + } +} + +func (s *Date_correlation_optimization_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDate_correlation_optimization_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Date_correlation_optimization_option() (localctx IDate_correlation_optimization_optionContext) { + localctx = NewDate_correlation_optimization_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 670, TSqlParserRULE_date_correlation_optimization_option) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8511) + p.Match(TSqlParserDATE_CORRELATION_OPTIMIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8512) + p.On_off() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDb_encryption_optionContext is an interface to support dynamic dispatch. +type IDb_encryption_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTION() antlr.TerminalNode + On_off() IOn_offContext + + // IsDb_encryption_optionContext differentiates from other interfaces. + IsDb_encryption_optionContext() +} + +type Db_encryption_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDb_encryption_optionContext() *Db_encryption_optionContext { + var p = new(Db_encryption_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_db_encryption_option + return p +} + +func InitEmptyDb_encryption_optionContext(p *Db_encryption_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_db_encryption_option +} + +func (*Db_encryption_optionContext) IsDb_encryption_optionContext() {} + +func NewDb_encryption_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Db_encryption_optionContext { + var p = new(Db_encryption_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_db_encryption_option + + return p +} + +func (s *Db_encryption_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Db_encryption_optionContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Db_encryption_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Db_encryption_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Db_encryption_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Db_encryption_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDb_encryption_option(s) + } +} + +func (s *Db_encryption_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDb_encryption_option(s) + } +} + +func (s *Db_encryption_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDb_encryption_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Db_encryption_option() (localctx IDb_encryption_optionContext) { + localctx = NewDb_encryption_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 672, TSqlParserRULE_db_encryption_option) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8514) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8515) + p.On_off() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDb_state_optionContext is an interface to support dynamic dispatch. +type IDb_state_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + EMERGENCY() antlr.TerminalNode + + // IsDb_state_optionContext differentiates from other interfaces. + IsDb_state_optionContext() +} + +type Db_state_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDb_state_optionContext() *Db_state_optionContext { + var p = new(Db_state_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_db_state_option + return p +} + +func InitEmptyDb_state_optionContext(p *Db_state_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_db_state_option +} + +func (*Db_state_optionContext) IsDb_state_optionContext() {} + +func NewDb_state_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Db_state_optionContext { + var p = new(Db_state_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_db_state_option + + return p +} + +func (s *Db_state_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Db_state_optionContext) ONLINE() antlr.TerminalNode { + return s.GetToken(TSqlParserONLINE, 0) +} + +func (s *Db_state_optionContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(TSqlParserOFFLINE, 0) +} + +func (s *Db_state_optionContext) EMERGENCY() antlr.TerminalNode { + return s.GetToken(TSqlParserEMERGENCY, 0) +} + +func (s *Db_state_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Db_state_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Db_state_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDb_state_option(s) + } +} + +func (s *Db_state_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDb_state_option(s) + } +} + +func (s *Db_state_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDb_state_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Db_state_option() (localctx IDb_state_optionContext) { + localctx = NewDb_state_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 674, TSqlParserRULE_db_state_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8517) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserEMERGENCY || _la == TSqlParserOFFLINE || _la == TSqlParserONLINE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDb_update_optionContext is an interface to support dynamic dispatch. +type IDb_update_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + READ_ONLY() antlr.TerminalNode + READ_WRITE() antlr.TerminalNode + + // IsDb_update_optionContext differentiates from other interfaces. + IsDb_update_optionContext() +} + +type Db_update_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDb_update_optionContext() *Db_update_optionContext { + var p = new(Db_update_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_db_update_option + return p +} + +func InitEmptyDb_update_optionContext(p *Db_update_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_db_update_option +} + +func (*Db_update_optionContext) IsDb_update_optionContext() {} + +func NewDb_update_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Db_update_optionContext { + var p = new(Db_update_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_db_update_option + + return p +} + +func (s *Db_update_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Db_update_optionContext) READ_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_ONLY, 0) +} + +func (s *Db_update_optionContext) READ_WRITE() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_WRITE, 0) +} + +func (s *Db_update_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Db_update_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Db_update_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDb_update_option(s) + } +} + +func (s *Db_update_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDb_update_option(s) + } +} + +func (s *Db_update_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDb_update_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Db_update_option() (localctx IDb_update_optionContext) { + localctx = NewDb_update_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 676, TSqlParserRULE_db_update_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8519) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserREAD_ONLY || _la == TSqlParserREAD_WRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDb_user_access_optionContext is an interface to support dynamic dispatch. +type IDb_user_access_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SINGLE_USER() antlr.TerminalNode + RESTRICTED_USER() antlr.TerminalNode + MULTI_USER() antlr.TerminalNode + + // IsDb_user_access_optionContext differentiates from other interfaces. + IsDb_user_access_optionContext() +} + +type Db_user_access_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDb_user_access_optionContext() *Db_user_access_optionContext { + var p = new(Db_user_access_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_db_user_access_option + return p +} + +func InitEmptyDb_user_access_optionContext(p *Db_user_access_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_db_user_access_option +} + +func (*Db_user_access_optionContext) IsDb_user_access_optionContext() {} + +func NewDb_user_access_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Db_user_access_optionContext { + var p = new(Db_user_access_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_db_user_access_option + + return p +} + +func (s *Db_user_access_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Db_user_access_optionContext) SINGLE_USER() antlr.TerminalNode { + return s.GetToken(TSqlParserSINGLE_USER, 0) +} + +func (s *Db_user_access_optionContext) RESTRICTED_USER() antlr.TerminalNode { + return s.GetToken(TSqlParserRESTRICTED_USER, 0) +} + +func (s *Db_user_access_optionContext) MULTI_USER() antlr.TerminalNode { + return s.GetToken(TSqlParserMULTI_USER, 0) +} + +func (s *Db_user_access_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Db_user_access_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Db_user_access_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDb_user_access_option(s) + } +} + +func (s *Db_user_access_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDb_user_access_option(s) + } +} + +func (s *Db_user_access_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDb_user_access_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Db_user_access_option() (localctx IDb_user_access_optionContext) { + localctx = NewDb_user_access_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 678, TSqlParserRULE_db_user_access_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8521) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserMULTI_USER || _la == TSqlParserRESTRICTED_USER || _la == TSqlParserSINGLE_USER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDelayed_durability_optionContext is an interface to support dynamic dispatch. +type IDelayed_durability_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELAYED_DURABILITY() antlr.TerminalNode + EQUAL() antlr.TerminalNode + DISABLED() antlr.TerminalNode + ALLOWED() antlr.TerminalNode + FORCED() antlr.TerminalNode + + // IsDelayed_durability_optionContext differentiates from other interfaces. + IsDelayed_durability_optionContext() +} + +type Delayed_durability_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDelayed_durability_optionContext() *Delayed_durability_optionContext { + var p = new(Delayed_durability_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_delayed_durability_option + return p +} + +func InitEmptyDelayed_durability_optionContext(p *Delayed_durability_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_delayed_durability_option +} + +func (*Delayed_durability_optionContext) IsDelayed_durability_optionContext() {} + +func NewDelayed_durability_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delayed_durability_optionContext { + var p = new(Delayed_durability_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_delayed_durability_option + + return p +} + +func (s *Delayed_durability_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Delayed_durability_optionContext) DELAYED_DURABILITY() antlr.TerminalNode { + return s.GetToken(TSqlParserDELAYED_DURABILITY, 0) +} + +func (s *Delayed_durability_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Delayed_durability_optionContext) DISABLED() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLED, 0) +} + +func (s *Delayed_durability_optionContext) ALLOWED() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOWED, 0) +} + +func (s *Delayed_durability_optionContext) FORCED() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCED, 0) +} + +func (s *Delayed_durability_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Delayed_durability_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Delayed_durability_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDelayed_durability_option(s) + } +} + +func (s *Delayed_durability_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDelayed_durability_option(s) + } +} + +func (s *Delayed_durability_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDelayed_durability_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Delayed_durability_option() (localctx IDelayed_durability_optionContext) { + localctx = NewDelayed_durability_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 680, TSqlParserRULE_delayed_durability_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8523) + p.Match(TSqlParserDELAYED_DURABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8524) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8525) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALLOWED || _la == TSqlParserDISABLED || _la == TSqlParserFORCED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_access_optionContext is an interface to support dynamic dispatch. +type IExternal_access_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DB_CHAINING() antlr.TerminalNode + On_off() IOn_offContext + TRUSTWORTHY() antlr.TerminalNode + DEFAULT_LANGUAGE() antlr.TerminalNode + EQUAL() antlr.TerminalNode + Id_() IId_Context + STRING() antlr.TerminalNode + DEFAULT_FULLTEXT_LANGUAGE() antlr.TerminalNode + NESTED_TRIGGERS() antlr.TerminalNode + OFF() antlr.TerminalNode + ON() antlr.TerminalNode + TRANSFORM_NOISE_WORDS() antlr.TerminalNode + TWO_DIGIT_YEAR_CUTOFF() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + + // IsExternal_access_optionContext differentiates from other interfaces. + IsExternal_access_optionContext() +} + +type External_access_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_access_optionContext() *External_access_optionContext { + var p = new(External_access_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_external_access_option + return p +} + +func InitEmptyExternal_access_optionContext(p *External_access_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_external_access_option +} + +func (*External_access_optionContext) IsExternal_access_optionContext() {} + +func NewExternal_access_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_access_optionContext { + var p = new(External_access_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_external_access_option + + return p +} + +func (s *External_access_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_access_optionContext) DB_CHAINING() antlr.TerminalNode { + return s.GetToken(TSqlParserDB_CHAINING, 0) +} + +func (s *External_access_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *External_access_optionContext) TRUSTWORTHY() antlr.TerminalNode { + return s.GetToken(TSqlParserTRUSTWORTHY, 0) +} + +func (s *External_access_optionContext) DEFAULT_LANGUAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_LANGUAGE, 0) +} + +func (s *External_access_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *External_access_optionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *External_access_optionContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *External_access_optionContext) DEFAULT_FULLTEXT_LANGUAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_FULLTEXT_LANGUAGE, 0) +} + +func (s *External_access_optionContext) NESTED_TRIGGERS() antlr.TerminalNode { + return s.GetToken(TSqlParserNESTED_TRIGGERS, 0) +} + +func (s *External_access_optionContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *External_access_optionContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *External_access_optionContext) TRANSFORM_NOISE_WORDS() antlr.TerminalNode { + return s.GetToken(TSqlParserTRANSFORM_NOISE_WORDS, 0) +} + +func (s *External_access_optionContext) TWO_DIGIT_YEAR_CUTOFF() antlr.TerminalNode { + return s.GetToken(TSqlParserTWO_DIGIT_YEAR_CUTOFF, 0) +} + +func (s *External_access_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *External_access_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_access_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_access_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExternal_access_option(s) + } +} + +func (s *External_access_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExternal_access_option(s) + } +} + +func (s *External_access_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExternal_access_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) External_access_option() (localctx IExternal_access_optionContext) { + localctx = NewExternal_access_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 682, TSqlParserRULE_external_access_option) + var _la int + + p.SetState(8552) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDB_CHAINING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8527) + p.Match(TSqlParserDB_CHAINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8528) + p.On_off() + } + + case TSqlParserTRUSTWORTHY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8529) + p.Match(TSqlParserTRUSTWORTHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8530) + p.On_off() + } + + case TSqlParserDEFAULT_LANGUAGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8531) + p.Match(TSqlParserDEFAULT_LANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8532) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8535) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(8533) + p.Id_() + } + + case TSqlParserSTRING: + { + p.SetState(8534) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserDEFAULT_FULLTEXT_LANGUAGE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8537) + p.Match(TSqlParserDEFAULT_FULLTEXT_LANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8538) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8541) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(8539) + p.Id_() + } + + case TSqlParserSTRING: + { + p.SetState(8540) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserNESTED_TRIGGERS: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(8543) + p.Match(TSqlParserNESTED_TRIGGERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8544) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8545) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserTRANSFORM_NOISE_WORDS: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(8546) + p.Match(TSqlParserTRANSFORM_NOISE_WORDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8547) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8548) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserTWO_DIGIT_YEAR_CUTOFF: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(8549) + p.Match(TSqlParserTWO_DIGIT_YEAR_CUTOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8550) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8551) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHadr_optionsContext is an interface to support dynamic dispatch. +type IHadr_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAvailability_group_name returns the availability_group_name rule contexts. + GetAvailability_group_name() IId_Context + + // SetAvailability_group_name sets the availability_group_name rule contexts. + SetAvailability_group_name(IId_Context) + + // Getter signatures + HADR() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + RESUME() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + GROUP() antlr.TerminalNode + EQUAL() antlr.TerminalNode + OFF() antlr.TerminalNode + Id_() IId_Context + + // IsHadr_optionsContext differentiates from other interfaces. + IsHadr_optionsContext() +} + +type Hadr_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + availability_group_name IId_Context +} + +func NewEmptyHadr_optionsContext() *Hadr_optionsContext { + var p = new(Hadr_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_hadr_options + return p +} + +func InitEmptyHadr_optionsContext(p *Hadr_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_hadr_options +} + +func (*Hadr_optionsContext) IsHadr_optionsContext() {} + +func NewHadr_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hadr_optionsContext { + var p = new(Hadr_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_hadr_options + + return p +} + +func (s *Hadr_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hadr_optionsContext) GetAvailability_group_name() IId_Context { + return s.availability_group_name +} + +func (s *Hadr_optionsContext) SetAvailability_group_name(v IId_Context) { + s.availability_group_name = v +} + +func (s *Hadr_optionsContext) HADR() antlr.TerminalNode { + return s.GetToken(TSqlParserHADR, 0) +} + +func (s *Hadr_optionsContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(TSqlParserSUSPEND, 0) +} + +func (s *Hadr_optionsContext) RESUME() antlr.TerminalNode { + return s.GetToken(TSqlParserRESUME, 0) +} + +func (s *Hadr_optionsContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(TSqlParserAVAILABILITY, 0) +} + +func (s *Hadr_optionsContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *Hadr_optionsContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Hadr_optionsContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Hadr_optionsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Hadr_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hadr_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hadr_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterHadr_options(s) + } +} + +func (s *Hadr_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitHadr_options(s) + } +} + +func (s *Hadr_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitHadr_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Hadr_options() (localctx IHadr_optionsContext) { + localctx = NewHadr_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 684, TSqlParserRULE_hadr_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8554) + p.Match(TSqlParserHADR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAVAILABILITY, TSqlParserOFF: + p.SetState(8560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAVAILABILITY: + { + p.SetState(8555) + p.Match(TSqlParserAVAILABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8556) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8557) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8558) + + var _x = p.Id_() + + localctx.(*Hadr_optionsContext).availability_group_name = _x + } + + case TSqlParserOFF: + { + p.SetState(8559) + p.Match(TSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserRESUME, TSqlParserSUSPEND: + { + p.SetState(8562) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserRESUME || _la == TSqlParserSUSPEND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMixed_page_allocation_optionContext is an interface to support dynamic dispatch. +type IMixed_page_allocation_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MIXED_PAGE_ALLOCATION() antlr.TerminalNode + OFF() antlr.TerminalNode + ON() antlr.TerminalNode + + // IsMixed_page_allocation_optionContext differentiates from other interfaces. + IsMixed_page_allocation_optionContext() +} + +type Mixed_page_allocation_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMixed_page_allocation_optionContext() *Mixed_page_allocation_optionContext { + var p = new(Mixed_page_allocation_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_mixed_page_allocation_option + return p +} + +func InitEmptyMixed_page_allocation_optionContext(p *Mixed_page_allocation_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_mixed_page_allocation_option +} + +func (*Mixed_page_allocation_optionContext) IsMixed_page_allocation_optionContext() {} + +func NewMixed_page_allocation_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mixed_page_allocation_optionContext { + var p = new(Mixed_page_allocation_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_mixed_page_allocation_option + + return p +} + +func (s *Mixed_page_allocation_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Mixed_page_allocation_optionContext) MIXED_PAGE_ALLOCATION() antlr.TerminalNode { + return s.GetToken(TSqlParserMIXED_PAGE_ALLOCATION, 0) +} + +func (s *Mixed_page_allocation_optionContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Mixed_page_allocation_optionContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Mixed_page_allocation_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Mixed_page_allocation_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Mixed_page_allocation_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMixed_page_allocation_option(s) + } +} + +func (s *Mixed_page_allocation_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMixed_page_allocation_option(s) + } +} + +func (s *Mixed_page_allocation_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMixed_page_allocation_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Mixed_page_allocation_option() (localctx IMixed_page_allocation_optionContext) { + localctx = NewMixed_page_allocation_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 686, TSqlParserRULE_mixed_page_allocation_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8565) + p.Match(TSqlParserMIXED_PAGE_ALLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8566) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParameterization_optionContext is an interface to support dynamic dispatch. +type IParameterization_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARAMETERIZATION() antlr.TerminalNode + SIMPLE() antlr.TerminalNode + FORCED() antlr.TerminalNode + + // IsParameterization_optionContext differentiates from other interfaces. + IsParameterization_optionContext() +} + +type Parameterization_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameterization_optionContext() *Parameterization_optionContext { + var p = new(Parameterization_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_parameterization_option + return p +} + +func InitEmptyParameterization_optionContext(p *Parameterization_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_parameterization_option +} + +func (*Parameterization_optionContext) IsParameterization_optionContext() {} + +func NewParameterization_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parameterization_optionContext { + var p = new(Parameterization_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_parameterization_option + + return p +} + +func (s *Parameterization_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parameterization_optionContext) PARAMETERIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARAMETERIZATION, 0) +} + +func (s *Parameterization_optionContext) SIMPLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSIMPLE, 0) +} + +func (s *Parameterization_optionContext) FORCED() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCED, 0) +} + +func (s *Parameterization_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parameterization_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parameterization_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterParameterization_option(s) + } +} + +func (s *Parameterization_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitParameterization_option(s) + } +} + +func (s *Parameterization_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitParameterization_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Parameterization_option() (localctx IParameterization_optionContext) { + localctx = NewParameterization_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 688, TSqlParserRULE_parameterization_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8568) + p.Match(TSqlParserPARAMETERIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8569) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFORCED || _la == TSqlParserSIMPLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRecovery_optionContext is an interface to support dynamic dispatch. +type IRecovery_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECOVERY() antlr.TerminalNode + FULL() antlr.TerminalNode + BULK_LOGGED() antlr.TerminalNode + SIMPLE() antlr.TerminalNode + TORN_PAGE_DETECTION() antlr.TerminalNode + On_off() IOn_offContext + ACCELERATED_DATABASE_RECOVERY() antlr.TerminalNode + EQUAL() antlr.TerminalNode + PAGE_VERIFY() antlr.TerminalNode + CHECKSUM() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsRecovery_optionContext differentiates from other interfaces. + IsRecovery_optionContext() +} + +type Recovery_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRecovery_optionContext() *Recovery_optionContext { + var p = new(Recovery_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_recovery_option + return p +} + +func InitEmptyRecovery_optionContext(p *Recovery_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_recovery_option +} + +func (*Recovery_optionContext) IsRecovery_optionContext() {} + +func NewRecovery_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Recovery_optionContext { + var p = new(Recovery_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_recovery_option + + return p +} + +func (s *Recovery_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Recovery_optionContext) RECOVERY() antlr.TerminalNode { + return s.GetToken(TSqlParserRECOVERY, 0) +} + +func (s *Recovery_optionContext) FULL() antlr.TerminalNode { + return s.GetToken(TSqlParserFULL, 0) +} + +func (s *Recovery_optionContext) BULK_LOGGED() antlr.TerminalNode { + return s.GetToken(TSqlParserBULK_LOGGED, 0) +} + +func (s *Recovery_optionContext) SIMPLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSIMPLE, 0) +} + +func (s *Recovery_optionContext) TORN_PAGE_DETECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserTORN_PAGE_DETECTION, 0) +} + +func (s *Recovery_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Recovery_optionContext) ACCELERATED_DATABASE_RECOVERY() antlr.TerminalNode { + return s.GetToken(TSqlParserACCELERATED_DATABASE_RECOVERY, 0) +} + +func (s *Recovery_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Recovery_optionContext) PAGE_VERIFY() antlr.TerminalNode { + return s.GetToken(TSqlParserPAGE_VERIFY, 0) +} + +func (s *Recovery_optionContext) CHECKSUM() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKSUM, 0) +} + +func (s *Recovery_optionContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Recovery_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Recovery_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Recovery_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRecovery_option(s) + } +} + +func (s *Recovery_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRecovery_option(s) + } +} + +func (s *Recovery_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRecovery_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Recovery_option() (localctx IRecovery_optionContext) { + localctx = NewRecovery_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 690, TSqlParserRULE_recovery_option) + var _la int + + p.SetState(8580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserRECOVERY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8571) + p.Match(TSqlParserRECOVERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8572) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserBULK_LOGGED || _la == TSqlParserFULL || _la == TSqlParserSIMPLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserTORN_PAGE_DETECTION: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8573) + p.Match(TSqlParserTORN_PAGE_DETECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8574) + p.On_off() + } + + case TSqlParserACCELERATED_DATABASE_RECOVERY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8575) + p.Match(TSqlParserACCELERATED_DATABASE_RECOVERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8576) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8577) + p.On_off() + } + + case TSqlParserPAGE_VERIFY: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8578) + p.Match(TSqlParserPAGE_VERIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8579) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCHECKSUM || _la == TSqlParserNONE || _la == TSqlParserTORN_PAGE_DETECTION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IService_broker_optionContext is an interface to support dynamic dispatch. +type IService_broker_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE_BROKER() antlr.TerminalNode + DISABLE_BROKER() antlr.TerminalNode + NEW_BROKER() antlr.TerminalNode + ERROR_BROKER_CONVERSATIONS() antlr.TerminalNode + HONOR_BROKER_PRIORITY() antlr.TerminalNode + On_off() IOn_offContext + + // IsService_broker_optionContext differentiates from other interfaces. + IsService_broker_optionContext() +} + +type Service_broker_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyService_broker_optionContext() *Service_broker_optionContext { + var p = new(Service_broker_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_service_broker_option + return p +} + +func InitEmptyService_broker_optionContext(p *Service_broker_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_service_broker_option +} + +func (*Service_broker_optionContext) IsService_broker_optionContext() {} + +func NewService_broker_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Service_broker_optionContext { + var p = new(Service_broker_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_service_broker_option + + return p +} + +func (s *Service_broker_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Service_broker_optionContext) ENABLE_BROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserENABLE_BROKER, 0) +} + +func (s *Service_broker_optionContext) DISABLE_BROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLE_BROKER, 0) +} + +func (s *Service_broker_optionContext) NEW_BROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserNEW_BROKER, 0) +} + +func (s *Service_broker_optionContext) ERROR_BROKER_CONVERSATIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_BROKER_CONVERSATIONS, 0) +} + +func (s *Service_broker_optionContext) HONOR_BROKER_PRIORITY() antlr.TerminalNode { + return s.GetToken(TSqlParserHONOR_BROKER_PRIORITY, 0) +} + +func (s *Service_broker_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Service_broker_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Service_broker_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Service_broker_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterService_broker_option(s) + } +} + +func (s *Service_broker_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitService_broker_option(s) + } +} + +func (s *Service_broker_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitService_broker_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Service_broker_option() (localctx IService_broker_optionContext) { + localctx = NewService_broker_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 692, TSqlParserRULE_service_broker_option) + p.SetState(8588) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserENABLE_BROKER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8582) + p.Match(TSqlParserENABLE_BROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDISABLE_BROKER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8583) + p.Match(TSqlParserDISABLE_BROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNEW_BROKER: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8584) + p.Match(TSqlParserNEW_BROKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserERROR_BROKER_CONVERSATIONS: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8585) + p.Match(TSqlParserERROR_BROKER_CONVERSATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserHONOR_BROKER_PRIORITY: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(8586) + p.Match(TSqlParserHONOR_BROKER_PRIORITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8587) + p.On_off() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISnapshot_optionContext is an interface to support dynamic dispatch. +type ISnapshot_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT returns the MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT token. + GetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT() antlr.Token + + // SetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT sets the MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT token. + SetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT(antlr.Token) + + // Getter signatures + ALLOW_SNAPSHOT_ISOLATION() antlr.TerminalNode + On_off() IOn_offContext + READ_COMMITTED_SNAPSHOT() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsSnapshot_optionContext differentiates from other interfaces. + IsSnapshot_optionContext() +} + +type Snapshot_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT antlr.Token +} + +func NewEmptySnapshot_optionContext() *Snapshot_optionContext { + var p = new(Snapshot_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_snapshot_option + return p +} + +func InitEmptySnapshot_optionContext(p *Snapshot_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_snapshot_option +} + +func (*Snapshot_optionContext) IsSnapshot_optionContext() {} + +func NewSnapshot_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Snapshot_optionContext { + var p = new(Snapshot_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_snapshot_option + + return p +} + +func (s *Snapshot_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Snapshot_optionContext) GetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT() antlr.Token { + return s.MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT +} + +func (s *Snapshot_optionContext) SetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT(v antlr.Token) { + s.MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT = v +} + +func (s *Snapshot_optionContext) ALLOW_SNAPSHOT_ISOLATION() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_SNAPSHOT_ISOLATION, 0) +} + +func (s *Snapshot_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Snapshot_optionContext) READ_COMMITTED_SNAPSHOT() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_COMMITTED_SNAPSHOT, 0) +} + +func (s *Snapshot_optionContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Snapshot_optionContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Snapshot_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Snapshot_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Snapshot_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSnapshot_option(s) + } +} + +func (s *Snapshot_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSnapshot_option(s) + } +} + +func (s *Snapshot_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSnapshot_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Snapshot_option() (localctx ISnapshot_optionContext) { + localctx = NewSnapshot_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 694, TSqlParserRULE_snapshot_option) + var _la int + + p.SetState(8595) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALLOW_SNAPSHOT_ISOLATION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8590) + p.Match(TSqlParserALLOW_SNAPSHOT_ISOLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8591) + p.On_off() + } + + case TSqlParserREAD_COMMITTED_SNAPSHOT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8592) + p.Match(TSqlParserREAD_COMMITTED_SNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8593) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserOFF, TSqlParserON: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8594) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Snapshot_optionContext).MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Snapshot_optionContext).MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_optionContext is an interface to support dynamic dispatch. +type ISql_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ANSI_NULL_DEFAULT() antlr.TerminalNode + On_off() IOn_offContext + ANSI_NULLS() antlr.TerminalNode + ANSI_PADDING() antlr.TerminalNode + ANSI_WARNINGS() antlr.TerminalNode + ARITHABORT() antlr.TerminalNode + COMPATIBILITY_LEVEL() antlr.TerminalNode + EQUAL() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + CONCAT_NULL_YIELDS_NULL() antlr.TerminalNode + NUMERIC_ROUNDABORT() antlr.TerminalNode + QUOTED_IDENTIFIER() antlr.TerminalNode + RECURSIVE_TRIGGERS() antlr.TerminalNode + + // IsSql_optionContext differentiates from other interfaces. + IsSql_optionContext() +} + +type Sql_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_optionContext() *Sql_optionContext { + var p = new(Sql_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_sql_option + return p +} + +func InitEmptySql_optionContext(p *Sql_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_sql_option +} + +func (*Sql_optionContext) IsSql_optionContext() {} + +func NewSql_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_optionContext { + var p = new(Sql_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_sql_option + + return p +} + +func (s *Sql_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_optionContext) ANSI_NULL_DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_NULL_DEFAULT, 0) +} + +func (s *Sql_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Sql_optionContext) ANSI_NULLS() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_NULLS, 0) +} + +func (s *Sql_optionContext) ANSI_PADDING() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_PADDING, 0) +} + +func (s *Sql_optionContext) ANSI_WARNINGS() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_WARNINGS, 0) +} + +func (s *Sql_optionContext) ARITHABORT() antlr.TerminalNode { + return s.GetToken(TSqlParserARITHABORT, 0) +} + +func (s *Sql_optionContext) COMPATIBILITY_LEVEL() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPATIBILITY_LEVEL, 0) +} + +func (s *Sql_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Sql_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Sql_optionContext) CONCAT_NULL_YIELDS_NULL() antlr.TerminalNode { + return s.GetToken(TSqlParserCONCAT_NULL_YIELDS_NULL, 0) +} + +func (s *Sql_optionContext) NUMERIC_ROUNDABORT() antlr.TerminalNode { + return s.GetToken(TSqlParserNUMERIC_ROUNDABORT, 0) +} + +func (s *Sql_optionContext) QUOTED_IDENTIFIER() antlr.TerminalNode { + return s.GetToken(TSqlParserQUOTED_IDENTIFIER, 0) +} + +func (s *Sql_optionContext) RECURSIVE_TRIGGERS() antlr.TerminalNode { + return s.GetToken(TSqlParserRECURSIVE_TRIGGERS, 0) +} + +func (s *Sql_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSql_option(s) + } +} + +func (s *Sql_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSql_option(s) + } +} + +func (s *Sql_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSql_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Sql_option() (localctx ISql_optionContext) { + localctx = NewSql_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 696, TSqlParserRULE_sql_option) + p.SetState(8618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserANSI_NULL_DEFAULT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8597) + p.Match(TSqlParserANSI_NULL_DEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8598) + p.On_off() + } + + case TSqlParserANSI_NULLS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8599) + p.Match(TSqlParserANSI_NULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8600) + p.On_off() + } + + case TSqlParserANSI_PADDING: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8601) + p.Match(TSqlParserANSI_PADDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8602) + p.On_off() + } + + case TSqlParserANSI_WARNINGS: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8603) + p.Match(TSqlParserANSI_WARNINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8604) + p.On_off() + } + + case TSqlParserARITHABORT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(8605) + p.Match(TSqlParserARITHABORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8606) + p.On_off() + } + + case TSqlParserCOMPATIBILITY_LEVEL: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(8607) + p.Match(TSqlParserCOMPATIBILITY_LEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8608) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8609) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCONCAT_NULL_YIELDS_NULL: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(8610) + p.Match(TSqlParserCONCAT_NULL_YIELDS_NULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8611) + p.On_off() + } + + case TSqlParserNUMERIC_ROUNDABORT: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(8612) + p.Match(TSqlParserNUMERIC_ROUNDABORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8613) + p.On_off() + } + + case TSqlParserQUOTED_IDENTIFIER: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(8614) + p.Match(TSqlParserQUOTED_IDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8615) + p.On_off() + } + + case TSqlParserRECURSIVE_TRIGGERS: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(8616) + p.Match(TSqlParserRECURSIVE_TRIGGERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8617) + p.On_off() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITarget_recovery_time_optionContext is an interface to support dynamic dispatch. +type ITarget_recovery_time_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TARGET_RECOVERY_TIME() antlr.TerminalNode + EQUAL() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + SECONDS() antlr.TerminalNode + MINUTES() antlr.TerminalNode + + // IsTarget_recovery_time_optionContext differentiates from other interfaces. + IsTarget_recovery_time_optionContext() +} + +type Target_recovery_time_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTarget_recovery_time_optionContext() *Target_recovery_time_optionContext { + var p = new(Target_recovery_time_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_target_recovery_time_option + return p +} + +func InitEmptyTarget_recovery_time_optionContext(p *Target_recovery_time_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_target_recovery_time_option +} + +func (*Target_recovery_time_optionContext) IsTarget_recovery_time_optionContext() {} + +func NewTarget_recovery_time_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Target_recovery_time_optionContext { + var p = new(Target_recovery_time_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_target_recovery_time_option + + return p +} + +func (s *Target_recovery_time_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Target_recovery_time_optionContext) TARGET_RECOVERY_TIME() antlr.TerminalNode { + return s.GetToken(TSqlParserTARGET_RECOVERY_TIME, 0) +} + +func (s *Target_recovery_time_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Target_recovery_time_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Target_recovery_time_optionContext) SECONDS() antlr.TerminalNode { + return s.GetToken(TSqlParserSECONDS, 0) +} + +func (s *Target_recovery_time_optionContext) MINUTES() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUTES, 0) +} + +func (s *Target_recovery_time_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Target_recovery_time_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Target_recovery_time_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTarget_recovery_time_option(s) + } +} + +func (s *Target_recovery_time_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTarget_recovery_time_option(s) + } +} + +func (s *Target_recovery_time_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTarget_recovery_time_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Target_recovery_time_option() (localctx ITarget_recovery_time_optionContext) { + localctx = NewTarget_recovery_time_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 698, TSqlParserRULE_target_recovery_time_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8620) + p.Match(TSqlParserTARGET_RECOVERY_TIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8621) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8622) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8623) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserMINUTES || _la == TSqlParserSECONDS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITerminationContext is an interface to support dynamic dispatch. +type ITerminationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSeconds returns the seconds token. + GetSeconds() antlr.Token + + // SetSeconds sets the seconds token. + SetSeconds(antlr.Token) + + // Getter signatures + ROLLBACK() antlr.TerminalNode + AFTER() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + NO_WAIT() antlr.TerminalNode + + // IsTerminationContext differentiates from other interfaces. + IsTerminationContext() +} + +type TerminationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + seconds antlr.Token +} + +func NewEmptyTerminationContext() *TerminationContext { + var p = new(TerminationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_termination + return p +} + +func InitEmptyTerminationContext(p *TerminationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_termination +} + +func (*TerminationContext) IsTerminationContext() {} + +func NewTerminationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TerminationContext { + var p = new(TerminationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_termination + + return p +} + +func (s *TerminationContext) GetParser() antlr.Parser { return s.parser } + +func (s *TerminationContext) GetSeconds() antlr.Token { return s.seconds } + +func (s *TerminationContext) SetSeconds(v antlr.Token) { s.seconds = v } + +func (s *TerminationContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(TSqlParserROLLBACK, 0) +} + +func (s *TerminationContext) AFTER() antlr.TerminalNode { + return s.GetToken(TSqlParserAFTER, 0) +} + +func (s *TerminationContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *TerminationContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(TSqlParserIMMEDIATE, 0) +} + +func (s *TerminationContext) NO_WAIT() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_WAIT, 0) +} + +func (s *TerminationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TerminationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TerminationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTermination(s) + } +} + +func (s *TerminationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTermination(s) + } +} + +func (s *TerminationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTermination(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Termination() (localctx ITerminationContext) { + localctx = NewTerminationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 700, TSqlParserRULE_termination) + p.SetState(8631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1096, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8625) + p.Match(TSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8626) + p.Match(TSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8627) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*TerminationContext).seconds = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8628) + p.Match(TSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8629) + p.Match(TSqlParserIMMEDIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8630) + p.Match(TSqlParserNO_WAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_indexContext is an interface to support dynamic dispatch. +type IDrop_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + INDEX() antlr.TerminalNode + AllDrop_relational_or_xml_or_spatial_index() []IDrop_relational_or_xml_or_spatial_indexContext + Drop_relational_or_xml_or_spatial_index(i int) IDrop_relational_or_xml_or_spatial_indexContext + AllDrop_backward_compatible_index() []IDrop_backward_compatible_indexContext + Drop_backward_compatible_index(i int) IDrop_backward_compatible_indexContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + SEMI() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDrop_indexContext differentiates from other interfaces. + IsDrop_indexContext() +} + +type Drop_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_indexContext() *Drop_indexContext { + var p = new(Drop_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_index + return p +} + +func InitEmptyDrop_indexContext(p *Drop_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_index +} + +func (*Drop_indexContext) IsDrop_indexContext() {} + +func NewDrop_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_indexContext { + var p = new(Drop_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_index + + return p +} + +func (s *Drop_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_indexContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Drop_indexContext) AllDrop_relational_or_xml_or_spatial_index() []IDrop_relational_or_xml_or_spatial_indexContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDrop_relational_or_xml_or_spatial_indexContext); ok { + len++ + } + } + + tst := make([]IDrop_relational_or_xml_or_spatial_indexContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDrop_relational_or_xml_or_spatial_indexContext); ok { + tst[i] = t.(IDrop_relational_or_xml_or_spatial_indexContext) + i++ + } + } + + return tst +} + +func (s *Drop_indexContext) Drop_relational_or_xml_or_spatial_index(i int) IDrop_relational_or_xml_or_spatial_indexContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_relational_or_xml_or_spatial_indexContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDrop_relational_or_xml_or_spatial_indexContext) +} + +func (s *Drop_indexContext) AllDrop_backward_compatible_index() []IDrop_backward_compatible_indexContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDrop_backward_compatible_indexContext); ok { + len++ + } + } + + tst := make([]IDrop_backward_compatible_indexContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDrop_backward_compatible_indexContext); ok { + tst[i] = t.(IDrop_backward_compatible_indexContext) + i++ + } + } + + return tst +} + +func (s *Drop_indexContext) Drop_backward_compatible_index(i int) IDrop_backward_compatible_indexContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_backward_compatible_indexContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDrop_backward_compatible_indexContext) +} + +func (s *Drop_indexContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_indexContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_indexContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Drop_indexContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Drop_indexContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Drop_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_index(s) + } +} + +func (s *Drop_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_index(s) + } +} + +func (s *Drop_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_index() (localctx IDrop_indexContext) { + localctx = NewDrop_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 702, TSqlParserRULE_drop_index) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8633) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8634) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(8635) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8636) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1100, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8639) + p.Drop_relational_or_xml_or_spatial_index() + } + p.SetState(8644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8640) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8641) + p.Drop_relational_or_xml_or_spatial_index() + } + + p.SetState(8646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(8647) + p.Drop_backward_compatible_index() + } + p.SetState(8652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8648) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8649) + p.Drop_backward_compatible_index() + } + + p.SetState(8654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8658) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1101, p.GetParserRuleContext()) == 1 { + { + p.SetState(8657) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_relational_or_xml_or_spatial_indexContext is an interface to support dynamic dispatch. +type IDrop_relational_or_xml_or_spatial_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIndex_name returns the index_name rule contexts. + GetIndex_name() IId_Context + + // SetIndex_name sets the index_name rule contexts. + SetIndex_name(IId_Context) + + // Getter signatures + ON() antlr.TerminalNode + Full_table_name() IFull_table_nameContext + Id_() IId_Context + + // IsDrop_relational_or_xml_or_spatial_indexContext differentiates from other interfaces. + IsDrop_relational_or_xml_or_spatial_indexContext() +} + +type Drop_relational_or_xml_or_spatial_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + index_name IId_Context +} + +func NewEmptyDrop_relational_or_xml_or_spatial_indexContext() *Drop_relational_or_xml_or_spatial_indexContext { + var p = new(Drop_relational_or_xml_or_spatial_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_relational_or_xml_or_spatial_index + return p +} + +func InitEmptyDrop_relational_or_xml_or_spatial_indexContext(p *Drop_relational_or_xml_or_spatial_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_relational_or_xml_or_spatial_index +} + +func (*Drop_relational_or_xml_or_spatial_indexContext) IsDrop_relational_or_xml_or_spatial_indexContext() { +} + +func NewDrop_relational_or_xml_or_spatial_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_relational_or_xml_or_spatial_indexContext { + var p = new(Drop_relational_or_xml_or_spatial_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_relational_or_xml_or_spatial_index + + return p +} + +func (s *Drop_relational_or_xml_or_spatial_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_relational_or_xml_or_spatial_indexContext) GetIndex_name() IId_Context { + return s.index_name +} + +func (s *Drop_relational_or_xml_or_spatial_indexContext) SetIndex_name(v IId_Context) { + s.index_name = v +} + +func (s *Drop_relational_or_xml_or_spatial_indexContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Drop_relational_or_xml_or_spatial_indexContext) Full_table_name() IFull_table_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_table_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_table_nameContext) +} + +func (s *Drop_relational_or_xml_or_spatial_indexContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_relational_or_xml_or_spatial_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_relational_or_xml_or_spatial_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_relational_or_xml_or_spatial_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_relational_or_xml_or_spatial_index(s) + } +} + +func (s *Drop_relational_or_xml_or_spatial_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_relational_or_xml_or_spatial_index(s) + } +} + +func (s *Drop_relational_or_xml_or_spatial_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_relational_or_xml_or_spatial_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_relational_or_xml_or_spatial_index() (localctx IDrop_relational_or_xml_or_spatial_indexContext) { + localctx = NewDrop_relational_or_xml_or_spatial_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 704, TSqlParserRULE_drop_relational_or_xml_or_spatial_index) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8660) + + var _x = p.Id_() + + localctx.(*Drop_relational_or_xml_or_spatial_indexContext).index_name = _x + } + { + p.SetState(8661) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8662) + p.Full_table_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_backward_compatible_indexContext is an interface to support dynamic dispatch. +type IDrop_backward_compatible_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOwner_name returns the owner_name rule contexts. + GetOwner_name() IId_Context + + // GetTable_or_view_name returns the table_or_view_name rule contexts. + GetTable_or_view_name() IId_Context + + // GetIndex_name returns the index_name rule contexts. + GetIndex_name() IId_Context + + // SetOwner_name sets the owner_name rule contexts. + SetOwner_name(IId_Context) + + // SetTable_or_view_name sets the table_or_view_name rule contexts. + SetTable_or_view_name(IId_Context) + + // SetIndex_name sets the index_name rule contexts. + SetIndex_name(IId_Context) + + // Getter signatures + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + + // IsDrop_backward_compatible_indexContext differentiates from other interfaces. + IsDrop_backward_compatible_indexContext() +} + +type Drop_backward_compatible_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + owner_name IId_Context + table_or_view_name IId_Context + index_name IId_Context +} + +func NewEmptyDrop_backward_compatible_indexContext() *Drop_backward_compatible_indexContext { + var p = new(Drop_backward_compatible_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_backward_compatible_index + return p +} + +func InitEmptyDrop_backward_compatible_indexContext(p *Drop_backward_compatible_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_backward_compatible_index +} + +func (*Drop_backward_compatible_indexContext) IsDrop_backward_compatible_indexContext() {} + +func NewDrop_backward_compatible_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_backward_compatible_indexContext { + var p = new(Drop_backward_compatible_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_backward_compatible_index + + return p +} + +func (s *Drop_backward_compatible_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_backward_compatible_indexContext) GetOwner_name() IId_Context { return s.owner_name } + +func (s *Drop_backward_compatible_indexContext) GetTable_or_view_name() IId_Context { + return s.table_or_view_name +} + +func (s *Drop_backward_compatible_indexContext) GetIndex_name() IId_Context { return s.index_name } + +func (s *Drop_backward_compatible_indexContext) SetOwner_name(v IId_Context) { s.owner_name = v } + +func (s *Drop_backward_compatible_indexContext) SetTable_or_view_name(v IId_Context) { + s.table_or_view_name = v +} + +func (s *Drop_backward_compatible_indexContext) SetIndex_name(v IId_Context) { s.index_name = v } + +func (s *Drop_backward_compatible_indexContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Drop_backward_compatible_indexContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Drop_backward_compatible_indexContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_backward_compatible_indexContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_backward_compatible_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_backward_compatible_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_backward_compatible_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_backward_compatible_index(s) + } +} + +func (s *Drop_backward_compatible_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_backward_compatible_index(s) + } +} + +func (s *Drop_backward_compatible_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_backward_compatible_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_backward_compatible_index() (localctx IDrop_backward_compatible_indexContext) { + localctx = NewDrop_backward_compatible_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 706, TSqlParserRULE_drop_backward_compatible_index) + p.EnterOuterAlt(localctx, 1) + p.SetState(8667) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1102, p.GetParserRuleContext()) == 1 { + { + p.SetState(8664) + + var _x = p.Id_() + + localctx.(*Drop_backward_compatible_indexContext).owner_name = _x + } + { + p.SetState(8665) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8669) + + var _x = p.Id_() + + localctx.(*Drop_backward_compatible_indexContext).table_or_view_name = _x + } + { + p.SetState(8670) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8671) + + var _x = p.Id_() + + localctx.(*Drop_backward_compatible_indexContext).index_name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_procedureContext is an interface to support dynamic dispatch. +type IDrop_procedureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetProc returns the proc token. + GetProc() antlr.Token + + // SetProc sets the proc token. + SetProc(antlr.Token) + + // Getter signatures + DROP() antlr.TerminalNode + AllFunc_proc_name_schema() []IFunc_proc_name_schemaContext + Func_proc_name_schema(i int) IFunc_proc_name_schemaContext + PROC() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsDrop_procedureContext differentiates from other interfaces. + IsDrop_procedureContext() +} + +type Drop_procedureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + proc antlr.Token +} + +func NewEmptyDrop_procedureContext() *Drop_procedureContext { + var p = new(Drop_procedureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_procedure + return p +} + +func InitEmptyDrop_procedureContext(p *Drop_procedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_procedure +} + +func (*Drop_procedureContext) IsDrop_procedureContext() {} + +func NewDrop_procedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_procedureContext { + var p = new(Drop_procedureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_procedure + + return p +} + +func (s *Drop_procedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_procedureContext) GetProc() antlr.Token { return s.proc } + +func (s *Drop_procedureContext) SetProc(v antlr.Token) { s.proc = v } + +func (s *Drop_procedureContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_procedureContext) AllFunc_proc_name_schema() []IFunc_proc_name_schemaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunc_proc_name_schemaContext); ok { + len++ + } + } + + tst := make([]IFunc_proc_name_schemaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunc_proc_name_schemaContext); ok { + tst[i] = t.(IFunc_proc_name_schemaContext) + i++ + } + } + + return tst +} + +func (s *Drop_procedureContext) Func_proc_name_schema(i int) IFunc_proc_name_schemaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_proc_name_schemaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunc_proc_name_schemaContext) +} + +func (s *Drop_procedureContext) PROC() antlr.TerminalNode { + return s.GetToken(TSqlParserPROC, 0) +} + +func (s *Drop_procedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(TSqlParserPROCEDURE, 0) +} + +func (s *Drop_procedureContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_procedureContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_procedureContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Drop_procedureContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Drop_procedureContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Drop_procedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_procedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_procedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_procedure(s) + } +} + +func (s *Drop_procedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_procedure(s) + } +} + +func (s *Drop_procedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_procedure(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_procedure() (localctx IDrop_procedureContext) { + localctx = NewDrop_procedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 708, TSqlParserRULE_drop_procedure) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8673) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8674) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Drop_procedureContext).proc = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserPROC || _la == TSqlParserPROCEDURE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Drop_procedureContext).proc = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(8677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(8675) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8676) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8679) + p.Func_proc_name_schema() + } + p.SetState(8684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8680) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8681) + p.Func_proc_name_schema() + } + + p.SetState(8686) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8688) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1105, p.GetParserRuleContext()) == 1 { + { + p.SetState(8687) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_triggerContext is an interface to support dynamic dispatch. +type IDrop_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Drop_dml_trigger() IDrop_dml_triggerContext + Drop_ddl_trigger() IDrop_ddl_triggerContext + + // IsDrop_triggerContext differentiates from other interfaces. + IsDrop_triggerContext() +} + +type Drop_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_triggerContext() *Drop_triggerContext { + var p = new(Drop_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_trigger + return p +} + +func InitEmptyDrop_triggerContext(p *Drop_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_trigger +} + +func (*Drop_triggerContext) IsDrop_triggerContext() {} + +func NewDrop_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_triggerContext { + var p = new(Drop_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_trigger + + return p +} + +func (s *Drop_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_triggerContext) Drop_dml_trigger() IDrop_dml_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_dml_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_dml_triggerContext) +} + +func (s *Drop_triggerContext) Drop_ddl_trigger() IDrop_ddl_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_ddl_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_ddl_triggerContext) +} + +func (s *Drop_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_trigger(s) + } +} + +func (s *Drop_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_trigger(s) + } +} + +func (s *Drop_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_trigger() (localctx IDrop_triggerContext) { + localctx = NewDrop_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 710, TSqlParserRULE_drop_trigger) + p.SetState(8692) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1106, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8690) + p.Drop_dml_trigger() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8691) + p.Drop_ddl_trigger() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_dml_triggerContext is an interface to support dynamic dispatch. +type IDrop_dml_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + AllSimple_name() []ISimple_nameContext + Simple_name(i int) ISimple_nameContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsDrop_dml_triggerContext differentiates from other interfaces. + IsDrop_dml_triggerContext() +} + +type Drop_dml_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_dml_triggerContext() *Drop_dml_triggerContext { + var p = new(Drop_dml_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_dml_trigger + return p +} + +func InitEmptyDrop_dml_triggerContext(p *Drop_dml_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_dml_trigger +} + +func (*Drop_dml_triggerContext) IsDrop_dml_triggerContext() {} + +func NewDrop_dml_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_dml_triggerContext { + var p = new(Drop_dml_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_dml_trigger + + return p +} + +func (s *Drop_dml_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_dml_triggerContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_dml_triggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIGGER, 0) +} + +func (s *Drop_dml_triggerContext) AllSimple_name() []ISimple_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISimple_nameContext); ok { + len++ + } + } + + tst := make([]ISimple_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISimple_nameContext); ok { + tst[i] = t.(ISimple_nameContext) + i++ + } + } + + return tst +} + +func (s *Drop_dml_triggerContext) Simple_name(i int) ISimple_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISimple_nameContext) +} + +func (s *Drop_dml_triggerContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_dml_triggerContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_dml_triggerContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Drop_dml_triggerContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Drop_dml_triggerContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Drop_dml_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_dml_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_dml_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_dml_trigger(s) + } +} + +func (s *Drop_dml_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_dml_trigger(s) + } +} + +func (s *Drop_dml_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_dml_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_dml_trigger() (localctx IDrop_dml_triggerContext) { + localctx = NewDrop_dml_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 712, TSqlParserRULE_drop_dml_trigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8694) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8695) + p.Match(TSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(8696) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8697) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8700) + p.Simple_name() + } + p.SetState(8705) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8701) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8702) + p.Simple_name() + } + + p.SetState(8707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8709) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1109, p.GetParserRuleContext()) == 1 { + { + p.SetState(8708) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_ddl_triggerContext is an interface to support dynamic dispatch. +type IDrop_ddl_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + AllSimple_name() []ISimple_nameContext + Simple_name(i int) ISimple_nameContext + ON() antlr.TerminalNode + DATABASE() antlr.TerminalNode + ALL() antlr.TerminalNode + SERVER() antlr.TerminalNode + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsDrop_ddl_triggerContext differentiates from other interfaces. + IsDrop_ddl_triggerContext() +} + +type Drop_ddl_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_ddl_triggerContext() *Drop_ddl_triggerContext { + var p = new(Drop_ddl_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_ddl_trigger + return p +} + +func InitEmptyDrop_ddl_triggerContext(p *Drop_ddl_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_ddl_trigger +} + +func (*Drop_ddl_triggerContext) IsDrop_ddl_triggerContext() {} + +func NewDrop_ddl_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_ddl_triggerContext { + var p = new(Drop_ddl_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_ddl_trigger + + return p +} + +func (s *Drop_ddl_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_ddl_triggerContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_ddl_triggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIGGER, 0) +} + +func (s *Drop_ddl_triggerContext) AllSimple_name() []ISimple_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISimple_nameContext); ok { + len++ + } + } + + tst := make([]ISimple_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISimple_nameContext); ok { + tst[i] = t.(ISimple_nameContext) + i++ + } + } + + return tst +} + +func (s *Drop_ddl_triggerContext) Simple_name(i int) ISimple_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISimple_nameContext) +} + +func (s *Drop_ddl_triggerContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Drop_ddl_triggerContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Drop_ddl_triggerContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Drop_ddl_triggerContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Drop_ddl_triggerContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_ddl_triggerContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_ddl_triggerContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Drop_ddl_triggerContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Drop_ddl_triggerContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Drop_ddl_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_ddl_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_ddl_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_ddl_trigger(s) + } +} + +func (s *Drop_ddl_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_ddl_trigger(s) + } +} + +func (s *Drop_ddl_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_ddl_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_ddl_trigger() (localctx IDrop_ddl_triggerContext) { + localctx = NewDrop_ddl_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 714, TSqlParserRULE_drop_ddl_trigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8711) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8712) + p.Match(TSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(8713) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8714) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8717) + p.Simple_name() + } + p.SetState(8722) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8718) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8719) + p.Simple_name() + } + + p.SetState(8724) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8725) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8729) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDATABASE: + { + p.SetState(8726) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserALL: + { + p.SetState(8727) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8728) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(8732) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1113, p.GetParserRuleContext()) == 1 { + { + p.SetState(8731) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_functionContext is an interface to support dynamic dispatch. +type IDrop_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + AllFunc_proc_name_schema() []IFunc_proc_name_schemaContext + Func_proc_name_schema(i int) IFunc_proc_name_schemaContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsDrop_functionContext differentiates from other interfaces. + IsDrop_functionContext() +} + +type Drop_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_functionContext() *Drop_functionContext { + var p = new(Drop_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_function + return p +} + +func InitEmptyDrop_functionContext(p *Drop_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_function +} + +func (*Drop_functionContext) IsDrop_functionContext() {} + +func NewDrop_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_functionContext { + var p = new(Drop_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_function + + return p +} + +func (s *Drop_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_functionContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_functionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(TSqlParserFUNCTION, 0) +} + +func (s *Drop_functionContext) AllFunc_proc_name_schema() []IFunc_proc_name_schemaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunc_proc_name_schemaContext); ok { + len++ + } + } + + tst := make([]IFunc_proc_name_schemaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunc_proc_name_schemaContext); ok { + tst[i] = t.(IFunc_proc_name_schemaContext) + i++ + } + } + + return tst +} + +func (s *Drop_functionContext) Func_proc_name_schema(i int) IFunc_proc_name_schemaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_proc_name_schemaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunc_proc_name_schemaContext) +} + +func (s *Drop_functionContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_functionContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_functionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Drop_functionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Drop_functionContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Drop_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_function(s) + } +} + +func (s *Drop_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_function(s) + } +} + +func (s *Drop_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_function() (localctx IDrop_functionContext) { + localctx = NewDrop_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 716, TSqlParserRULE_drop_function) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8734) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8735) + p.Match(TSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(8736) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8737) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8740) + p.Func_proc_name_schema() + } + p.SetState(8745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8741) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8742) + p.Func_proc_name_schema() + } + + p.SetState(8747) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8749) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1116, p.GetParserRuleContext()) == 1 { + { + p.SetState(8748) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_statisticsContext is an interface to support dynamic dispatch. +type IDrop_statisticsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name rule contexts. + GetName() IId_Context + + // SetName sets the name rule contexts. + SetName(IId_Context) + + // Getter signatures + DROP() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + SEMI() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllTable_name() []ITable_nameContext + Table_name(i int) ITable_nameContext + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsDrop_statisticsContext differentiates from other interfaces. + IsDrop_statisticsContext() +} + +type Drop_statisticsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name IId_Context +} + +func NewEmptyDrop_statisticsContext() *Drop_statisticsContext { + var p = new(Drop_statisticsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_statistics + return p +} + +func InitEmptyDrop_statisticsContext(p *Drop_statisticsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_statistics +} + +func (*Drop_statisticsContext) IsDrop_statisticsContext() {} + +func NewDrop_statisticsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_statisticsContext { + var p = new(Drop_statisticsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_statistics + + return p +} + +func (s *Drop_statisticsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_statisticsContext) GetName() IId_Context { return s.name } + +func (s *Drop_statisticsContext) SetName(v IId_Context) { s.name = v } + +func (s *Drop_statisticsContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_statisticsContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS, 0) +} + +func (s *Drop_statisticsContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Drop_statisticsContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Drop_statisticsContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_statisticsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Drop_statisticsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Drop_statisticsContext) AllTable_name() []ITable_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_nameContext); ok { + len++ + } + } + + tst := make([]ITable_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_nameContext); ok { + tst[i] = t.(ITable_nameContext) + i++ + } + } + + return tst +} + +func (s *Drop_statisticsContext) Table_name(i int) ITable_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Drop_statisticsContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Drop_statisticsContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Drop_statisticsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_statisticsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_statisticsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_statistics(s) + } +} + +func (s *Drop_statisticsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_statistics(s) + } +} + +func (s *Drop_statisticsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_statistics(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_statistics() (localctx IDrop_statisticsContext) { + localctx = NewDrop_statisticsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 718, TSqlParserRULE_drop_statistics) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8751) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8752) + p.Match(TSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&562949975835135) != 0) { + p.SetState(8754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(8753) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8759) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1118, p.GetParserRuleContext()) == 1 { + { + p.SetState(8756) + p.Table_name() + } + { + p.SetState(8757) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8761) + + var _x = p.Id_() + + localctx.(*Drop_statisticsContext).name = _x + } + + p.SetState(8764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8766) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_tableContext is an interface to support dynamic dispatch. +type IDrop_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllTable_name() []ITable_nameContext + Table_name(i int) ITable_nameContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsDrop_tableContext differentiates from other interfaces. + IsDrop_tableContext() +} + +type Drop_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_tableContext() *Drop_tableContext { + var p = new(Drop_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_table + return p +} + +func InitEmptyDrop_tableContext(p *Drop_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_table +} + +func (*Drop_tableContext) IsDrop_tableContext() {} + +func NewDrop_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_tableContext { + var p = new(Drop_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_table + + return p +} + +func (s *Drop_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLE, 0) +} + +func (s *Drop_tableContext) AllTable_name() []ITable_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_nameContext); ok { + len++ + } + } + + tst := make([]ITable_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_nameContext); ok { + tst[i] = t.(ITable_nameContext) + i++ + } + } + + return tst +} + +func (s *Drop_tableContext) Table_name(i int) ITable_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Drop_tableContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_tableContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Drop_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Drop_tableContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Drop_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_table(s) + } +} + +func (s *Drop_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_table(s) + } +} + +func (s *Drop_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_table() (localctx IDrop_tableContext) { + localctx = NewDrop_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 720, TSqlParserRULE_drop_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8768) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8769) + p.Match(TSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8772) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(8770) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8771) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8774) + p.Table_name() + } + p.SetState(8779) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8775) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8776) + p.Table_name() + } + + p.SetState(8781) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8783) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) == 1 { + { + p.SetState(8782) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_viewContext is an interface to support dynamic dispatch. +type IDrop_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + VIEW() antlr.TerminalNode + AllSimple_name() []ISimple_nameContext + Simple_name(i int) ISimple_nameContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsDrop_viewContext differentiates from other interfaces. + IsDrop_viewContext() +} + +type Drop_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_viewContext() *Drop_viewContext { + var p = new(Drop_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_view + return p +} + +func InitEmptyDrop_viewContext(p *Drop_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_view +} + +func (*Drop_viewContext) IsDrop_viewContext() {} + +func NewDrop_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_viewContext { + var p = new(Drop_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_view + + return p +} + +func (s *Drop_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_viewContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(TSqlParserVIEW, 0) +} + +func (s *Drop_viewContext) AllSimple_name() []ISimple_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISimple_nameContext); ok { + len++ + } + } + + tst := make([]ISimple_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISimple_nameContext); ok { + tst[i] = t.(ISimple_nameContext) + i++ + } + } + + return tst +} + +func (s *Drop_viewContext) Simple_name(i int) ISimple_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISimple_nameContext) +} + +func (s *Drop_viewContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_viewContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_viewContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Drop_viewContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Drop_viewContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Drop_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_view(s) + } +} + +func (s *Drop_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_view(s) + } +} + +func (s *Drop_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_view() (localctx IDrop_viewContext) { + localctx = NewDrop_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 722, TSqlParserRULE_drop_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8785) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8786) + p.Match(TSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8789) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(8787) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8788) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8791) + p.Simple_name() + } + p.SetState(8796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8792) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8793) + p.Simple_name() + } + + p.SetState(8798) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8800) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1125, p.GetParserRuleContext()) == 1 { + { + p.SetState(8799) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_typeContext is an interface to support dynamic dispatch. +type ICreate_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name rule contexts. + GetName() ISimple_nameContext + + // SetName sets the name rule contexts. + SetName(ISimple_nameContext) + + // Getter signatures + CREATE() antlr.TerminalNode + TYPE() antlr.TerminalNode + Simple_name() ISimple_nameContext + FROM() antlr.TerminalNode + Data_type() IData_typeContext + AS() antlr.TerminalNode + TABLE() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Column_def_table_constraints() IColumn_def_table_constraintsContext + RR_BRACKET() antlr.TerminalNode + Null_notnull() INull_notnullContext + + // IsCreate_typeContext differentiates from other interfaces. + IsCreate_typeContext() +} + +type Create_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name ISimple_nameContext +} + +func NewEmptyCreate_typeContext() *Create_typeContext { + var p = new(Create_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_type + return p +} + +func InitEmptyCreate_typeContext(p *Create_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_type +} + +func (*Create_typeContext) IsCreate_typeContext() {} + +func NewCreate_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_typeContext { + var p = new(Create_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_type + + return p +} + +func (s *Create_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_typeContext) GetName() ISimple_nameContext { return s.name } + +func (s *Create_typeContext) SetName(v ISimple_nameContext) { s.name = v } + +func (s *Create_typeContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_typeContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *Create_typeContext) Simple_name() ISimple_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimple_nameContext) +} + +func (s *Create_typeContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Create_typeContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Create_typeContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Create_typeContext) TABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLE, 0) +} + +func (s *Create_typeContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Create_typeContext) Column_def_table_constraints() IColumn_def_table_constraintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_def_table_constraintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_def_table_constraintsContext) +} + +func (s *Create_typeContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Create_typeContext) Null_notnull() INull_notnullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_notnullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_notnullContext) +} + +func (s *Create_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_type(s) + } +} + +func (s *Create_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_type(s) + } +} + +func (s *Create_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_type() (localctx ICreate_typeContext) { + localctx = NewCreate_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 724, TSqlParserRULE_create_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8802) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8803) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8804) + + var _x = p.Simple_name() + + localctx.(*Create_typeContext).name = _x + } + p.SetState(8810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFROM { + { + p.SetState(8805) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8806) + p.Data_type() + } + p.SetState(8808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserNOT || _la == TSqlParserNULL_ { + { + p.SetState(8807) + p.Null_notnull() + } + + } + + } + p.SetState(8818) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(8812) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8813) + p.Match(TSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8814) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8815) + p.Column_def_table_constraints() + } + { + p.SetState(8816) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_typeContext is an interface to support dynamic dispatch. +type IDrop_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name rule contexts. + GetName() ISimple_nameContext + + // SetName sets the name rule contexts. + SetName(ISimple_nameContext) + + // Getter signatures + DROP() antlr.TerminalNode + TYPE() antlr.TerminalNode + Simple_name() ISimple_nameContext + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsDrop_typeContext differentiates from other interfaces. + IsDrop_typeContext() +} + +type Drop_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name ISimple_nameContext +} + +func NewEmptyDrop_typeContext() *Drop_typeContext { + var p = new(Drop_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_type + return p +} + +func InitEmptyDrop_typeContext(p *Drop_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_drop_type +} + +func (*Drop_typeContext) IsDrop_typeContext() {} + +func NewDrop_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_typeContext { + var p = new(Drop_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_drop_type + + return p +} + +func (s *Drop_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_typeContext) GetName() ISimple_nameContext { return s.name } + +func (s *Drop_typeContext) SetName(v ISimple_nameContext) { s.name = v } + +func (s *Drop_typeContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Drop_typeContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *Drop_typeContext) Simple_name() ISimple_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimple_nameContext) +} + +func (s *Drop_typeContext) IF() antlr.TerminalNode { + return s.GetToken(TSqlParserIF, 0) +} + +func (s *Drop_typeContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *Drop_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDrop_type(s) + } +} + +func (s *Drop_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDrop_type(s) + } +} + +func (s *Drop_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDrop_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Drop_type() (localctx IDrop_typeContext) { + localctx = NewDrop_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 726, TSqlParserRULE_drop_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8820) + p.Match(TSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8821) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserIF { + { + p.SetState(8822) + p.Match(TSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8823) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8826) + + var _x = p.Simple_name() + + localctx.(*Drop_typeContext).name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRowset_function_limitedContext is an interface to support dynamic dispatch. +type IRowset_function_limitedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Openquery() IOpenqueryContext + Opendatasource() IOpendatasourceContext + + // IsRowset_function_limitedContext differentiates from other interfaces. + IsRowset_function_limitedContext() +} + +type Rowset_function_limitedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRowset_function_limitedContext() *Rowset_function_limitedContext { + var p = new(Rowset_function_limitedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_rowset_function_limited + return p +} + +func InitEmptyRowset_function_limitedContext(p *Rowset_function_limitedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_rowset_function_limited +} + +func (*Rowset_function_limitedContext) IsRowset_function_limitedContext() {} + +func NewRowset_function_limitedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rowset_function_limitedContext { + var p = new(Rowset_function_limitedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_rowset_function_limited + + return p +} + +func (s *Rowset_function_limitedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rowset_function_limitedContext) Openquery() IOpenqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpenqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpenqueryContext) +} + +func (s *Rowset_function_limitedContext) Opendatasource() IOpendatasourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpendatasourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpendatasourceContext) +} + +func (s *Rowset_function_limitedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rowset_function_limitedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rowset_function_limitedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRowset_function_limited(s) + } +} + +func (s *Rowset_function_limitedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRowset_function_limited(s) + } +} + +func (s *Rowset_function_limitedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRowset_function_limited(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Rowset_function_limited() (localctx IRowset_function_limitedContext) { + localctx = NewRowset_function_limitedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 728, TSqlParserRULE_rowset_function_limited) + p.SetState(8830) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserOPENQUERY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8828) + p.Openquery() + } + + case TSqlParserOPENDATASOURCE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8829) + p.Opendatasource() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpenqueryContext is an interface to support dynamic dispatch. +type IOpenqueryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetQuery returns the query token. + GetQuery() antlr.Token + + // SetQuery sets the query token. + SetQuery(antlr.Token) + + // GetLinked_server returns the linked_server rule contexts. + GetLinked_server() IId_Context + + // SetLinked_server sets the linked_server rule contexts. + SetLinked_server(IId_Context) + + // Getter signatures + OPENQUERY() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + COMMA() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Id_() IId_Context + STRING() antlr.TerminalNode + + // IsOpenqueryContext differentiates from other interfaces. + IsOpenqueryContext() +} + +type OpenqueryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + linked_server IId_Context + query antlr.Token +} + +func NewEmptyOpenqueryContext() *OpenqueryContext { + var p = new(OpenqueryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_openquery + return p +} + +func InitEmptyOpenqueryContext(p *OpenqueryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_openquery +} + +func (*OpenqueryContext) IsOpenqueryContext() {} + +func NewOpenqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpenqueryContext { + var p = new(OpenqueryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_openquery + + return p +} + +func (s *OpenqueryContext) GetParser() antlr.Parser { return s.parser } + +func (s *OpenqueryContext) GetQuery() antlr.Token { return s.query } + +func (s *OpenqueryContext) SetQuery(v antlr.Token) { s.query = v } + +func (s *OpenqueryContext) GetLinked_server() IId_Context { return s.linked_server } + +func (s *OpenqueryContext) SetLinked_server(v IId_Context) { s.linked_server = v } + +func (s *OpenqueryContext) OPENQUERY() antlr.TerminalNode { + return s.GetToken(TSqlParserOPENQUERY, 0) +} + +func (s *OpenqueryContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *OpenqueryContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *OpenqueryContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *OpenqueryContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *OpenqueryContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *OpenqueryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OpenqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OpenqueryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOpenquery(s) + } +} + +func (s *OpenqueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOpenquery(s) + } +} + +func (s *OpenqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOpenquery(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Openquery() (localctx IOpenqueryContext) { + localctx = NewOpenqueryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 730, TSqlParserRULE_openquery) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8832) + p.Match(TSqlParserOPENQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8833) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8834) + + var _x = p.Id_() + + localctx.(*OpenqueryContext).linked_server = _x + } + { + p.SetState(8835) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8836) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*OpenqueryContext).query = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8837) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpendatasourceContext is an interface to support dynamic dispatch. +type IOpendatasourceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetProvider returns the provider token. + GetProvider() antlr.Token + + // GetInit returns the init token. + GetInit() antlr.Token + + // SetProvider sets the provider token. + SetProvider(antlr.Token) + + // SetInit sets the init token. + SetInit(antlr.Token) + + // GetDatabase returns the database rule contexts. + GetDatabase() IId_Context + + // GetScheme returns the scheme rule contexts. + GetScheme() IId_Context + + // GetTable returns the table rule contexts. + GetTable() IId_Context + + // SetDatabase sets the database rule contexts. + SetDatabase(IId_Context) + + // SetScheme sets the scheme rule contexts. + SetScheme(IId_Context) + + // SetTable sets the table rule contexts. + SetTable(IId_Context) + + // Getter signatures + OPENDATASOURCE() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + COMMA() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + + // IsOpendatasourceContext differentiates from other interfaces. + IsOpendatasourceContext() +} + +type OpendatasourceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + provider antlr.Token + init antlr.Token + database IId_Context + scheme IId_Context + table IId_Context +} + +func NewEmptyOpendatasourceContext() *OpendatasourceContext { + var p = new(OpendatasourceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_opendatasource + return p +} + +func InitEmptyOpendatasourceContext(p *OpendatasourceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_opendatasource +} + +func (*OpendatasourceContext) IsOpendatasourceContext() {} + +func NewOpendatasourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpendatasourceContext { + var p = new(OpendatasourceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_opendatasource + + return p +} + +func (s *OpendatasourceContext) GetParser() antlr.Parser { return s.parser } + +func (s *OpendatasourceContext) GetProvider() antlr.Token { return s.provider } + +func (s *OpendatasourceContext) GetInit() antlr.Token { return s.init } + +func (s *OpendatasourceContext) SetProvider(v antlr.Token) { s.provider = v } + +func (s *OpendatasourceContext) SetInit(v antlr.Token) { s.init = v } + +func (s *OpendatasourceContext) GetDatabase() IId_Context { return s.database } + +func (s *OpendatasourceContext) GetScheme() IId_Context { return s.scheme } + +func (s *OpendatasourceContext) GetTable() IId_Context { return s.table } + +func (s *OpendatasourceContext) SetDatabase(v IId_Context) { s.database = v } + +func (s *OpendatasourceContext) SetScheme(v IId_Context) { s.scheme = v } + +func (s *OpendatasourceContext) SetTable(v IId_Context) { s.table = v } + +func (s *OpendatasourceContext) OPENDATASOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserOPENDATASOURCE, 0) +} + +func (s *OpendatasourceContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *OpendatasourceContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *OpendatasourceContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *OpendatasourceContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *OpendatasourceContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *OpendatasourceContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *OpendatasourceContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *OpendatasourceContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *OpendatasourceContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *OpendatasourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OpendatasourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OpendatasourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOpendatasource(s) + } +} + +func (s *OpendatasourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOpendatasource(s) + } +} + +func (s *OpendatasourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOpendatasource(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Opendatasource() (localctx IOpendatasourceContext) { + localctx = NewOpendatasourceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 732, TSqlParserRULE_opendatasource) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8839) + p.Match(TSqlParserOPENDATASOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8840) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8841) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*OpendatasourceContext).provider = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8842) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8843) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*OpendatasourceContext).init = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8844) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8845) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&22413823) != 0) { + { + p.SetState(8846) + + var _x = p.Id_() + + localctx.(*OpendatasourceContext).database = _x + } + + } + { + p.SetState(8849) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8851) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&22413823) != 0) { + { + p.SetState(8850) + + var _x = p.Id_() + + localctx.(*OpendatasourceContext).scheme = _x + } + + } + { + p.SetState(8853) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(8854) + + var _x = p.Id_() + + localctx.(*OpendatasourceContext).table = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeclare_statementContext is an interface to support dynamic dispatch. +type IDeclare_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_declare_local returns the _declare_local rule contexts. + Get_declare_local() IDeclare_localContext + + // Get_xml_declaration returns the _xml_declaration rule contexts. + Get_xml_declaration() IXml_declarationContext + + // Set_declare_local sets the _declare_local rule contexts. + Set_declare_local(IDeclare_localContext) + + // Set_xml_declaration sets the _xml_declaration rule contexts. + Set_xml_declaration(IXml_declarationContext) + + // GetLoc returns the loc rule context list. + GetLoc() []IDeclare_localContext + + // GetXml_dec returns the xml_dec rule context list. + GetXml_dec() []IXml_declarationContext + + // SetLoc sets the loc rule context list. + SetLoc([]IDeclare_localContext) + + // SetXml_dec sets the xml_dec rule context list. + SetXml_dec([]IXml_declarationContext) + + // Getter signatures + DECLARE() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + Data_type() IData_typeContext + Table_type_definition() ITable_type_definitionContext + Table_name() ITable_nameContext + AS() antlr.TerminalNode + AllDeclare_local() []IDeclare_localContext + Declare_local(i int) IDeclare_localContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Xml_type_definition() IXml_type_definitionContext + WITH() antlr.TerminalNode + XMLNAMESPACES() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllXml_declaration() []IXml_declarationContext + Xml_declaration(i int) IXml_declarationContext + + // IsDeclare_statementContext differentiates from other interfaces. + IsDeclare_statementContext() +} + +type Declare_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _declare_local IDeclare_localContext + loc []IDeclare_localContext + _xml_declaration IXml_declarationContext + xml_dec []IXml_declarationContext +} + +func NewEmptyDeclare_statementContext() *Declare_statementContext { + var p = new(Declare_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_declare_statement + return p +} + +func InitEmptyDeclare_statementContext(p *Declare_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_declare_statement +} + +func (*Declare_statementContext) IsDeclare_statementContext() {} + +func NewDeclare_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Declare_statementContext { + var p = new(Declare_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_declare_statement + + return p +} + +func (s *Declare_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Declare_statementContext) Get_declare_local() IDeclare_localContext { return s._declare_local } + +func (s *Declare_statementContext) Get_xml_declaration() IXml_declarationContext { + return s._xml_declaration +} + +func (s *Declare_statementContext) Set_declare_local(v IDeclare_localContext) { s._declare_local = v } + +func (s *Declare_statementContext) Set_xml_declaration(v IXml_declarationContext) { + s._xml_declaration = v +} + +func (s *Declare_statementContext) GetLoc() []IDeclare_localContext { return s.loc } + +func (s *Declare_statementContext) GetXml_dec() []IXml_declarationContext { return s.xml_dec } + +func (s *Declare_statementContext) SetLoc(v []IDeclare_localContext) { s.loc = v } + +func (s *Declare_statementContext) SetXml_dec(v []IXml_declarationContext) { s.xml_dec = v } + +func (s *Declare_statementContext) DECLARE() antlr.TerminalNode { + return s.GetToken(TSqlParserDECLARE, 0) +} + +func (s *Declare_statementContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Declare_statementContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Declare_statementContext) Table_type_definition() ITable_type_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_type_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_type_definitionContext) +} + +func (s *Declare_statementContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Declare_statementContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Declare_statementContext) AllDeclare_local() []IDeclare_localContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeclare_localContext); ok { + len++ + } + } + + tst := make([]IDeclare_localContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeclare_localContext); ok { + tst[i] = t.(IDeclare_localContext) + i++ + } + } + + return tst +} + +func (s *Declare_statementContext) Declare_local(i int) IDeclare_localContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclare_localContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeclare_localContext) +} + +func (s *Declare_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Declare_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Declare_statementContext) Xml_type_definition() IXml_type_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_type_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_type_definitionContext) +} + +func (s *Declare_statementContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Declare_statementContext) XMLNAMESPACES() antlr.TerminalNode { + return s.GetToken(TSqlParserXMLNAMESPACES, 0) +} + +func (s *Declare_statementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Declare_statementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Declare_statementContext) AllXml_declaration() []IXml_declarationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_declarationContext); ok { + len++ + } + } + + tst := make([]IXml_declarationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_declarationContext); ok { + tst[i] = t.(IXml_declarationContext) + i++ + } + } + + return tst +} + +func (s *Declare_statementContext) Xml_declaration(i int) IXml_declarationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_declarationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_declarationContext) +} + +func (s *Declare_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Declare_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Declare_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDeclare_statement(s) + } +} + +func (s *Declare_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDeclare_statement(s) + } +} + +func (s *Declare_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDeclare_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Declare_statement() (localctx IDeclare_statementContext) { + localctx = NewDeclare_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 734, TSqlParserRULE_declare_statement) + var _la int + + p.SetState(8894) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1138, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8856) + p.Match(TSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8857) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8859) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(8858) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1134, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8861) + p.Data_type() + } + + case 2: + { + p.SetState(8862) + p.Table_type_definition() + } + + case 3: + { + p.SetState(8863) + p.Table_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8866) + p.Match(TSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8867) + + var _x = p.Declare_local() + + localctx.(*Declare_statementContext)._declare_local = _x + } + localctx.(*Declare_statementContext).loc = append(localctx.(*Declare_statementContext).loc, localctx.(*Declare_statementContext)._declare_local) + p.SetState(8872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8868) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8869) + + var _x = p.Declare_local() + + localctx.(*Declare_statementContext)._declare_local = _x + } + localctx.(*Declare_statementContext).loc = append(localctx.(*Declare_statementContext).loc, localctx.(*Declare_statementContext)._declare_local) + + p.SetState(8874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8875) + p.Match(TSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8876) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(8877) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8880) + p.Xml_type_definition() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8881) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8882) + p.Match(TSqlParserXMLNAMESPACES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8883) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8884) + + var _x = p.Xml_declaration() + + localctx.(*Declare_statementContext)._xml_declaration = _x + } + localctx.(*Declare_statementContext).xml_dec = append(localctx.(*Declare_statementContext).xml_dec, localctx.(*Declare_statementContext)._xml_declaration) + p.SetState(8889) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(8885) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8886) + + var _x = p.Xml_declaration() + + localctx.(*Declare_statementContext)._xml_declaration = _x + } + localctx.(*Declare_statementContext).xml_dec = append(localctx.(*Declare_statementContext).xml_dec, localctx.(*Declare_statementContext)._xml_declaration) + + p.SetState(8891) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8892) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_declarationContext is an interface to support dynamic dispatch. +type IXml_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetXml_namespace_uri returns the xml_namespace_uri token. + GetXml_namespace_uri() antlr.Token + + // SetXml_namespace_uri sets the xml_namespace_uri token. + SetXml_namespace_uri(antlr.Token) + + // Getter signatures + AS() antlr.TerminalNode + Id_() IId_Context + STRING() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsXml_declarationContext differentiates from other interfaces. + IsXml_declarationContext() +} + +type Xml_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + xml_namespace_uri antlr.Token +} + +func NewEmptyXml_declarationContext() *Xml_declarationContext { + var p = new(Xml_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_declaration + return p +} + +func InitEmptyXml_declarationContext(p *Xml_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_declaration +} + +func (*Xml_declarationContext) IsXml_declarationContext() {} + +func NewXml_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_declarationContext { + var p = new(Xml_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_xml_declaration + + return p +} + +func (s *Xml_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_declarationContext) GetXml_namespace_uri() antlr.Token { return s.xml_namespace_uri } + +func (s *Xml_declarationContext) SetXml_namespace_uri(v antlr.Token) { s.xml_namespace_uri = v } + +func (s *Xml_declarationContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Xml_declarationContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Xml_declarationContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Xml_declarationContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Xml_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterXml_declaration(s) + } +} + +func (s *Xml_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitXml_declaration(s) + } +} + +func (s *Xml_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitXml_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Xml_declaration() (localctx IXml_declarationContext) { + localctx = NewXml_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 736, TSqlParserRULE_xml_declaration) + p.SetState(8901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8896) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Xml_declarationContext).xml_namespace_uri = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8897) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8898) + p.Id_() + } + + case TSqlParserDEFAULT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8899) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8900) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICursor_statementContext is an interface to support dynamic dispatch. +type ICursor_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLOSE() antlr.TerminalNode + Cursor_name() ICursor_nameContext + GLOBAL() antlr.TerminalNode + SEMI() antlr.TerminalNode + DEALLOCATE() antlr.TerminalNode + CURSOR() antlr.TerminalNode + Declare_cursor() IDeclare_cursorContext + Fetch_cursor() IFetch_cursorContext + OPEN() antlr.TerminalNode + + // IsCursor_statementContext differentiates from other interfaces. + IsCursor_statementContext() +} + +type Cursor_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_statementContext() *Cursor_statementContext { + var p = new(Cursor_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_cursor_statement + return p +} + +func InitEmptyCursor_statementContext(p *Cursor_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_cursor_statement +} + +func (*Cursor_statementContext) IsCursor_statementContext() {} + +func NewCursor_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_statementContext { + var p = new(Cursor_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_cursor_statement + + return p +} + +func (s *Cursor_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_statementContext) CLOSE() antlr.TerminalNode { + return s.GetToken(TSqlParserCLOSE, 0) +} + +func (s *Cursor_statementContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Cursor_statementContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(TSqlParserGLOBAL, 0) +} + +func (s *Cursor_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Cursor_statementContext) DEALLOCATE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEALLOCATE, 0) +} + +func (s *Cursor_statementContext) CURSOR() antlr.TerminalNode { + return s.GetToken(TSqlParserCURSOR, 0) +} + +func (s *Cursor_statementContext) Declare_cursor() IDeclare_cursorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclare_cursorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeclare_cursorContext) +} + +func (s *Cursor_statementContext) Fetch_cursor() IFetch_cursorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFetch_cursorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFetch_cursorContext) +} + +func (s *Cursor_statementContext) OPEN() antlr.TerminalNode { + return s.GetToken(TSqlParserOPEN, 0) +} + +func (s *Cursor_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCursor_statement(s) + } +} + +func (s *Cursor_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCursor_statement(s) + } +} + +func (s *Cursor_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCursor_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Cursor_statement() (localctx ICursor_statementContext) { + localctx = NewCursor_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 738, TSqlParserRULE_cursor_statement) + var _la int + + p.SetState(8932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCLOSE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8903) + p.Match(TSqlParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8905) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1140, p.GetParserRuleContext()) == 1 { + { + p.SetState(8904) + p.Match(TSqlParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8907) + p.Cursor_name() + } + p.SetState(8909) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1141, p.GetParserRuleContext()) == 1 { + { + p.SetState(8908) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserDEALLOCATE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8911) + p.Match(TSqlParserDEALLOCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8913) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1142, p.GetParserRuleContext()) == 1 { + { + p.SetState(8912) + p.Match(TSqlParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCURSOR { + { + p.SetState(8915) + p.Match(TSqlParserCURSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8918) + p.Cursor_name() + } + p.SetState(8920) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1144, p.GetParserRuleContext()) == 1 { + { + p.SetState(8919) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserDECLARE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8922) + p.Declare_cursor() + } + + case TSqlParserFETCH: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8923) + p.Fetch_cursor() + } + + case TSqlParserOPEN: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(8924) + p.Match(TSqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8926) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1145, p.GetParserRuleContext()) == 1 { + { + p.SetState(8925) + p.Match(TSqlParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8928) + p.Cursor_name() + } + p.SetState(8930) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1146, p.GetParserRuleContext()) == 1 { + { + p.SetState(8929) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBackup_databaseContext is an interface to support dynamic dispatch. +type IBackup_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFile_or_filegroup returns the file_or_filegroup token. + GetFile_or_filegroup() antlr.Token + + // GetMedianame returns the medianame token. + GetMedianame() antlr.Token + + // GetStats_percent returns the stats_percent token. + GetStats_percent() antlr.Token + + // SetFile_or_filegroup sets the file_or_filegroup token. + SetFile_or_filegroup(antlr.Token) + + // SetMedianame sets the medianame token. + SetMedianame(antlr.Token) + + // SetStats_percent sets the stats_percent token. + SetStats_percent(antlr.Token) + + // GetDatabase_name returns the database_name rule contexts. + GetDatabase_name() IId_Context + + // GetLogical_device_name returns the logical_device_name rule contexts. + GetLogical_device_name() IId_Context + + // GetBackup_set_name returns the backup_set_name rule contexts. + GetBackup_set_name() IId_Context + + // GetEncryptor_name returns the encryptor_name rule contexts. + GetEncryptor_name() IId_Context + + // SetDatabase_name sets the database_name rule contexts. + SetDatabase_name(IId_Context) + + // SetLogical_device_name sets the logical_device_name rule contexts. + SetLogical_device_name(IId_Context) + + // SetBackup_set_name sets the backup_set_name rule contexts. + SetBackup_set_name(IId_Context) + + // SetEncryptor_name sets the encryptor_name rule contexts. + SetEncryptor_name(IId_Context) + + // Getter signatures + BACKUP() antlr.TerminalNode + DATABASE() antlr.TerminalNode + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + READ_WRITE_FILEGROUPS() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + AllFILE() []antlr.TerminalNode + FILE(i int) antlr.TerminalNode + AllFILEGROUP() []antlr.TerminalNode + FILEGROUP(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllDISK() []antlr.TerminalNode + DISK(i int) antlr.TerminalNode + AllTAPE() []antlr.TerminalNode + TAPE(i int) antlr.TerminalNode + AllURL() []antlr.TerminalNode + URL(i int) antlr.TerminalNode + AllMIRROR() []antlr.TerminalNode + MIRROR(i int) antlr.TerminalNode + AllDIFFERENTIAL() []antlr.TerminalNode + DIFFERENTIAL(i int) antlr.TerminalNode + AllCOPY_ONLY() []antlr.TerminalNode + COPY_ONLY(i int) antlr.TerminalNode + AllDESCRIPTION() []antlr.TerminalNode + DESCRIPTION(i int) antlr.TerminalNode + AllNAME() []antlr.TerminalNode + NAME(i int) antlr.TerminalNode + AllCREDENTIAL() []antlr.TerminalNode + CREDENTIAL(i int) antlr.TerminalNode + AllFILE_SNAPSHOT() []antlr.TerminalNode + FILE_SNAPSHOT(i int) antlr.TerminalNode + AllMEDIADESCRIPTION() []antlr.TerminalNode + MEDIADESCRIPTION(i int) antlr.TerminalNode + AllMEDIANAME() []antlr.TerminalNode + MEDIANAME(i int) antlr.TerminalNode + AllBLOCKSIZE() []antlr.TerminalNode + BLOCKSIZE(i int) antlr.TerminalNode + AllBUFFERCOUNT() []antlr.TerminalNode + BUFFERCOUNT(i int) antlr.TerminalNode + AllMAXTRANSFER() []antlr.TerminalNode + MAXTRANSFER(i int) antlr.TerminalNode + AllRESTART() []antlr.TerminalNode + RESTART(i int) antlr.TerminalNode + AllSTATS() []antlr.TerminalNode + STATS(i int) antlr.TerminalNode + AllENCRYPTION() []antlr.TerminalNode + ENCRYPTION(i int) antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllALGORITHM() []antlr.TerminalNode + ALGORITHM(i int) antlr.TerminalNode + AllSERVER() []antlr.TerminalNode + SERVER(i int) antlr.TerminalNode + AllCERTIFICATE() []antlr.TerminalNode + CERTIFICATE(i int) antlr.TerminalNode + AllCOMPRESSION() []antlr.TerminalNode + COMPRESSION(i int) antlr.TerminalNode + AllNO_COMPRESSION() []antlr.TerminalNode + NO_COMPRESSION(i int) antlr.TerminalNode + AllNOINIT() []antlr.TerminalNode + NOINIT(i int) antlr.TerminalNode + AllINIT() []antlr.TerminalNode + INIT(i int) antlr.TerminalNode + AllNOSKIP() []antlr.TerminalNode + NOSKIP(i int) antlr.TerminalNode + AllSKIP_KEYWORD() []antlr.TerminalNode + SKIP_KEYWORD(i int) antlr.TerminalNode + AllNOFORMAT() []antlr.TerminalNode + NOFORMAT(i int) antlr.TerminalNode + AllFORMAT() []antlr.TerminalNode + FORMAT(i int) antlr.TerminalNode + AllNO_CHECKSUM() []antlr.TerminalNode + NO_CHECKSUM(i int) antlr.TerminalNode + AllCHECKSUM() []antlr.TerminalNode + CHECKSUM(i int) antlr.TerminalNode + AllSTOP_ON_ERROR() []antlr.TerminalNode + STOP_ON_ERROR(i int) antlr.TerminalNode + AllCONTINUE_AFTER_ERROR() []antlr.TerminalNode + CONTINUE_AFTER_ERROR(i int) antlr.TerminalNode + AllREWIND() []antlr.TerminalNode + REWIND(i int) antlr.TerminalNode + AllNOREWIND() []antlr.TerminalNode + NOREWIND(i int) antlr.TerminalNode + AllLOAD() []antlr.TerminalNode + LOAD(i int) antlr.TerminalNode + AllNOUNLOAD() []antlr.TerminalNode + NOUNLOAD(i int) antlr.TerminalNode + AllAES_128() []antlr.TerminalNode + AES_128(i int) antlr.TerminalNode + AllAES_192() []antlr.TerminalNode + AES_192(i int) antlr.TerminalNode + AllAES_256() []antlr.TerminalNode + AES_256(i int) antlr.TerminalNode + AllTRIPLE_DES_3KEY() []antlr.TerminalNode + TRIPLE_DES_3KEY(i int) antlr.TerminalNode + AllEXPIREDATE() []antlr.TerminalNode + EXPIREDATE(i int) antlr.TerminalNode + AllRETAINDAYS() []antlr.TerminalNode + RETAINDAYS(i int) antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + AllASYMMETRIC() []antlr.TerminalNode + ASYMMETRIC(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + + // IsBackup_databaseContext differentiates from other interfaces. + IsBackup_databaseContext() +} + +type Backup_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database_name IId_Context + file_or_filegroup antlr.Token + logical_device_name IId_Context + backup_set_name IId_Context + medianame antlr.Token + stats_percent antlr.Token + encryptor_name IId_Context +} + +func NewEmptyBackup_databaseContext() *Backup_databaseContext { + var p = new(Backup_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_backup_database + return p +} + +func InitEmptyBackup_databaseContext(p *Backup_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_backup_database +} + +func (*Backup_databaseContext) IsBackup_databaseContext() {} + +func NewBackup_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_databaseContext { + var p = new(Backup_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_backup_database + + return p +} + +func (s *Backup_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Backup_databaseContext) GetFile_or_filegroup() antlr.Token { return s.file_or_filegroup } + +func (s *Backup_databaseContext) GetMedianame() antlr.Token { return s.medianame } + +func (s *Backup_databaseContext) GetStats_percent() antlr.Token { return s.stats_percent } + +func (s *Backup_databaseContext) SetFile_or_filegroup(v antlr.Token) { s.file_or_filegroup = v } + +func (s *Backup_databaseContext) SetMedianame(v antlr.Token) { s.medianame = v } + +func (s *Backup_databaseContext) SetStats_percent(v antlr.Token) { s.stats_percent = v } + +func (s *Backup_databaseContext) GetDatabase_name() IId_Context { return s.database_name } + +func (s *Backup_databaseContext) GetLogical_device_name() IId_Context { return s.logical_device_name } + +func (s *Backup_databaseContext) GetBackup_set_name() IId_Context { return s.backup_set_name } + +func (s *Backup_databaseContext) GetEncryptor_name() IId_Context { return s.encryptor_name } + +func (s *Backup_databaseContext) SetDatabase_name(v IId_Context) { s.database_name = v } + +func (s *Backup_databaseContext) SetLogical_device_name(v IId_Context) { s.logical_device_name = v } + +func (s *Backup_databaseContext) SetBackup_set_name(v IId_Context) { s.backup_set_name = v } + +func (s *Backup_databaseContext) SetEncryptor_name(v IId_Context) { s.encryptor_name = v } + +func (s *Backup_databaseContext) BACKUP() antlr.TerminalNode { + return s.GetToken(TSqlParserBACKUP, 0) +} + +func (s *Backup_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Backup_databaseContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTO) +} + +func (s *Backup_databaseContext) TO(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTO, i) +} + +func (s *Backup_databaseContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Backup_databaseContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Backup_databaseContext) READ_WRITE_FILEGROUPS() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_WRITE_FILEGROUPS, 0) +} + +func (s *Backup_databaseContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Backup_databaseContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Backup_databaseContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Backup_databaseContext) AllFILE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFILE) +} + +func (s *Backup_databaseContext) FILE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, i) +} + +func (s *Backup_databaseContext) AllFILEGROUP() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFILEGROUP) +} + +func (s *Backup_databaseContext) FILEGROUP(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROUP, i) +} + +func (s *Backup_databaseContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Backup_databaseContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Backup_databaseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Backup_databaseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Backup_databaseContext) AllDISK() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDISK) +} + +func (s *Backup_databaseContext) DISK(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDISK, i) +} + +func (s *Backup_databaseContext) AllTAPE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTAPE) +} + +func (s *Backup_databaseContext) TAPE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTAPE, i) +} + +func (s *Backup_databaseContext) AllURL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserURL) +} + +func (s *Backup_databaseContext) URL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserURL, i) +} + +func (s *Backup_databaseContext) AllMIRROR() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMIRROR) +} + +func (s *Backup_databaseContext) MIRROR(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMIRROR, i) +} + +func (s *Backup_databaseContext) AllDIFFERENTIAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDIFFERENTIAL) +} + +func (s *Backup_databaseContext) DIFFERENTIAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDIFFERENTIAL, i) +} + +func (s *Backup_databaseContext) AllCOPY_ONLY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOPY_ONLY) +} + +func (s *Backup_databaseContext) COPY_ONLY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOPY_ONLY, i) +} + +func (s *Backup_databaseContext) AllDESCRIPTION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDESCRIPTION) +} + +func (s *Backup_databaseContext) DESCRIPTION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDESCRIPTION, i) +} + +func (s *Backup_databaseContext) AllNAME() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNAME) +} + +func (s *Backup_databaseContext) NAME(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, i) +} + +func (s *Backup_databaseContext) AllCREDENTIAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCREDENTIAL) +} + +func (s *Backup_databaseContext) CREDENTIAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCREDENTIAL, i) +} + +func (s *Backup_databaseContext) AllFILE_SNAPSHOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFILE_SNAPSHOT) +} + +func (s *Backup_databaseContext) FILE_SNAPSHOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFILE_SNAPSHOT, i) +} + +func (s *Backup_databaseContext) AllMEDIADESCRIPTION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMEDIADESCRIPTION) +} + +func (s *Backup_databaseContext) MEDIADESCRIPTION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMEDIADESCRIPTION, i) +} + +func (s *Backup_databaseContext) AllMEDIANAME() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMEDIANAME) +} + +func (s *Backup_databaseContext) MEDIANAME(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMEDIANAME, i) +} + +func (s *Backup_databaseContext) AllBLOCKSIZE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBLOCKSIZE) +} + +func (s *Backup_databaseContext) BLOCKSIZE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBLOCKSIZE, i) +} + +func (s *Backup_databaseContext) AllBUFFERCOUNT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBUFFERCOUNT) +} + +func (s *Backup_databaseContext) BUFFERCOUNT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBUFFERCOUNT, i) +} + +func (s *Backup_databaseContext) AllMAXTRANSFER() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMAXTRANSFER) +} + +func (s *Backup_databaseContext) MAXTRANSFER(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMAXTRANSFER, i) +} + +func (s *Backup_databaseContext) AllRESTART() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRESTART) +} + +func (s *Backup_databaseContext) RESTART(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRESTART, i) +} + +func (s *Backup_databaseContext) AllSTATS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTATS) +} + +func (s *Backup_databaseContext) STATS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTATS, i) +} + +func (s *Backup_databaseContext) AllENCRYPTION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserENCRYPTION) +} + +func (s *Backup_databaseContext) ENCRYPTION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, i) +} + +func (s *Backup_databaseContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Backup_databaseContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Backup_databaseContext) AllALGORITHM() []antlr.TerminalNode { + return s.GetTokens(TSqlParserALGORITHM) +} + +func (s *Backup_databaseContext) ALGORITHM(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserALGORITHM, i) +} + +func (s *Backup_databaseContext) AllSERVER() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSERVER) +} + +func (s *Backup_databaseContext) SERVER(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, i) +} + +func (s *Backup_databaseContext) AllCERTIFICATE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCERTIFICATE) +} + +func (s *Backup_databaseContext) CERTIFICATE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, i) +} + +func (s *Backup_databaseContext) AllCOMPRESSION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMPRESSION) +} + +func (s *Backup_databaseContext) COMPRESSION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPRESSION, i) +} + +func (s *Backup_databaseContext) AllNO_COMPRESSION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNO_COMPRESSION) +} + +func (s *Backup_databaseContext) NO_COMPRESSION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNO_COMPRESSION, i) +} + +func (s *Backup_databaseContext) AllNOINIT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOINIT) +} + +func (s *Backup_databaseContext) NOINIT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOINIT, i) +} + +func (s *Backup_databaseContext) AllINIT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserINIT) +} + +func (s *Backup_databaseContext) INIT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserINIT, i) +} + +func (s *Backup_databaseContext) AllNOSKIP() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOSKIP) +} + +func (s *Backup_databaseContext) NOSKIP(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOSKIP, i) +} + +func (s *Backup_databaseContext) AllSKIP_KEYWORD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSKIP_KEYWORD) +} + +func (s *Backup_databaseContext) SKIP_KEYWORD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSKIP_KEYWORD, i) +} + +func (s *Backup_databaseContext) AllNOFORMAT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOFORMAT) +} + +func (s *Backup_databaseContext) NOFORMAT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOFORMAT, i) +} + +func (s *Backup_databaseContext) AllFORMAT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFORMAT) +} + +func (s *Backup_databaseContext) FORMAT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFORMAT, i) +} + +func (s *Backup_databaseContext) AllNO_CHECKSUM() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNO_CHECKSUM) +} + +func (s *Backup_databaseContext) NO_CHECKSUM(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNO_CHECKSUM, i) +} + +func (s *Backup_databaseContext) AllCHECKSUM() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCHECKSUM) +} + +func (s *Backup_databaseContext) CHECKSUM(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKSUM, i) +} + +func (s *Backup_databaseContext) AllSTOP_ON_ERROR() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTOP_ON_ERROR) +} + +func (s *Backup_databaseContext) STOP_ON_ERROR(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTOP_ON_ERROR, i) +} + +func (s *Backup_databaseContext) AllCONTINUE_AFTER_ERROR() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCONTINUE_AFTER_ERROR) +} + +func (s *Backup_databaseContext) CONTINUE_AFTER_ERROR(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCONTINUE_AFTER_ERROR, i) +} + +func (s *Backup_databaseContext) AllREWIND() []antlr.TerminalNode { + return s.GetTokens(TSqlParserREWIND) +} + +func (s *Backup_databaseContext) REWIND(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserREWIND, i) +} + +func (s *Backup_databaseContext) AllNOREWIND() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOREWIND) +} + +func (s *Backup_databaseContext) NOREWIND(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOREWIND, i) +} + +func (s *Backup_databaseContext) AllLOAD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOAD) +} + +func (s *Backup_databaseContext) LOAD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOAD, i) +} + +func (s *Backup_databaseContext) AllNOUNLOAD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOUNLOAD) +} + +func (s *Backup_databaseContext) NOUNLOAD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOUNLOAD, i) +} + +func (s *Backup_databaseContext) AllAES_128() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAES_128) +} + +func (s *Backup_databaseContext) AES_128(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAES_128, i) +} + +func (s *Backup_databaseContext) AllAES_192() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAES_192) +} + +func (s *Backup_databaseContext) AES_192(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAES_192, i) +} + +func (s *Backup_databaseContext) AllAES_256() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAES_256) +} + +func (s *Backup_databaseContext) AES_256(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAES_256, i) +} + +func (s *Backup_databaseContext) AllTRIPLE_DES_3KEY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTRIPLE_DES_3KEY) +} + +func (s *Backup_databaseContext) TRIPLE_DES_3KEY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTRIPLE_DES_3KEY, i) +} + +func (s *Backup_databaseContext) AllEXPIREDATE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEXPIREDATE) +} + +func (s *Backup_databaseContext) EXPIREDATE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEXPIREDATE, i) +} + +func (s *Backup_databaseContext) AllRETAINDAYS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRETAINDAYS) +} + +func (s *Backup_databaseContext) RETAINDAYS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRETAINDAYS, i) +} + +func (s *Backup_databaseContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Backup_databaseContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Backup_databaseContext) AllASYMMETRIC() []antlr.TerminalNode { + return s.GetTokens(TSqlParserASYMMETRIC) +} + +func (s *Backup_databaseContext) ASYMMETRIC(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, i) +} + +func (s *Backup_databaseContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserKEY) +} + +func (s *Backup_databaseContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, i) +} + +func (s *Backup_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Backup_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Backup_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBackup_database(s) + } +} + +func (s *Backup_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBackup_database(s) + } +} + +func (s *Backup_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBackup_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Backup_database() (localctx IBackup_databaseContext) { + localctx = NewBackup_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 740, TSqlParserRULE_backup_database) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8934) + p.Match(TSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8935) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(8936) + + var _x = p.Id_() + + localctx.(*Backup_databaseContext).database_name = _x + } + + p.SetState(8949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserREAD_WRITE_FILEGROUPS { + { + p.SetState(8937) + p.Match(TSqlParserREAD_WRITE_FILEGROUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8946) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1149, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(8939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(8938) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8941) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFILE || _la == TSqlParserFILEGROUP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8942) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8943) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Backup_databaseContext).file_or_filegroup = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1149, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } + p.SetState(8959) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserFILE || _la == TSqlParserFILEGROUP || _la == TSqlParserCOMMA { + p.SetState(8952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(8951) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8954) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFILE || _la == TSqlParserFILEGROUP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8955) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8956) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Backup_databaseContext).file_or_filegroup = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(8961) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8985) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1158, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8962) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(8964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(8963) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8966) + + var _x = p.Id_() + + localctx.(*Backup_databaseContext).logical_device_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8969) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1154, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + { + p.SetState(8971) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8981) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(8973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(8972) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8975) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISK || _la == TSqlParserTAPE || _la == TSqlParserURL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8976) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(8977) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(8978) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8983) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1157, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(9020) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1166, p.GetParserRuleContext()) == 1 { + p.SetState(8997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(8987) + p.Match(TSqlParserMIRROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8988) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(8990) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(8989) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8992) + + var _x = p.Id_() + + localctx.(*Backup_databaseContext).logical_device_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8995) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1160, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8999) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1161, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1166, p.GetParserRuleContext()) == 2 { + p.SetState(9016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(9001) + p.Match(TSqlParserMIRROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9002) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9012) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(9004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9003) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9006) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISK || _la == TSqlParserTAPE || _la == TSqlParserURL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9007) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9010) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(9008) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9009) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9014) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1164, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9018) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1165, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9182) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1202, p.GetParserRuleContext()) == 1 { + { + p.SetState(9022) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1201, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(9177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1200, p.GetParserRuleContext()) { + case 1: + p.SetState(9024) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9023) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9026) + p.Match(TSqlParserDIFFERENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(9028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9027) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9030) + p.Match(TSqlParserCOPY_ONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.SetState(9032) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9031) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9034) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCOMPRESSION || _la == TSqlParserNO_COMPRESSION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 4: + p.SetState(9036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9035) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9038) + p.Match(TSqlParserDESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9039) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9042) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(9040) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9041) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 5: + p.SetState(9045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9044) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9047) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9048) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9049) + + var _x = p.Id_() + + localctx.(*Backup_databaseContext).backup_set_name = _x + } + + case 6: + p.SetState(9051) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9050) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9053) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.SetState(9055) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9054) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9057) + p.Match(TSqlParserFILE_SNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.SetState(9059) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9058) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9073) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserEXPIREDATE: + { + p.SetState(9061) + p.Match(TSqlParserEXPIREDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9062) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9065) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(9063) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9064) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserRETAINDAYS: + { + p.SetState(9067) + p.Match(TSqlParserRETAINDAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9068) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(9069) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9070) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 9: + p.SetState(9076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9075) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9078) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserINIT || _la == TSqlParserNOINIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 10: + p.SetState(9080) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9079) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9082) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNOSKIP || _la == TSqlParserSKIP_KEYWORD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 11: + p.SetState(9084) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9083) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9086) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFORMAT || _la == TSqlParserNOFORMAT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 12: + p.SetState(9088) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9087) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9090) + p.Match(TSqlParserMEDIADESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9091) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(9092) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9093) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 13: + p.SetState(9097) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9096) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9099) + p.Match(TSqlParserMEDIANAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9100) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(9101) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Backup_databaseContext).medianame = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.SetState(9103) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9102) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9105) + p.Match(TSqlParserBLOCKSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9106) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(9107) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9108) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 15: + p.SetState(9112) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9111) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9114) + p.Match(TSqlParserBUFFERCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9115) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(9116) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9117) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 16: + p.SetState(9121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9120) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9123) + p.Match(TSqlParserMAXTRANSFER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9124) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(9125) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9126) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 17: + p.SetState(9130) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9129) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9132) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCHECKSUM || _la == TSqlParserNO_CHECKSUM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 18: + p.SetState(9134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9133) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9136) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCONTINUE_AFTER_ERROR || _la == TSqlParserSTOP_ON_ERROR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 19: + p.SetState(9138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9137) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9140) + p.Match(TSqlParserRESTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.SetState(9142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9141) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9144) + p.Match(TSqlParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserEQUAL { + { + p.SetState(9145) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9146) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Backup_databaseContext).stats_percent = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 21: + p.SetState(9150) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9149) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9152) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNOREWIND || _la == TSqlParserREWIND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 22: + p.SetState(9154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9153) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9156) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOAD || _la == TSqlParserNOUNLOAD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 23: + p.SetState(9158) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9157) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9160) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9161) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9162) + p.Match(TSqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9163) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9164) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&229376) != 0) || _la == TSqlParserTRIPLE_DES_3KEY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9165) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9166) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9167) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9168) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1199, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9169) + + var _x = p.Id_() + + localctx.(*Backup_databaseContext).encryptor_name = _x + } + + case 2: + { + p.SetState(9170) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9171) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9172) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9173) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9174) + + var _x = p.Id_() + + localctx.(*Backup_databaseContext).encryptor_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(9181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1201, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBackup_logContext is an interface to support dynamic dispatch. +type IBackup_logContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMedianame returns the medianame token. + GetMedianame() antlr.Token + + // GetStats_percent returns the stats_percent token. + GetStats_percent() antlr.Token + + // GetUndo_file_name returns the undo_file_name token. + GetUndo_file_name() antlr.Token + + // SetMedianame sets the medianame token. + SetMedianame(antlr.Token) + + // SetStats_percent sets the stats_percent token. + SetStats_percent(antlr.Token) + + // SetUndo_file_name sets the undo_file_name token. + SetUndo_file_name(antlr.Token) + + // GetDatabase_name returns the database_name rule contexts. + GetDatabase_name() IId_Context + + // GetLogical_device_name returns the logical_device_name rule contexts. + GetLogical_device_name() IId_Context + + // GetBackup_set_name returns the backup_set_name rule contexts. + GetBackup_set_name() IId_Context + + // GetEncryptor_name returns the encryptor_name rule contexts. + GetEncryptor_name() IId_Context + + // SetDatabase_name sets the database_name rule contexts. + SetDatabase_name(IId_Context) + + // SetLogical_device_name sets the logical_device_name rule contexts. + SetLogical_device_name(IId_Context) + + // SetBackup_set_name sets the backup_set_name rule contexts. + SetBackup_set_name(IId_Context) + + // SetEncryptor_name sets the encryptor_name rule contexts. + SetEncryptor_name(IId_Context) + + // Getter signatures + BACKUP() antlr.TerminalNode + LOG() antlr.TerminalNode + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + WITH() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllDISK() []antlr.TerminalNode + DISK(i int) antlr.TerminalNode + AllTAPE() []antlr.TerminalNode + TAPE(i int) antlr.TerminalNode + AllURL() []antlr.TerminalNode + URL(i int) antlr.TerminalNode + AllMIRROR() []antlr.TerminalNode + MIRROR(i int) antlr.TerminalNode + AllDIFFERENTIAL() []antlr.TerminalNode + DIFFERENTIAL(i int) antlr.TerminalNode + AllCOPY_ONLY() []antlr.TerminalNode + COPY_ONLY(i int) antlr.TerminalNode + AllDESCRIPTION() []antlr.TerminalNode + DESCRIPTION(i int) antlr.TerminalNode + AllNAME() []antlr.TerminalNode + NAME(i int) antlr.TerminalNode + AllCREDENTIAL() []antlr.TerminalNode + CREDENTIAL(i int) antlr.TerminalNode + AllFILE_SNAPSHOT() []antlr.TerminalNode + FILE_SNAPSHOT(i int) antlr.TerminalNode + AllMEDIADESCRIPTION() []antlr.TerminalNode + MEDIADESCRIPTION(i int) antlr.TerminalNode + AllMEDIANAME() []antlr.TerminalNode + MEDIANAME(i int) antlr.TerminalNode + AllBLOCKSIZE() []antlr.TerminalNode + BLOCKSIZE(i int) antlr.TerminalNode + AllBUFFERCOUNT() []antlr.TerminalNode + BUFFERCOUNT(i int) antlr.TerminalNode + AllMAXTRANSFER() []antlr.TerminalNode + MAXTRANSFER(i int) antlr.TerminalNode + AllRESTART() []antlr.TerminalNode + RESTART(i int) antlr.TerminalNode + AllSTATS() []antlr.TerminalNode + STATS(i int) antlr.TerminalNode + AllNO_TRUNCATE() []antlr.TerminalNode + NO_TRUNCATE(i int) antlr.TerminalNode + AllENCRYPTION() []antlr.TerminalNode + ENCRYPTION(i int) antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllALGORITHM() []antlr.TerminalNode + ALGORITHM(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllSERVER() []antlr.TerminalNode + SERVER(i int) antlr.TerminalNode + AllCERTIFICATE() []antlr.TerminalNode + CERTIFICATE(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllCOMPRESSION() []antlr.TerminalNode + COMPRESSION(i int) antlr.TerminalNode + AllNO_COMPRESSION() []antlr.TerminalNode + NO_COMPRESSION(i int) antlr.TerminalNode + AllNOINIT() []antlr.TerminalNode + NOINIT(i int) antlr.TerminalNode + AllINIT() []antlr.TerminalNode + INIT(i int) antlr.TerminalNode + AllNOSKIP() []antlr.TerminalNode + NOSKIP(i int) antlr.TerminalNode + AllSKIP_KEYWORD() []antlr.TerminalNode + SKIP_KEYWORD(i int) antlr.TerminalNode + AllNOFORMAT() []antlr.TerminalNode + NOFORMAT(i int) antlr.TerminalNode + AllFORMAT() []antlr.TerminalNode + FORMAT(i int) antlr.TerminalNode + AllNO_CHECKSUM() []antlr.TerminalNode + NO_CHECKSUM(i int) antlr.TerminalNode + AllCHECKSUM() []antlr.TerminalNode + CHECKSUM(i int) antlr.TerminalNode + AllSTOP_ON_ERROR() []antlr.TerminalNode + STOP_ON_ERROR(i int) antlr.TerminalNode + AllCONTINUE_AFTER_ERROR() []antlr.TerminalNode + CONTINUE_AFTER_ERROR(i int) antlr.TerminalNode + AllREWIND() []antlr.TerminalNode + REWIND(i int) antlr.TerminalNode + AllNOREWIND() []antlr.TerminalNode + NOREWIND(i int) antlr.TerminalNode + AllLOAD() []antlr.TerminalNode + LOAD(i int) antlr.TerminalNode + AllNOUNLOAD() []antlr.TerminalNode + NOUNLOAD(i int) antlr.TerminalNode + AllAES_128() []antlr.TerminalNode + AES_128(i int) antlr.TerminalNode + AllAES_192() []antlr.TerminalNode + AES_192(i int) antlr.TerminalNode + AllAES_256() []antlr.TerminalNode + AES_256(i int) antlr.TerminalNode + AllTRIPLE_DES_3KEY() []antlr.TerminalNode + TRIPLE_DES_3KEY(i int) antlr.TerminalNode + AllEXPIREDATE() []antlr.TerminalNode + EXPIREDATE(i int) antlr.TerminalNode + AllRETAINDAYS() []antlr.TerminalNode + RETAINDAYS(i int) antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + AllNORECOVERY() []antlr.TerminalNode + NORECOVERY(i int) antlr.TerminalNode + AllSTANDBY() []antlr.TerminalNode + STANDBY(i int) antlr.TerminalNode + AllASYMMETRIC() []antlr.TerminalNode + ASYMMETRIC(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + + // IsBackup_logContext differentiates from other interfaces. + IsBackup_logContext() +} + +type Backup_logContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database_name IId_Context + logical_device_name IId_Context + backup_set_name IId_Context + medianame antlr.Token + stats_percent antlr.Token + undo_file_name antlr.Token + encryptor_name IId_Context +} + +func NewEmptyBackup_logContext() *Backup_logContext { + var p = new(Backup_logContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_backup_log + return p +} + +func InitEmptyBackup_logContext(p *Backup_logContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_backup_log +} + +func (*Backup_logContext) IsBackup_logContext() {} + +func NewBackup_logContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_logContext { + var p = new(Backup_logContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_backup_log + + return p +} + +func (s *Backup_logContext) GetParser() antlr.Parser { return s.parser } + +func (s *Backup_logContext) GetMedianame() antlr.Token { return s.medianame } + +func (s *Backup_logContext) GetStats_percent() antlr.Token { return s.stats_percent } + +func (s *Backup_logContext) GetUndo_file_name() antlr.Token { return s.undo_file_name } + +func (s *Backup_logContext) SetMedianame(v antlr.Token) { s.medianame = v } + +func (s *Backup_logContext) SetStats_percent(v antlr.Token) { s.stats_percent = v } + +func (s *Backup_logContext) SetUndo_file_name(v antlr.Token) { s.undo_file_name = v } + +func (s *Backup_logContext) GetDatabase_name() IId_Context { return s.database_name } + +func (s *Backup_logContext) GetLogical_device_name() IId_Context { return s.logical_device_name } + +func (s *Backup_logContext) GetBackup_set_name() IId_Context { return s.backup_set_name } + +func (s *Backup_logContext) GetEncryptor_name() IId_Context { return s.encryptor_name } + +func (s *Backup_logContext) SetDatabase_name(v IId_Context) { s.database_name = v } + +func (s *Backup_logContext) SetLogical_device_name(v IId_Context) { s.logical_device_name = v } + +func (s *Backup_logContext) SetBackup_set_name(v IId_Context) { s.backup_set_name = v } + +func (s *Backup_logContext) SetEncryptor_name(v IId_Context) { s.encryptor_name = v } + +func (s *Backup_logContext) BACKUP() antlr.TerminalNode { + return s.GetToken(TSqlParserBACKUP, 0) +} + +func (s *Backup_logContext) LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserLOG, 0) +} + +func (s *Backup_logContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTO) +} + +func (s *Backup_logContext) TO(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTO, i) +} + +func (s *Backup_logContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Backup_logContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Backup_logContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Backup_logContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Backup_logContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Backup_logContext) AllDISK() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDISK) +} + +func (s *Backup_logContext) DISK(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDISK, i) +} + +func (s *Backup_logContext) AllTAPE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTAPE) +} + +func (s *Backup_logContext) TAPE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTAPE, i) +} + +func (s *Backup_logContext) AllURL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserURL) +} + +func (s *Backup_logContext) URL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserURL, i) +} + +func (s *Backup_logContext) AllMIRROR() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMIRROR) +} + +func (s *Backup_logContext) MIRROR(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMIRROR, i) +} + +func (s *Backup_logContext) AllDIFFERENTIAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDIFFERENTIAL) +} + +func (s *Backup_logContext) DIFFERENTIAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDIFFERENTIAL, i) +} + +func (s *Backup_logContext) AllCOPY_ONLY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOPY_ONLY) +} + +func (s *Backup_logContext) COPY_ONLY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOPY_ONLY, i) +} + +func (s *Backup_logContext) AllDESCRIPTION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDESCRIPTION) +} + +func (s *Backup_logContext) DESCRIPTION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDESCRIPTION, i) +} + +func (s *Backup_logContext) AllNAME() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNAME) +} + +func (s *Backup_logContext) NAME(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, i) +} + +func (s *Backup_logContext) AllCREDENTIAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCREDENTIAL) +} + +func (s *Backup_logContext) CREDENTIAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCREDENTIAL, i) +} + +func (s *Backup_logContext) AllFILE_SNAPSHOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFILE_SNAPSHOT) +} + +func (s *Backup_logContext) FILE_SNAPSHOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFILE_SNAPSHOT, i) +} + +func (s *Backup_logContext) AllMEDIADESCRIPTION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMEDIADESCRIPTION) +} + +func (s *Backup_logContext) MEDIADESCRIPTION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMEDIADESCRIPTION, i) +} + +func (s *Backup_logContext) AllMEDIANAME() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMEDIANAME) +} + +func (s *Backup_logContext) MEDIANAME(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMEDIANAME, i) +} + +func (s *Backup_logContext) AllBLOCKSIZE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBLOCKSIZE) +} + +func (s *Backup_logContext) BLOCKSIZE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBLOCKSIZE, i) +} + +func (s *Backup_logContext) AllBUFFERCOUNT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBUFFERCOUNT) +} + +func (s *Backup_logContext) BUFFERCOUNT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBUFFERCOUNT, i) +} + +func (s *Backup_logContext) AllMAXTRANSFER() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMAXTRANSFER) +} + +func (s *Backup_logContext) MAXTRANSFER(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMAXTRANSFER, i) +} + +func (s *Backup_logContext) AllRESTART() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRESTART) +} + +func (s *Backup_logContext) RESTART(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRESTART, i) +} + +func (s *Backup_logContext) AllSTATS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTATS) +} + +func (s *Backup_logContext) STATS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTATS, i) +} + +func (s *Backup_logContext) AllNO_TRUNCATE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNO_TRUNCATE) +} + +func (s *Backup_logContext) NO_TRUNCATE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNO_TRUNCATE, i) +} + +func (s *Backup_logContext) AllENCRYPTION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserENCRYPTION) +} + +func (s *Backup_logContext) ENCRYPTION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, i) +} + +func (s *Backup_logContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Backup_logContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Backup_logContext) AllALGORITHM() []antlr.TerminalNode { + return s.GetTokens(TSqlParserALGORITHM) +} + +func (s *Backup_logContext) ALGORITHM(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserALGORITHM, i) +} + +func (s *Backup_logContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Backup_logContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Backup_logContext) AllSERVER() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSERVER) +} + +func (s *Backup_logContext) SERVER(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, i) +} + +func (s *Backup_logContext) AllCERTIFICATE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCERTIFICATE) +} + +func (s *Backup_logContext) CERTIFICATE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, i) +} + +func (s *Backup_logContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Backup_logContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Backup_logContext) AllCOMPRESSION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMPRESSION) +} + +func (s *Backup_logContext) COMPRESSION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPRESSION, i) +} + +func (s *Backup_logContext) AllNO_COMPRESSION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNO_COMPRESSION) +} + +func (s *Backup_logContext) NO_COMPRESSION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNO_COMPRESSION, i) +} + +func (s *Backup_logContext) AllNOINIT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOINIT) +} + +func (s *Backup_logContext) NOINIT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOINIT, i) +} + +func (s *Backup_logContext) AllINIT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserINIT) +} + +func (s *Backup_logContext) INIT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserINIT, i) +} + +func (s *Backup_logContext) AllNOSKIP() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOSKIP) +} + +func (s *Backup_logContext) NOSKIP(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOSKIP, i) +} + +func (s *Backup_logContext) AllSKIP_KEYWORD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSKIP_KEYWORD) +} + +func (s *Backup_logContext) SKIP_KEYWORD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSKIP_KEYWORD, i) +} + +func (s *Backup_logContext) AllNOFORMAT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOFORMAT) +} + +func (s *Backup_logContext) NOFORMAT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOFORMAT, i) +} + +func (s *Backup_logContext) AllFORMAT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFORMAT) +} + +func (s *Backup_logContext) FORMAT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFORMAT, i) +} + +func (s *Backup_logContext) AllNO_CHECKSUM() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNO_CHECKSUM) +} + +func (s *Backup_logContext) NO_CHECKSUM(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNO_CHECKSUM, i) +} + +func (s *Backup_logContext) AllCHECKSUM() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCHECKSUM) +} + +func (s *Backup_logContext) CHECKSUM(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKSUM, i) +} + +func (s *Backup_logContext) AllSTOP_ON_ERROR() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTOP_ON_ERROR) +} + +func (s *Backup_logContext) STOP_ON_ERROR(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTOP_ON_ERROR, i) +} + +func (s *Backup_logContext) AllCONTINUE_AFTER_ERROR() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCONTINUE_AFTER_ERROR) +} + +func (s *Backup_logContext) CONTINUE_AFTER_ERROR(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCONTINUE_AFTER_ERROR, i) +} + +func (s *Backup_logContext) AllREWIND() []antlr.TerminalNode { + return s.GetTokens(TSqlParserREWIND) +} + +func (s *Backup_logContext) REWIND(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserREWIND, i) +} + +func (s *Backup_logContext) AllNOREWIND() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOREWIND) +} + +func (s *Backup_logContext) NOREWIND(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOREWIND, i) +} + +func (s *Backup_logContext) AllLOAD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOAD) +} + +func (s *Backup_logContext) LOAD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOAD, i) +} + +func (s *Backup_logContext) AllNOUNLOAD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOUNLOAD) +} + +func (s *Backup_logContext) NOUNLOAD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOUNLOAD, i) +} + +func (s *Backup_logContext) AllAES_128() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAES_128) +} + +func (s *Backup_logContext) AES_128(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAES_128, i) +} + +func (s *Backup_logContext) AllAES_192() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAES_192) +} + +func (s *Backup_logContext) AES_192(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAES_192, i) +} + +func (s *Backup_logContext) AllAES_256() []antlr.TerminalNode { + return s.GetTokens(TSqlParserAES_256) +} + +func (s *Backup_logContext) AES_256(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserAES_256, i) +} + +func (s *Backup_logContext) AllTRIPLE_DES_3KEY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserTRIPLE_DES_3KEY) +} + +func (s *Backup_logContext) TRIPLE_DES_3KEY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserTRIPLE_DES_3KEY, i) +} + +func (s *Backup_logContext) AllEXPIREDATE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEXPIREDATE) +} + +func (s *Backup_logContext) EXPIREDATE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEXPIREDATE, i) +} + +func (s *Backup_logContext) AllRETAINDAYS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRETAINDAYS) +} + +func (s *Backup_logContext) RETAINDAYS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRETAINDAYS, i) +} + +func (s *Backup_logContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Backup_logContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Backup_logContext) AllNORECOVERY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNORECOVERY) +} + +func (s *Backup_logContext) NORECOVERY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNORECOVERY, i) +} + +func (s *Backup_logContext) AllSTANDBY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTANDBY) +} + +func (s *Backup_logContext) STANDBY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTANDBY, i) +} + +func (s *Backup_logContext) AllASYMMETRIC() []antlr.TerminalNode { + return s.GetTokens(TSqlParserASYMMETRIC) +} + +func (s *Backup_logContext) ASYMMETRIC(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, i) +} + +func (s *Backup_logContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserKEY) +} + +func (s *Backup_logContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, i) +} + +func (s *Backup_logContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Backup_logContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Backup_logContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBackup_log(s) + } +} + +func (s *Backup_logContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBackup_log(s) + } +} + +func (s *Backup_logContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBackup_log(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Backup_log() (localctx IBackup_logContext) { + localctx = NewBackup_logContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 742, TSqlParserRULE_backup_log) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9184) + p.Match(TSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9185) + p.Match(TSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(9186) + + var _x = p.Id_() + + localctx.(*Backup_logContext).database_name = _x + } + + p.SetState(9210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1208, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9187) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9192) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(9189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9188) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9191) + + var _x = p.Id_() + + localctx.(*Backup_logContext).logical_device_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9194) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1204, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + { + p.SetState(9196) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(9198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9197) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9200) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISK || _la == TSqlParserTAPE || _la == TSqlParserURL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9201) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(9202) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9203) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9208) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1207, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(9245) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1216, p.GetParserRuleContext()) == 1 { + p.SetState(9222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(9212) + p.Match(TSqlParserMIRROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9213) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9218) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(9215) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9214) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9217) + + var _x = p.Id_() + + localctx.(*Backup_logContext).logical_device_name = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9220) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1210, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9224) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1211, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1216, p.GetParserRuleContext()) == 2 { + p.SetState(9241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(9226) + p.Match(TSqlParserMIRROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9227) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(9229) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9228) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9231) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDISK || _la == TSqlParserTAPE || _la == TSqlParserURL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9232) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9235) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(9233) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9234) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9239) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1214, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9243) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1215, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9420) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1255, p.GetParserRuleContext()) == 1 { + { + p.SetState(9247) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9417) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1254, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(9415) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1253, p.GetParserRuleContext()) { + case 1: + p.SetState(9249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9248) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9251) + p.Match(TSqlParserDIFFERENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(9253) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9252) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9255) + p.Match(TSqlParserCOPY_ONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.SetState(9257) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9256) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9259) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCOMPRESSION || _la == TSqlParserNO_COMPRESSION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 4: + p.SetState(9261) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9260) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9263) + p.Match(TSqlParserDESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9264) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(9265) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9266) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 5: + p.SetState(9270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9269) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9272) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9273) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9274) + + var _x = p.Id_() + + localctx.(*Backup_logContext).backup_set_name = _x + } + + case 6: + p.SetState(9276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9275) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9278) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.SetState(9280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9279) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9282) + p.Match(TSqlParserFILE_SNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.SetState(9284) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9283) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserEXPIREDATE: + { + p.SetState(9286) + p.Match(TSqlParserEXPIREDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9287) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9290) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(9288) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9289) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserRETAINDAYS: + { + p.SetState(9292) + p.Match(TSqlParserRETAINDAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9293) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(9294) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9295) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 9: + p.SetState(9301) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9300) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9303) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserINIT || _la == TSqlParserNOINIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 10: + p.SetState(9305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9304) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9307) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNOSKIP || _la == TSqlParserSKIP_KEYWORD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 11: + p.SetState(9309) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9308) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9311) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFORMAT || _la == TSqlParserNOFORMAT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 12: + p.SetState(9313) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9312) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9315) + p.Match(TSqlParserMEDIADESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9316) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9319) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + { + p.SetState(9317) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9318) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 13: + p.SetState(9322) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9321) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9324) + p.Match(TSqlParserMEDIANAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9325) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(9326) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Backup_logContext).medianame = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.SetState(9328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9327) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9330) + p.Match(TSqlParserBLOCKSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9331) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(9332) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9333) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 15: + p.SetState(9337) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9336) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9339) + p.Match(TSqlParserBUFFERCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9340) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(9341) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9342) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 16: + p.SetState(9346) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9345) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9348) + p.Match(TSqlParserMAXTRANSFER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9349) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9352) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(9350) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9351) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 17: + p.SetState(9355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9354) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9357) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCHECKSUM || _la == TSqlParserNO_CHECKSUM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 18: + p.SetState(9359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9358) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9361) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCONTINUE_AFTER_ERROR || _la == TSqlParserSTOP_ON_ERROR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 19: + p.SetState(9363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9362) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9365) + p.Match(TSqlParserRESTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.SetState(9367) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9366) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9369) + p.Match(TSqlParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9372) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserEQUAL { + { + p.SetState(9370) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9371) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Backup_logContext).stats_percent = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 21: + p.SetState(9375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9374) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9377) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNOREWIND || _la == TSqlParserREWIND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 22: + p.SetState(9379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9378) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9381) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOAD || _la == TSqlParserNOUNLOAD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 23: + p.SetState(9383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9382) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserNORECOVERY: + { + p.SetState(9385) + p.Match(TSqlParserNORECOVERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSTANDBY: + { + p.SetState(9386) + p.Match(TSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9387) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9388) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Backup_logContext).undo_file_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 24: + p.SetState(9392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9391) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9394) + p.Match(TSqlParserNO_TRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 25: + p.SetState(9396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9395) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9398) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9399) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9400) + p.Match(TSqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9401) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9402) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&229376) != 0) || _la == TSqlParserTRIPLE_DES_3KEY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9403) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9404) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9405) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9406) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1252, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9407) + + var _x = p.Id_() + + localctx.(*Backup_logContext).encryptor_name = _x + } + + case 2: + { + p.SetState(9408) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9409) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9410) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9411) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9412) + + var _x = p.Id_() + + localctx.(*Backup_logContext).encryptor_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(9419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1254, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBackup_certificateContext is an interface to support dynamic dispatch. +type IBackup_certificateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCert_file returns the cert_file token. + GetCert_file() antlr.Token + + // GetPrivate_key_file returns the private_key_file token. + GetPrivate_key_file() antlr.Token + + // GetEncryption_password returns the encryption_password token. + GetEncryption_password() antlr.Token + + // GetDecryption_pasword returns the decryption_pasword token. + GetDecryption_pasword() antlr.Token + + // SetCert_file sets the cert_file token. + SetCert_file(antlr.Token) + + // SetPrivate_key_file sets the private_key_file token. + SetPrivate_key_file(antlr.Token) + + // SetEncryption_password sets the encryption_password token. + SetEncryption_password(antlr.Token) + + // SetDecryption_pasword sets the decryption_pasword token. + SetDecryption_pasword(antlr.Token) + + // GetCertname returns the certname rule contexts. + GetCertname() IId_Context + + // SetCertname sets the certname rule contexts. + SetCertname(IId_Context) + + // Getter signatures + BACKUP() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + TO() antlr.TerminalNode + AllFILE() []antlr.TerminalNode + FILE(i int) antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + Id_() IId_Context + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + PRIVATE() antlr.TerminalNode + KEY() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllENCRYPTION() []antlr.TerminalNode + ENCRYPTION(i int) antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + AllPASSWORD() []antlr.TerminalNode + PASSWORD(i int) antlr.TerminalNode + AllDECRYPTION() []antlr.TerminalNode + DECRYPTION(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsBackup_certificateContext differentiates from other interfaces. + IsBackup_certificateContext() +} + +type Backup_certificateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + certname IId_Context + cert_file antlr.Token + private_key_file antlr.Token + encryption_password antlr.Token + decryption_pasword antlr.Token +} + +func NewEmptyBackup_certificateContext() *Backup_certificateContext { + var p = new(Backup_certificateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_backup_certificate + return p +} + +func InitEmptyBackup_certificateContext(p *Backup_certificateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_backup_certificate +} + +func (*Backup_certificateContext) IsBackup_certificateContext() {} + +func NewBackup_certificateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_certificateContext { + var p = new(Backup_certificateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_backup_certificate + + return p +} + +func (s *Backup_certificateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Backup_certificateContext) GetCert_file() antlr.Token { return s.cert_file } + +func (s *Backup_certificateContext) GetPrivate_key_file() antlr.Token { return s.private_key_file } + +func (s *Backup_certificateContext) GetEncryption_password() antlr.Token { + return s.encryption_password +} + +func (s *Backup_certificateContext) GetDecryption_pasword() antlr.Token { return s.decryption_pasword } + +func (s *Backup_certificateContext) SetCert_file(v antlr.Token) { s.cert_file = v } + +func (s *Backup_certificateContext) SetPrivate_key_file(v antlr.Token) { s.private_key_file = v } + +func (s *Backup_certificateContext) SetEncryption_password(v antlr.Token) { s.encryption_password = v } + +func (s *Backup_certificateContext) SetDecryption_pasword(v antlr.Token) { s.decryption_pasword = v } + +func (s *Backup_certificateContext) GetCertname() IId_Context { return s.certname } + +func (s *Backup_certificateContext) SetCertname(v IId_Context) { s.certname = v } + +func (s *Backup_certificateContext) BACKUP() antlr.TerminalNode { + return s.GetToken(TSqlParserBACKUP, 0) +} + +func (s *Backup_certificateContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Backup_certificateContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Backup_certificateContext) AllFILE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFILE) +} + +func (s *Backup_certificateContext) FILE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, i) +} + +func (s *Backup_certificateContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Backup_certificateContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Backup_certificateContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Backup_certificateContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Backup_certificateContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Backup_certificateContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Backup_certificateContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIVATE, 0) +} + +func (s *Backup_certificateContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Backup_certificateContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Backup_certificateContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Backup_certificateContext) AllENCRYPTION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserENCRYPTION) +} + +func (s *Backup_certificateContext) ENCRYPTION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, i) +} + +func (s *Backup_certificateContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBY) +} + +func (s *Backup_certificateContext) BY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBY, i) +} + +func (s *Backup_certificateContext) AllPASSWORD() []antlr.TerminalNode { + return s.GetTokens(TSqlParserPASSWORD) +} + +func (s *Backup_certificateContext) PASSWORD(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, i) +} + +func (s *Backup_certificateContext) AllDECRYPTION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECRYPTION) +} + +func (s *Backup_certificateContext) DECRYPTION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECRYPTION, i) +} + +func (s *Backup_certificateContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Backup_certificateContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Backup_certificateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Backup_certificateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Backup_certificateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBackup_certificate(s) + } +} + +func (s *Backup_certificateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBackup_certificate(s) + } +} + +func (s *Backup_certificateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBackup_certificate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Backup_certificate() (localctx IBackup_certificateContext) { + localctx = NewBackup_certificateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 744, TSqlParserRULE_backup_certificate) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9422) + p.Match(TSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9423) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9424) + + var _x = p.Id_() + + localctx.(*Backup_certificateContext).certname = _x + } + { + p.SetState(9425) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9426) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9427) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9428) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Backup_certificateContext).cert_file = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9460) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1261, p.GetParserRuleContext()) == 1 { + { + p.SetState(9429) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9430) + p.Match(TSqlParserPRIVATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9431) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9432) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9455) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserDECRYPTION || _la == TSqlParserENCRYPTION || _la == TSqlParserFILE || _la == TSqlParserCOMMA { + p.SetState(9455) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1259, p.GetParserRuleContext()) { + case 1: + p.SetState(9434) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9433) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9436) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9437) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9438) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Backup_certificateContext).private_key_file = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(9440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9439) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9442) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9443) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9444) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9445) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9446) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Backup_certificateContext).encryption_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.SetState(9448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9447) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9450) + p.Match(TSqlParserDECRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9451) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9452) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9453) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9454) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Backup_certificateContext).decryption_pasword = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(9457) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9459) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBackup_master_keyContext is an interface to support dynamic dispatch. +type IBackup_master_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMaster_key_backup_file returns the master_key_backup_file token. + GetMaster_key_backup_file() antlr.Token + + // GetEncryption_password returns the encryption_password token. + GetEncryption_password() antlr.Token + + // SetMaster_key_backup_file sets the master_key_backup_file token. + SetMaster_key_backup_file(antlr.Token) + + // SetEncryption_password sets the encryption_password token. + SetEncryption_password(antlr.Token) + + // Getter signatures + BACKUP() antlr.TerminalNode + MASTER() antlr.TerminalNode + KEY() antlr.TerminalNode + TO() antlr.TerminalNode + FILE() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + BY() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + + // IsBackup_master_keyContext differentiates from other interfaces. + IsBackup_master_keyContext() +} + +type Backup_master_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + master_key_backup_file antlr.Token + encryption_password antlr.Token +} + +func NewEmptyBackup_master_keyContext() *Backup_master_keyContext { + var p = new(Backup_master_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_backup_master_key + return p +} + +func InitEmptyBackup_master_keyContext(p *Backup_master_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_backup_master_key +} + +func (*Backup_master_keyContext) IsBackup_master_keyContext() {} + +func NewBackup_master_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_master_keyContext { + var p = new(Backup_master_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_backup_master_key + + return p +} + +func (s *Backup_master_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Backup_master_keyContext) GetMaster_key_backup_file() antlr.Token { + return s.master_key_backup_file +} + +func (s *Backup_master_keyContext) GetEncryption_password() antlr.Token { return s.encryption_password } + +func (s *Backup_master_keyContext) SetMaster_key_backup_file(v antlr.Token) { + s.master_key_backup_file = v +} + +func (s *Backup_master_keyContext) SetEncryption_password(v antlr.Token) { s.encryption_password = v } + +func (s *Backup_master_keyContext) BACKUP() antlr.TerminalNode { + return s.GetToken(TSqlParserBACKUP, 0) +} + +func (s *Backup_master_keyContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *Backup_master_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Backup_master_keyContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Backup_master_keyContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Backup_master_keyContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Backup_master_keyContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Backup_master_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Backup_master_keyContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Backup_master_keyContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Backup_master_keyContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Backup_master_keyContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Backup_master_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Backup_master_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Backup_master_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBackup_master_key(s) + } +} + +func (s *Backup_master_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBackup_master_key(s) + } +} + +func (s *Backup_master_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBackup_master_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Backup_master_key() (localctx IBackup_master_keyContext) { + localctx = NewBackup_master_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 746, TSqlParserRULE_backup_master_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9462) + p.Match(TSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9463) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9464) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9465) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9466) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9467) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9468) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Backup_master_keyContext).master_key_backup_file = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9469) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9470) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9471) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9472) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9473) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Backup_master_keyContext).encryption_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBackup_service_master_keyContext is an interface to support dynamic dispatch. +type IBackup_service_master_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetService_master_key_backup_file returns the service_master_key_backup_file token. + GetService_master_key_backup_file() antlr.Token + + // GetEncryption_password returns the encryption_password token. + GetEncryption_password() antlr.Token + + // SetService_master_key_backup_file sets the service_master_key_backup_file token. + SetService_master_key_backup_file(antlr.Token) + + // SetEncryption_password sets the encryption_password token. + SetEncryption_password(antlr.Token) + + // Getter signatures + BACKUP() antlr.TerminalNode + SERVICE() antlr.TerminalNode + MASTER() antlr.TerminalNode + KEY() antlr.TerminalNode + TO() antlr.TerminalNode + FILE() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + BY() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + + // IsBackup_service_master_keyContext differentiates from other interfaces. + IsBackup_service_master_keyContext() +} + +type Backup_service_master_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + service_master_key_backup_file antlr.Token + encryption_password antlr.Token +} + +func NewEmptyBackup_service_master_keyContext() *Backup_service_master_keyContext { + var p = new(Backup_service_master_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_backup_service_master_key + return p +} + +func InitEmptyBackup_service_master_keyContext(p *Backup_service_master_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_backup_service_master_key +} + +func (*Backup_service_master_keyContext) IsBackup_service_master_keyContext() {} + +func NewBackup_service_master_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_service_master_keyContext { + var p = new(Backup_service_master_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_backup_service_master_key + + return p +} + +func (s *Backup_service_master_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Backup_service_master_keyContext) GetService_master_key_backup_file() antlr.Token { + return s.service_master_key_backup_file +} + +func (s *Backup_service_master_keyContext) GetEncryption_password() antlr.Token { + return s.encryption_password +} + +func (s *Backup_service_master_keyContext) SetService_master_key_backup_file(v antlr.Token) { + s.service_master_key_backup_file = v +} + +func (s *Backup_service_master_keyContext) SetEncryption_password(v antlr.Token) { + s.encryption_password = v +} + +func (s *Backup_service_master_keyContext) BACKUP() antlr.TerminalNode { + return s.GetToken(TSqlParserBACKUP, 0) +} + +func (s *Backup_service_master_keyContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *Backup_service_master_keyContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *Backup_service_master_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Backup_service_master_keyContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Backup_service_master_keyContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Backup_service_master_keyContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Backup_service_master_keyContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Backup_service_master_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Backup_service_master_keyContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Backup_service_master_keyContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Backup_service_master_keyContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Backup_service_master_keyContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Backup_service_master_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Backup_service_master_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Backup_service_master_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBackup_service_master_key(s) + } +} + +func (s *Backup_service_master_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBackup_service_master_key(s) + } +} + +func (s *Backup_service_master_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBackup_service_master_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Backup_service_master_key() (localctx IBackup_service_master_keyContext) { + localctx = NewBackup_service_master_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 748, TSqlParserRULE_backup_service_master_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9475) + p.Match(TSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9476) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9477) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9478) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9479) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9480) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9481) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9482) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Backup_service_master_keyContext).service_master_key_backup_file = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9483) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9484) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9485) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9486) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9487) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Backup_service_master_keyContext).encryption_password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKill_statementContext is an interface to support dynamic dispatch. +type IKill_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KILL() antlr.TerminalNode + Kill_process() IKill_processContext + Kill_query_notification() IKill_query_notificationContext + Kill_stats_job() IKill_stats_jobContext + + // IsKill_statementContext differentiates from other interfaces. + IsKill_statementContext() +} + +type Kill_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKill_statementContext() *Kill_statementContext { + var p = new(Kill_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_kill_statement + return p +} + +func InitEmptyKill_statementContext(p *Kill_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_kill_statement +} + +func (*Kill_statementContext) IsKill_statementContext() {} + +func NewKill_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Kill_statementContext { + var p = new(Kill_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_kill_statement + + return p +} + +func (s *Kill_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Kill_statementContext) KILL() antlr.TerminalNode { + return s.GetToken(TSqlParserKILL, 0) +} + +func (s *Kill_statementContext) Kill_process() IKill_processContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKill_processContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKill_processContext) +} + +func (s *Kill_statementContext) Kill_query_notification() IKill_query_notificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKill_query_notificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKill_query_notificationContext) +} + +func (s *Kill_statementContext) Kill_stats_job() IKill_stats_jobContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKill_stats_jobContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKill_stats_jobContext) +} + +func (s *Kill_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Kill_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Kill_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterKill_statement(s) + } +} + +func (s *Kill_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitKill_statement(s) + } +} + +func (s *Kill_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitKill_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Kill_statement() (localctx IKill_statementContext) { + localctx = NewKill_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 750, TSqlParserRULE_kill_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9489) + p.Match(TSqlParserKILL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserUOW, TSqlParserDECIMAL, TSqlParserSTRING: + { + p.SetState(9490) + p.Kill_process() + } + + case TSqlParserQUERY: + { + p.SetState(9491) + p.Kill_query_notification() + } + + case TSqlParserSTATS: + { + p.SetState(9492) + p.Kill_stats_job() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKill_processContext is an interface to support dynamic dispatch. +type IKill_processContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSession_id returns the session_id token. + GetSession_id() antlr.Token + + // SetSession_id sets the session_id token. + SetSession_id(antlr.Token) + + // Getter signatures + UOW() antlr.TerminalNode + WITH() antlr.TerminalNode + STATUSONLY() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsKill_processContext differentiates from other interfaces. + IsKill_processContext() +} + +type Kill_processContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + session_id antlr.Token +} + +func NewEmptyKill_processContext() *Kill_processContext { + var p = new(Kill_processContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_kill_process + return p +} + +func InitEmptyKill_processContext(p *Kill_processContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_kill_process +} + +func (*Kill_processContext) IsKill_processContext() {} + +func NewKill_processContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Kill_processContext { + var p = new(Kill_processContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_kill_process + + return p +} + +func (s *Kill_processContext) GetParser() antlr.Parser { return s.parser } + +func (s *Kill_processContext) GetSession_id() antlr.Token { return s.session_id } + +func (s *Kill_processContext) SetSession_id(v antlr.Token) { s.session_id = v } + +func (s *Kill_processContext) UOW() antlr.TerminalNode { + return s.GetToken(TSqlParserUOW, 0) +} + +func (s *Kill_processContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Kill_processContext) STATUSONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATUSONLY, 0) +} + +func (s *Kill_processContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Kill_processContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Kill_processContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Kill_processContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Kill_processContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterKill_process(s) + } +} + +func (s *Kill_processContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitKill_process(s) + } +} + +func (s *Kill_processContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitKill_process(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Kill_process() (localctx IKill_processContext) { + localctx = NewKill_processContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 752, TSqlParserRULE_kill_process) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9497) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL, TSqlParserSTRING: + { + p.SetState(9495) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Kill_processContext).session_id = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDECIMAL || _la == TSqlParserSTRING) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Kill_processContext).session_id = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserUOW: + { + p.SetState(9496) + p.Match(TSqlParserUOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9501) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1264, p.GetParserRuleContext()) == 1 { + { + p.SetState(9499) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9500) + p.Match(TSqlParserSTATUSONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKill_query_notificationContext is an interface to support dynamic dispatch. +type IKill_query_notificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSubscription_id returns the subscription_id token. + GetSubscription_id() antlr.Token + + // SetSubscription_id sets the subscription_id token. + SetSubscription_id(antlr.Token) + + // Getter signatures + QUERY() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + SUBSCRIPTION() antlr.TerminalNode + ALL() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + + // IsKill_query_notificationContext differentiates from other interfaces. + IsKill_query_notificationContext() +} + +type Kill_query_notificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + subscription_id antlr.Token +} + +func NewEmptyKill_query_notificationContext() *Kill_query_notificationContext { + var p = new(Kill_query_notificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_kill_query_notification + return p +} + +func InitEmptyKill_query_notificationContext(p *Kill_query_notificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_kill_query_notification +} + +func (*Kill_query_notificationContext) IsKill_query_notificationContext() {} + +func NewKill_query_notificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Kill_query_notificationContext { + var p = new(Kill_query_notificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_kill_query_notification + + return p +} + +func (s *Kill_query_notificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Kill_query_notificationContext) GetSubscription_id() antlr.Token { return s.subscription_id } + +func (s *Kill_query_notificationContext) SetSubscription_id(v antlr.Token) { s.subscription_id = v } + +func (s *Kill_query_notificationContext) QUERY() antlr.TerminalNode { + return s.GetToken(TSqlParserQUERY, 0) +} + +func (s *Kill_query_notificationContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserNOTIFICATION, 0) +} + +func (s *Kill_query_notificationContext) SUBSCRIPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserSUBSCRIPTION, 0) +} + +func (s *Kill_query_notificationContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Kill_query_notificationContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Kill_query_notificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Kill_query_notificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Kill_query_notificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterKill_query_notification(s) + } +} + +func (s *Kill_query_notificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitKill_query_notification(s) + } +} + +func (s *Kill_query_notificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitKill_query_notification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Kill_query_notification() (localctx IKill_query_notificationContext) { + localctx = NewKill_query_notificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 754, TSqlParserRULE_kill_query_notification) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9503) + p.Match(TSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9504) + p.Match(TSqlParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9505) + p.Match(TSqlParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9508) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALL: + { + p.SetState(9506) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL: + { + p.SetState(9507) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Kill_query_notificationContext).subscription_id = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKill_stats_jobContext is an interface to support dynamic dispatch. +type IKill_stats_jobContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetJob_id returns the job_id token. + GetJob_id() antlr.Token + + // SetJob_id sets the job_id token. + SetJob_id(antlr.Token) + + // Getter signatures + STATS() antlr.TerminalNode + JOB() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + + // IsKill_stats_jobContext differentiates from other interfaces. + IsKill_stats_jobContext() +} + +type Kill_stats_jobContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + job_id antlr.Token +} + +func NewEmptyKill_stats_jobContext() *Kill_stats_jobContext { + var p = new(Kill_stats_jobContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_kill_stats_job + return p +} + +func InitEmptyKill_stats_jobContext(p *Kill_stats_jobContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_kill_stats_job +} + +func (*Kill_stats_jobContext) IsKill_stats_jobContext() {} + +func NewKill_stats_jobContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Kill_stats_jobContext { + var p = new(Kill_stats_jobContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_kill_stats_job + + return p +} + +func (s *Kill_stats_jobContext) GetParser() antlr.Parser { return s.parser } + +func (s *Kill_stats_jobContext) GetJob_id() antlr.Token { return s.job_id } + +func (s *Kill_stats_jobContext) SetJob_id(v antlr.Token) { s.job_id = v } + +func (s *Kill_stats_jobContext) STATS() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATS, 0) +} + +func (s *Kill_stats_jobContext) JOB() antlr.TerminalNode { + return s.GetToken(TSqlParserJOB, 0) +} + +func (s *Kill_stats_jobContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Kill_stats_jobContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Kill_stats_jobContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Kill_stats_jobContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterKill_stats_job(s) + } +} + +func (s *Kill_stats_jobContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitKill_stats_job(s) + } +} + +func (s *Kill_stats_jobContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitKill_stats_job(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Kill_stats_job() (localctx IKill_stats_jobContext) { + localctx = NewKill_stats_jobContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 756, TSqlParserRULE_kill_stats_job) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9510) + p.Match(TSqlParserSTATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9511) + p.Match(TSqlParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9512) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Kill_stats_jobContext).job_id = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecute_statementContext is an interface to support dynamic dispatch. +type IExecute_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXECUTE() antlr.TerminalNode + Execute_body() IExecute_bodyContext + SEMI() antlr.TerminalNode + + // IsExecute_statementContext differentiates from other interfaces. + IsExecute_statementContext() +} + +type Execute_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecute_statementContext() *Execute_statementContext { + var p = new(Execute_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_statement + return p +} + +func InitEmptyExecute_statementContext(p *Execute_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_statement +} + +func (*Execute_statementContext) IsExecute_statementContext() {} + +func NewExecute_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_statementContext { + var p = new(Execute_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_execute_statement + + return p +} + +func (s *Execute_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_statementContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXECUTE, 0) +} + +func (s *Execute_statementContext) Execute_body() IExecute_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_bodyContext) +} + +func (s *Execute_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Execute_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExecute_statement(s) + } +} + +func (s *Execute_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExecute_statement(s) + } +} + +func (s *Execute_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExecute_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Execute_statement() (localctx IExecute_statementContext) { + localctx = NewExecute_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 758, TSqlParserRULE_execute_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9514) + p.Match(TSqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9515) + p.Execute_body() + } + p.SetState(9517) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1266, p.GetParserRuleContext()) == 1 { + { + p.SetState(9516) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecute_body_batchContext is an interface to support dynamic dispatch. +type IExecute_body_batchContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_proc_name_server_database_schema() IFunc_proc_name_server_database_schemaContext + AllExecute_statement_arg() []IExecute_statement_argContext + Execute_statement_arg(i int) IExecute_statement_argContext + SEMI() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExecute_body_batchContext differentiates from other interfaces. + IsExecute_body_batchContext() +} + +type Execute_body_batchContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecute_body_batchContext() *Execute_body_batchContext { + var p = new(Execute_body_batchContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_body_batch + return p +} + +func InitEmptyExecute_body_batchContext(p *Execute_body_batchContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_body_batch +} + +func (*Execute_body_batchContext) IsExecute_body_batchContext() {} + +func NewExecute_body_batchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_body_batchContext { + var p = new(Execute_body_batchContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_execute_body_batch + + return p +} + +func (s *Execute_body_batchContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_body_batchContext) Func_proc_name_server_database_schema() IFunc_proc_name_server_database_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_proc_name_server_database_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_proc_name_server_database_schemaContext) +} + +func (s *Execute_body_batchContext) AllExecute_statement_arg() []IExecute_statement_argContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExecute_statement_argContext); ok { + len++ + } + } + + tst := make([]IExecute_statement_argContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExecute_statement_argContext); ok { + tst[i] = t.(IExecute_statement_argContext) + i++ + } + } + + return tst +} + +func (s *Execute_body_batchContext) Execute_statement_arg(i int) IExecute_statement_argContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_statement_argContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExecute_statement_argContext) +} + +func (s *Execute_body_batchContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Execute_body_batchContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Execute_body_batchContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Execute_body_batchContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_body_batchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_body_batchContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExecute_body_batch(s) + } +} + +func (s *Execute_body_batchContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExecute_body_batch(s) + } +} + +func (s *Execute_body_batchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExecute_body_batch(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Execute_body_batch() (localctx IExecute_body_batchContext) { + localctx = NewExecute_body_batchContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 760, TSqlParserRULE_execute_body_batch) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9519) + p.Func_proc_name_server_database_schema() + } + p.SetState(9528) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1268, p.GetParserRuleContext()) == 1 { + { + p.SetState(9520) + p.Execute_statement_arg() + } + p.SetState(9525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(9521) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9522) + p.Execute_statement_arg() + } + + p.SetState(9527) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9531) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1269, p.GetParserRuleContext()) == 1 { + { + p.SetState(9530) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecute_bodyContext is an interface to support dynamic dispatch. +type IExecute_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetReturn_status returns the return_status token. + GetReturn_status() antlr.Token + + // SetReturn_status sets the return_status token. + SetReturn_status(antlr.Token) + + // GetLinkedServer returns the linkedServer rule contexts. + GetLinkedServer() IId_Context + + // SetLinkedServer sets the linkedServer rule contexts. + SetLinkedServer(IId_Context) + + // Getter signatures + Func_proc_name_server_database_schema() IFunc_proc_name_server_database_schemaContext + AllExecute_var_string() []IExecute_var_stringContext + Execute_var_string(i int) IExecute_var_stringContext + EQUAL() antlr.TerminalNode + Execute_statement_arg() IExecute_statement_argContext + LOCAL_ID() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AS() antlr.TerminalNode + STRING() antlr.TerminalNode + AT_KEYWORD() antlr.TerminalNode + LOGIN() antlr.TerminalNode + USER() antlr.TerminalNode + Id_() IId_Context + CALLER() antlr.TerminalNode + + // IsExecute_bodyContext differentiates from other interfaces. + IsExecute_bodyContext() +} + +type Execute_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + return_status antlr.Token + linkedServer IId_Context +} + +func NewEmptyExecute_bodyContext() *Execute_bodyContext { + var p = new(Execute_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_body + return p +} + +func InitEmptyExecute_bodyContext(p *Execute_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_body +} + +func (*Execute_bodyContext) IsExecute_bodyContext() {} + +func NewExecute_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_bodyContext { + var p = new(Execute_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_execute_body + + return p +} + +func (s *Execute_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_bodyContext) GetReturn_status() antlr.Token { return s.return_status } + +func (s *Execute_bodyContext) SetReturn_status(v antlr.Token) { s.return_status = v } + +func (s *Execute_bodyContext) GetLinkedServer() IId_Context { return s.linkedServer } + +func (s *Execute_bodyContext) SetLinkedServer(v IId_Context) { s.linkedServer = v } + +func (s *Execute_bodyContext) Func_proc_name_server_database_schema() IFunc_proc_name_server_database_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_proc_name_server_database_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_proc_name_server_database_schemaContext) +} + +func (s *Execute_bodyContext) AllExecute_var_string() []IExecute_var_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExecute_var_stringContext); ok { + len++ + } + } + + tst := make([]IExecute_var_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExecute_var_stringContext); ok { + tst[i] = t.(IExecute_var_stringContext) + i++ + } + } + + return tst +} + +func (s *Execute_bodyContext) Execute_var_string(i int) IExecute_var_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_var_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExecute_var_stringContext) +} + +func (s *Execute_bodyContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Execute_bodyContext) Execute_statement_arg() IExecute_statement_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_statement_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_statement_argContext) +} + +func (s *Execute_bodyContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Execute_bodyContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Execute_bodyContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Execute_bodyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Execute_bodyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Execute_bodyContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Execute_bodyContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Execute_bodyContext) AT_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserAT_KEYWORD, 0) +} + +func (s *Execute_bodyContext) LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, 0) +} + +func (s *Execute_bodyContext) USER() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER, 0) +} + +func (s *Execute_bodyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Execute_bodyContext) CALLER() antlr.TerminalNode { + return s.GetToken(TSqlParserCALLER, 0) +} + +func (s *Execute_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExecute_body(s) + } +} + +func (s *Execute_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExecute_body(s) + } +} + +func (s *Execute_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExecute_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Execute_body() (localctx IExecute_bodyContext) { + localctx = NewExecute_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 762, TSqlParserRULE_execute_body) + var _la int + + p.SetState(9571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserLOCAL_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserSTRING, TSqlParserDOT: + p.EnterOuterAlt(localctx, 1) + p.SetState(9535) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1270, p.GetParserRuleContext()) == 1 { + { + p.SetState(9533) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*Execute_bodyContext).return_status = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9534) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserDOT: + { + p.SetState(9537) + p.Func_proc_name_server_database_schema() + } + + case TSqlParserLOCAL_ID, TSqlParserSTRING: + { + p.SetState(9538) + p.Execute_var_string() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9542) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1272, p.GetParserRuleContext()) == 1 { + { + p.SetState(9541) + p.Execute_statement_arg() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserLR_BRACKET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9544) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9545) + p.Execute_var_string() + } + p.SetState(9550) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(9546) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9547) + p.Execute_var_string() + } + + p.SetState(9552) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9553) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(9554) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9555) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOGIN || _la == TSqlParserUSER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9556) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9557) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9562) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1275, p.GetParserRuleContext()) == 1 { + { + p.SetState(9560) + p.Match(TSqlParserAT_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9561) + + var _x = p.Id_() + + localctx.(*Execute_bodyContext).linkedServer = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserAS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9564) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9569) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLOGIN, TSqlParserUSER: + { + p.SetState(9565) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOGIN || _la == TSqlParserUSER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9566) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9567) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCALLER: + { + p.SetState(9568) + p.Match(TSqlParserCALLER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecute_statement_argContext is an interface to support dynamic dispatch. +type IExecute_statement_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Execute_statement_arg_unnamed() IExecute_statement_arg_unnamedContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllExecute_statement_arg() []IExecute_statement_argContext + Execute_statement_arg(i int) IExecute_statement_argContext + AllExecute_statement_arg_named() []IExecute_statement_arg_namedContext + Execute_statement_arg_named(i int) IExecute_statement_arg_namedContext + + // IsExecute_statement_argContext differentiates from other interfaces. + IsExecute_statement_argContext() +} + +type Execute_statement_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecute_statement_argContext() *Execute_statement_argContext { + var p = new(Execute_statement_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_statement_arg + return p +} + +func InitEmptyExecute_statement_argContext(p *Execute_statement_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_statement_arg +} + +func (*Execute_statement_argContext) IsExecute_statement_argContext() {} + +func NewExecute_statement_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_statement_argContext { + var p = new(Execute_statement_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_execute_statement_arg + + return p +} + +func (s *Execute_statement_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_statement_argContext) Execute_statement_arg_unnamed() IExecute_statement_arg_unnamedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_statement_arg_unnamedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_statement_arg_unnamedContext) +} + +func (s *Execute_statement_argContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Execute_statement_argContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Execute_statement_argContext) AllExecute_statement_arg() []IExecute_statement_argContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExecute_statement_argContext); ok { + len++ + } + } + + tst := make([]IExecute_statement_argContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExecute_statement_argContext); ok { + tst[i] = t.(IExecute_statement_argContext) + i++ + } + } + + return tst +} + +func (s *Execute_statement_argContext) Execute_statement_arg(i int) IExecute_statement_argContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_statement_argContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExecute_statement_argContext) +} + +func (s *Execute_statement_argContext) AllExecute_statement_arg_named() []IExecute_statement_arg_namedContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExecute_statement_arg_namedContext); ok { + len++ + } + } + + tst := make([]IExecute_statement_arg_namedContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExecute_statement_arg_namedContext); ok { + tst[i] = t.(IExecute_statement_arg_namedContext) + i++ + } + } + + return tst +} + +func (s *Execute_statement_argContext) Execute_statement_arg_named(i int) IExecute_statement_arg_namedContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_statement_arg_namedContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExecute_statement_arg_namedContext) +} + +func (s *Execute_statement_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_statement_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_statement_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExecute_statement_arg(s) + } +} + +func (s *Execute_statement_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExecute_statement_arg(s) + } +} + +func (s *Execute_statement_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExecute_statement_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Execute_statement_arg() (localctx IExecute_statement_argContext) { + localctx = NewExecute_statement_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 764, TSqlParserRULE_execute_statement_arg) + var _alt int + + p.SetState(9589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1280, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9573) + p.Execute_statement_arg_unnamed() + } + p.SetState(9578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1278, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(9574) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9575) + p.Execute_statement_arg() + } + + } + p.SetState(9580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1278, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9581) + p.Execute_statement_arg_named() + } + p.SetState(9586) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1279, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(9582) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9583) + p.Execute_statement_arg_named() + } + + } + p.SetState(9588) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1279, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecute_statement_arg_namedContext is an interface to support dynamic dispatch. +type IExecute_statement_arg_namedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // GetValue returns the value rule contexts. + GetValue() IExecute_parameterContext + + // SetValue sets the value rule contexts. + SetValue(IExecute_parameterContext) + + // Getter signatures + EQUAL() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + Execute_parameter() IExecute_parameterContext + + // IsExecute_statement_arg_namedContext differentiates from other interfaces. + IsExecute_statement_arg_namedContext() +} + +type Execute_statement_arg_namedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + value IExecute_parameterContext +} + +func NewEmptyExecute_statement_arg_namedContext() *Execute_statement_arg_namedContext { + var p = new(Execute_statement_arg_namedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_statement_arg_named + return p +} + +func InitEmptyExecute_statement_arg_namedContext(p *Execute_statement_arg_namedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_statement_arg_named +} + +func (*Execute_statement_arg_namedContext) IsExecute_statement_arg_namedContext() {} + +func NewExecute_statement_arg_namedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_statement_arg_namedContext { + var p = new(Execute_statement_arg_namedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_execute_statement_arg_named + + return p +} + +func (s *Execute_statement_arg_namedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_statement_arg_namedContext) GetName() antlr.Token { return s.name } + +func (s *Execute_statement_arg_namedContext) SetName(v antlr.Token) { s.name = v } + +func (s *Execute_statement_arg_namedContext) GetValue() IExecute_parameterContext { return s.value } + +func (s *Execute_statement_arg_namedContext) SetValue(v IExecute_parameterContext) { s.value = v } + +func (s *Execute_statement_arg_namedContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Execute_statement_arg_namedContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Execute_statement_arg_namedContext) Execute_parameter() IExecute_parameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_parameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_parameterContext) +} + +func (s *Execute_statement_arg_namedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_statement_arg_namedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_statement_arg_namedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExecute_statement_arg_named(s) + } +} + +func (s *Execute_statement_arg_namedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExecute_statement_arg_named(s) + } +} + +func (s *Execute_statement_arg_namedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExecute_statement_arg_named(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Execute_statement_arg_named() (localctx IExecute_statement_arg_namedContext) { + localctx = NewExecute_statement_arg_namedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 766, TSqlParserRULE_execute_statement_arg_named) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9591) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*Execute_statement_arg_namedContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9592) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9593) + + var _x = p.Execute_parameter() + + localctx.(*Execute_statement_arg_namedContext).value = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecute_statement_arg_unnamedContext is an interface to support dynamic dispatch. +type IExecute_statement_arg_unnamedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetValue returns the value rule contexts. + GetValue() IExecute_parameterContext + + // SetValue sets the value rule contexts. + SetValue(IExecute_parameterContext) + + // Getter signatures + Execute_parameter() IExecute_parameterContext + + // IsExecute_statement_arg_unnamedContext differentiates from other interfaces. + IsExecute_statement_arg_unnamedContext() +} + +type Execute_statement_arg_unnamedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + value IExecute_parameterContext +} + +func NewEmptyExecute_statement_arg_unnamedContext() *Execute_statement_arg_unnamedContext { + var p = new(Execute_statement_arg_unnamedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_statement_arg_unnamed + return p +} + +func InitEmptyExecute_statement_arg_unnamedContext(p *Execute_statement_arg_unnamedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_statement_arg_unnamed +} + +func (*Execute_statement_arg_unnamedContext) IsExecute_statement_arg_unnamedContext() {} + +func NewExecute_statement_arg_unnamedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_statement_arg_unnamedContext { + var p = new(Execute_statement_arg_unnamedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_execute_statement_arg_unnamed + + return p +} + +func (s *Execute_statement_arg_unnamedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_statement_arg_unnamedContext) GetValue() IExecute_parameterContext { return s.value } + +func (s *Execute_statement_arg_unnamedContext) SetValue(v IExecute_parameterContext) { s.value = v } + +func (s *Execute_statement_arg_unnamedContext) Execute_parameter() IExecute_parameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_parameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_parameterContext) +} + +func (s *Execute_statement_arg_unnamedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_statement_arg_unnamedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_statement_arg_unnamedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExecute_statement_arg_unnamed(s) + } +} + +func (s *Execute_statement_arg_unnamedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExecute_statement_arg_unnamed(s) + } +} + +func (s *Execute_statement_arg_unnamedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExecute_statement_arg_unnamed(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Execute_statement_arg_unnamed() (localctx IExecute_statement_arg_unnamedContext) { + localctx = NewExecute_statement_arg_unnamedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 768, TSqlParserRULE_execute_statement_arg_unnamed) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9595) + + var _x = p.Execute_parameter() + + localctx.(*Execute_statement_arg_unnamedContext).value = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecute_parameterContext is an interface to support dynamic dispatch. +type IExecute_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Constant() IConstantContext + LOCAL_ID() antlr.TerminalNode + Id_() IId_Context + DEFAULT() antlr.TerminalNode + NULL_() antlr.TerminalNode + OUTPUT() antlr.TerminalNode + OUT() antlr.TerminalNode + + // IsExecute_parameterContext differentiates from other interfaces. + IsExecute_parameterContext() +} + +type Execute_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecute_parameterContext() *Execute_parameterContext { + var p = new(Execute_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_parameter + return p +} + +func InitEmptyExecute_parameterContext(p *Execute_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_parameter +} + +func (*Execute_parameterContext) IsExecute_parameterContext() {} + +func NewExecute_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_parameterContext { + var p = new(Execute_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_execute_parameter + + return p +} + +func (s *Execute_parameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_parameterContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *Execute_parameterContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Execute_parameterContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Execute_parameterContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Execute_parameterContext) NULL_() antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_, 0) +} + +func (s *Execute_parameterContext) OUTPUT() antlr.TerminalNode { + return s.GetToken(TSqlParserOUTPUT, 0) +} + +func (s *Execute_parameterContext) OUT() antlr.TerminalNode { + return s.GetToken(TSqlParserOUT, 0) +} + +func (s *Execute_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExecute_parameter(s) + } +} + +func (s *Execute_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExecute_parameter(s) + } +} + +func (s *Execute_parameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExecute_parameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Execute_parameter() (localctx IExecute_parameterContext) { + localctx = NewExecute_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 770, TSqlParserRULE_execute_parameter) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL, TSqlParserSTRING, TSqlParserBINARY, TSqlParserFLOAT, TSqlParserREAL, TSqlParserDOLLAR, TSqlParserMINUS, TSqlParserPLACEHOLDER: + { + p.SetState(9597) + p.Constant() + } + + case TSqlParserLOCAL_ID: + { + p.SetState(9598) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9600) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1281, p.GetParserRuleContext()) == 1 { + { + p.SetState(9599) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOUT || _la == TSqlParserOUTPUT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(9602) + p.Id_() + } + + case TSqlParserDEFAULT: + { + p.SetState(9603) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNULL_: + { + p.SetState(9604) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecute_var_stringContext is an interface to support dynamic dispatch. +type IExecute_var_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLOCAL_ID() []antlr.TerminalNode + LOCAL_ID(i int) antlr.TerminalNode + AllPLUS() []antlr.TerminalNode + PLUS(i int) antlr.TerminalNode + OUTPUT() antlr.TerminalNode + OUT() antlr.TerminalNode + Execute_var_string() IExecute_var_stringContext + STRING() antlr.TerminalNode + + // IsExecute_var_stringContext differentiates from other interfaces. + IsExecute_var_stringContext() +} + +type Execute_var_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecute_var_stringContext() *Execute_var_stringContext { + var p = new(Execute_var_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_var_string + return p +} + +func InitEmptyExecute_var_stringContext(p *Execute_var_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_var_string +} + +func (*Execute_var_stringContext) IsExecute_var_stringContext() {} + +func NewExecute_var_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_var_stringContext { + var p = new(Execute_var_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_execute_var_string + + return p +} + +func (s *Execute_var_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_var_stringContext) AllLOCAL_ID() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOCAL_ID) +} + +func (s *Execute_var_stringContext) LOCAL_ID(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, i) +} + +func (s *Execute_var_stringContext) AllPLUS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserPLUS) +} + +func (s *Execute_var_stringContext) PLUS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserPLUS, i) +} + +func (s *Execute_var_stringContext) OUTPUT() antlr.TerminalNode { + return s.GetToken(TSqlParserOUTPUT, 0) +} + +func (s *Execute_var_stringContext) OUT() antlr.TerminalNode { + return s.GetToken(TSqlParserOUT, 0) +} + +func (s *Execute_var_stringContext) Execute_var_string() IExecute_var_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_var_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_var_stringContext) +} + +func (s *Execute_var_stringContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Execute_var_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_var_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_var_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExecute_var_string(s) + } +} + +func (s *Execute_var_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExecute_var_string(s) + } +} + +func (s *Execute_var_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExecute_var_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Execute_var_string() (localctx IExecute_var_stringContext) { + localctx = NewExecute_var_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 772, TSqlParserRULE_execute_var_string) + var _la int + + p.SetState(9628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLOCAL_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9607) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9609) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1283, p.GetParserRuleContext()) == 1 { + { + p.SetState(9608) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOUT || _la == TSqlParserOUTPUT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9617) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPLUS { + { + p.SetState(9611) + p.Match(TSqlParserPLUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9612) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPLUS { + { + p.SetState(9613) + p.Match(TSqlParserPLUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9614) + p.Execute_var_string() + } + + } + + } + + case TSqlParserSTRING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9619) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9626) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPLUS { + { + p.SetState(9620) + p.Match(TSqlParserPLUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9621) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9624) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPLUS { + { + p.SetState(9622) + p.Match(TSqlParserPLUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9623) + p.Execute_var_string() + } + + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISecurity_statementContext is an interface to support dynamic dispatch. +type ISecurity_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOn_id returns the on_id rule contexts. + GetOn_id() ITable_nameContext + + // Get_principal_id returns the _principal_id rule contexts. + Get_principal_id() IPrincipal_idContext + + // GetAs_principal returns the as_principal rule contexts. + GetAs_principal() IPrincipal_idContext + + // SetOn_id sets the on_id rule contexts. + SetOn_id(ITable_nameContext) + + // Set_principal_id sets the _principal_id rule contexts. + Set_principal_id(IPrincipal_idContext) + + // SetAs_principal sets the as_principal rule contexts. + SetAs_principal(IPrincipal_idContext) + + // GetTo_principal returns the to_principal rule context list. + GetTo_principal() []IPrincipal_idContext + + // SetTo_principal sets the to_principal rule context list. + SetTo_principal([]IPrincipal_idContext) + + // Getter signatures + Execute_clause() IExecute_clauseContext + SEMI() antlr.TerminalNode + AllGRANT() []antlr.TerminalNode + GRANT(i int) antlr.TerminalNode + TO() antlr.TerminalNode + AllPrincipal_id() []IPrincipal_idContext + Principal_id(i int) IPrincipal_idContext + ALL() antlr.TerminalNode + Grant_permission() IGrant_permissionContext + ON() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + OPTION() antlr.TerminalNode + AS() antlr.TerminalNode + Table_name() ITable_nameContext + PRIVILEGES() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Column_name_list() IColumn_name_listContext + RR_BRACKET() antlr.TerminalNode + Class_type_for_grant() IClass_type_for_grantContext + DOUBLE_COLON() antlr.TerminalNode + REVERT() antlr.TerminalNode + COOKIE() antlr.TerminalNode + EQUAL() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + Open_key() IOpen_keyContext + Close_key() IClose_keyContext + Create_key() ICreate_keyContext + Create_certificate() ICreate_certificateContext + + // IsSecurity_statementContext differentiates from other interfaces. + IsSecurity_statementContext() +} + +type Security_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + on_id ITable_nameContext + _principal_id IPrincipal_idContext + to_principal []IPrincipal_idContext + as_principal IPrincipal_idContext +} + +func NewEmptySecurity_statementContext() *Security_statementContext { + var p = new(Security_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_security_statement + return p +} + +func InitEmptySecurity_statementContext(p *Security_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_security_statement +} + +func (*Security_statementContext) IsSecurity_statementContext() {} + +func NewSecurity_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Security_statementContext { + var p = new(Security_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_security_statement + + return p +} + +func (s *Security_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Security_statementContext) GetOn_id() ITable_nameContext { return s.on_id } + +func (s *Security_statementContext) Get_principal_id() IPrincipal_idContext { return s._principal_id } + +func (s *Security_statementContext) GetAs_principal() IPrincipal_idContext { return s.as_principal } + +func (s *Security_statementContext) SetOn_id(v ITable_nameContext) { s.on_id = v } + +func (s *Security_statementContext) Set_principal_id(v IPrincipal_idContext) { s._principal_id = v } + +func (s *Security_statementContext) SetAs_principal(v IPrincipal_idContext) { s.as_principal = v } + +func (s *Security_statementContext) GetTo_principal() []IPrincipal_idContext { return s.to_principal } + +func (s *Security_statementContext) SetTo_principal(v []IPrincipal_idContext) { s.to_principal = v } + +func (s *Security_statementContext) Execute_clause() IExecute_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_clauseContext) +} + +func (s *Security_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Security_statementContext) AllGRANT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserGRANT) +} + +func (s *Security_statementContext) GRANT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserGRANT, i) +} + +func (s *Security_statementContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Security_statementContext) AllPrincipal_id() []IPrincipal_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPrincipal_idContext); ok { + len++ + } + } + + tst := make([]IPrincipal_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPrincipal_idContext); ok { + tst[i] = t.(IPrincipal_idContext) + i++ + } + } + + return tst +} + +func (s *Security_statementContext) Principal_id(i int) IPrincipal_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrincipal_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPrincipal_idContext) +} + +func (s *Security_statementContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Security_statementContext) Grant_permission() IGrant_permissionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_permissionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_permissionContext) +} + +func (s *Security_statementContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Security_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Security_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Security_statementContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Security_statementContext) OPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserOPTION, 0) +} + +func (s *Security_statementContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Security_statementContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Security_statementContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIVILEGES, 0) +} + +func (s *Security_statementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Security_statementContext) Column_name_list() IColumn_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Security_statementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Security_statementContext) Class_type_for_grant() IClass_type_for_grantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClass_type_for_grantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClass_type_for_grantContext) +} + +func (s *Security_statementContext) DOUBLE_COLON() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_COLON, 0) +} + +func (s *Security_statementContext) REVERT() antlr.TerminalNode { + return s.GetToken(TSqlParserREVERT, 0) +} + +func (s *Security_statementContext) COOKIE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOOKIE, 0) +} + +func (s *Security_statementContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Security_statementContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Security_statementContext) Open_key() IOpen_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpen_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpen_keyContext) +} + +func (s *Security_statementContext) Close_key() IClose_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClose_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClose_keyContext) +} + +func (s *Security_statementContext) Create_key() ICreate_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_keyContext) +} + +func (s *Security_statementContext) Create_certificate() ICreate_certificateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_certificateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_certificateContext) +} + +func (s *Security_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Security_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Security_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSecurity_statement(s) + } +} + +func (s *Security_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSecurity_statement(s) + } +} + +func (s *Security_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSecurity_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Security_statement() (localctx ISecurity_statementContext) { + localctx = NewSecurity_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 774, TSqlParserRULE_security_statement) + var _la int + + p.SetState(9692) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1301, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9630) + p.Execute_clause() + } + p.SetState(9632) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1289, p.GetParserRuleContext()) == 1 { + { + p.SetState(9631) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9634) + p.Match(TSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALL: + { + p.SetState(9635) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPRIVILEGES { + { + p.SetState(9636) + p.Match(TSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserADMINISTER, TSqlParserALTER, TSqlParserAUTHENTICATE, TSqlParserBACKUP, TSqlParserCHECKPOINT, TSqlParserCONNECT, TSqlParserCONTROL, TSqlParserCREATE, TSqlParserDELETE, TSqlParserEXECUTE, TSqlParserEXTERNAL, TSqlParserIMPERSONATE, TSqlParserINSERT, TSqlParserKILL, TSqlParserRECEIVE, TSqlParserREFERENCES, TSqlParserSELECT, TSqlParserSEND, TSqlParserSHOWPLAN, TSqlParserSHUTDOWN, TSqlParserSUBSCRIBE, TSqlParserTAKE, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUPDATE, TSqlParserVIEW: + { + p.SetState(9639) + p.Grant_permission() + } + p.SetState(9644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLR_BRACKET { + { + p.SetState(9640) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9641) + p.Column_name_list() + } + { + p.SetState(9642) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(9648) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9652) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1293, p.GetParserRuleContext()) == 1 { + { + p.SetState(9649) + p.Class_type_for_grant() + } + { + p.SetState(9650) + p.Match(TSqlParserDOUBLE_COLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9654) + + var _x = p.Table_name() + + localctx.(*Security_statementContext).on_id = _x + } + + } + { + p.SetState(9657) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9658) + + var _x = p.Principal_id() + + localctx.(*Security_statementContext)._principal_id = _x + } + localctx.(*Security_statementContext).to_principal = append(localctx.(*Security_statementContext).to_principal, localctx.(*Security_statementContext)._principal_id) + p.SetState(9663) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(9659) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9660) + + var _x = p.Principal_id() + + localctx.(*Security_statementContext)._principal_id = _x + } + localctx.(*Security_statementContext).to_principal = append(localctx.(*Security_statementContext).to_principal, localctx.(*Security_statementContext)._principal_id) + + p.SetState(9665) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(9669) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1296, p.GetParserRuleContext()) == 1 { + { + p.SetState(9666) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9667) + p.Match(TSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9668) + p.Match(TSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9673) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(9671) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9672) + + var _x = p.Principal_id() + + localctx.(*Security_statementContext).as_principal = _x + } + + } + p.SetState(9676) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1298, p.GetParserRuleContext()) == 1 { + { + p.SetState(9675) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9678) + p.Match(TSqlParserREVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9683) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1299, p.GetParserRuleContext()) == 1 { + { + p.SetState(9679) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9680) + p.Match(TSqlParserCOOKIE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9681) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9682) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9686) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1300, p.GetParserRuleContext()) == 1 { + { + p.SetState(9685) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9688) + p.Open_key() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9689) + p.Close_key() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9690) + p.Create_key() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(9691) + p.Create_certificate() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrincipal_idContext is an interface to support dynamic dispatch. +type IPrincipal_idContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + PUBLIC() antlr.TerminalNode + + // IsPrincipal_idContext differentiates from other interfaces. + IsPrincipal_idContext() +} + +type Principal_idContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrincipal_idContext() *Principal_idContext { + var p = new(Principal_idContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_principal_id + return p +} + +func InitEmptyPrincipal_idContext(p *Principal_idContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_principal_id +} + +func (*Principal_idContext) IsPrincipal_idContext() {} + +func NewPrincipal_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Principal_idContext { + var p = new(Principal_idContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_principal_id + + return p +} + +func (s *Principal_idContext) GetParser() antlr.Parser { return s.parser } + +func (s *Principal_idContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Principal_idContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(TSqlParserPUBLIC, 0) +} + +func (s *Principal_idContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Principal_idContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Principal_idContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPrincipal_id(s) + } +} + +func (s *Principal_idContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPrincipal_id(s) + } +} + +func (s *Principal_idContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPrincipal_id(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Principal_id() (localctx IPrincipal_idContext) { + localctx = NewPrincipal_idContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 776, TSqlParserRULE_principal_id) + p.SetState(9696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9694) + p.Id_() + } + + case TSqlParserPUBLIC: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9695) + p.Match(TSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_certificateContext is an interface to support dynamic dispatch. +type ICreate_certificateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCertificate_name returns the certificate_name rule contexts. + GetCertificate_name() IId_Context + + // GetUser_name returns the user_name rule contexts. + GetUser_name() IId_Context + + // SetCertificate_name sets the certificate_name rule contexts. + SetCertificate_name(IId_Context) + + // SetUser_name sets the user_name rule contexts. + SetUser_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + FROM() antlr.TerminalNode + Existing_keys() IExisting_keysContext + Generate_new_keys() IGenerate_new_keysContext + AUTHORIZATION() antlr.TerminalNode + ACTIVE() antlr.TerminalNode + FOR() antlr.TerminalNode + BEGIN() antlr.TerminalNode + DIALOG() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + + // IsCreate_certificateContext differentiates from other interfaces. + IsCreate_certificateContext() +} + +type Create_certificateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + certificate_name IId_Context + user_name IId_Context +} + +func NewEmptyCreate_certificateContext() *Create_certificateContext { + var p = new(Create_certificateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_certificate + return p +} + +func InitEmptyCreate_certificateContext(p *Create_certificateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_certificate +} + +func (*Create_certificateContext) IsCreate_certificateContext() {} + +func NewCreate_certificateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_certificateContext { + var p = new(Create_certificateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_certificate + + return p +} + +func (s *Create_certificateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_certificateContext) GetCertificate_name() IId_Context { return s.certificate_name } + +func (s *Create_certificateContext) GetUser_name() IId_Context { return s.user_name } + +func (s *Create_certificateContext) SetCertificate_name(v IId_Context) { s.certificate_name = v } + +func (s *Create_certificateContext) SetUser_name(v IId_Context) { s.user_name = v } + +func (s *Create_certificateContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_certificateContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Create_certificateContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_certificateContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_certificateContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Create_certificateContext) Existing_keys() IExisting_keysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExisting_keysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExisting_keysContext) +} + +func (s *Create_certificateContext) Generate_new_keys() IGenerate_new_keysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGenerate_new_keysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGenerate_new_keysContext) +} + +func (s *Create_certificateContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_certificateContext) ACTIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserACTIVE, 0) +} + +func (s *Create_certificateContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Create_certificateContext) BEGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserBEGIN, 0) +} + +func (s *Create_certificateContext) DIALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserDIALOG, 0) +} + +func (s *Create_certificateContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_certificateContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Create_certificateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_certificateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_certificateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_certificate(s) + } +} + +func (s *Create_certificateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_certificate(s) + } +} + +func (s *Create_certificateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_certificate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_certificate() (localctx ICreate_certificateContext) { + localctx = NewCreate_certificateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 778, TSqlParserRULE_create_certificate) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9698) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9699) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9700) + + var _x = p.Id_() + + localctx.(*Create_certificateContext).certificate_name = _x + } + p.SetState(9703) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(9701) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9702) + + var _x = p.Id_() + + localctx.(*Create_certificateContext).user_name = _x + } + + } + p.SetState(9708) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFROM: + { + p.SetState(9705) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9706) + p.Existing_keys() + } + + case TSqlParserENCRYPTION, TSqlParserWITH: + { + p.SetState(9707) + p.Generate_new_keys() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9716) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1305, p.GetParserRuleContext()) == 1 { + { + p.SetState(9710) + p.Match(TSqlParserACTIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9711) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9712) + p.Match(TSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9713) + p.Match(TSqlParserDIALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9714) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9715) + p.On_off() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExisting_keysContext is an interface to support dynamic dispatch. +type IExisting_keysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPath_to_file returns the path_to_file token. + GetPath_to_file() antlr.Token + + // SetPath_to_file sets the path_to_file token. + SetPath_to_file(antlr.Token) + + // GetAssembly_name returns the assembly_name rule contexts. + GetAssembly_name() IId_Context + + // SetAssembly_name sets the assembly_name rule contexts. + SetAssembly_name(IId_Context) + + // Getter signatures + ASSEMBLY() antlr.TerminalNode + Id_() IId_Context + FILE() antlr.TerminalNode + EQUAL() antlr.TerminalNode + STRING() antlr.TerminalNode + EXECUTABLE() antlr.TerminalNode + WITH() antlr.TerminalNode + PRIVATE() antlr.TerminalNode + KEY() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Private_key_options() IPrivate_key_optionsContext + RR_BRACKET() antlr.TerminalNode + + // IsExisting_keysContext differentiates from other interfaces. + IsExisting_keysContext() +} + +type Existing_keysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + assembly_name IId_Context + path_to_file antlr.Token +} + +func NewEmptyExisting_keysContext() *Existing_keysContext { + var p = new(Existing_keysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_existing_keys + return p +} + +func InitEmptyExisting_keysContext(p *Existing_keysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_existing_keys +} + +func (*Existing_keysContext) IsExisting_keysContext() {} + +func NewExisting_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Existing_keysContext { + var p = new(Existing_keysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_existing_keys + + return p +} + +func (s *Existing_keysContext) GetParser() antlr.Parser { return s.parser } + +func (s *Existing_keysContext) GetPath_to_file() antlr.Token { return s.path_to_file } + +func (s *Existing_keysContext) SetPath_to_file(v antlr.Token) { s.path_to_file = v } + +func (s *Existing_keysContext) GetAssembly_name() IId_Context { return s.assembly_name } + +func (s *Existing_keysContext) SetAssembly_name(v IId_Context) { s.assembly_name = v } + +func (s *Existing_keysContext) ASSEMBLY() antlr.TerminalNode { + return s.GetToken(TSqlParserASSEMBLY, 0) +} + +func (s *Existing_keysContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Existing_keysContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Existing_keysContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Existing_keysContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Existing_keysContext) EXECUTABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXECUTABLE, 0) +} + +func (s *Existing_keysContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Existing_keysContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIVATE, 0) +} + +func (s *Existing_keysContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Existing_keysContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Existing_keysContext) Private_key_options() IPrivate_key_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivate_key_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivate_key_optionsContext) +} + +func (s *Existing_keysContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Existing_keysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Existing_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Existing_keysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExisting_keys(s) + } +} + +func (s *Existing_keysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExisting_keys(s) + } +} + +func (s *Existing_keysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExisting_keys(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Existing_keys() (localctx IExisting_keysContext) { + localctx = NewExisting_keysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 780, TSqlParserRULE_existing_keys) + var _la int + + p.SetState(9735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserASSEMBLY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9718) + p.Match(TSqlParserASSEMBLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9719) + + var _x = p.Id_() + + localctx.(*Existing_keysContext).assembly_name = _x + } + + case TSqlParserEXECUTABLE, TSqlParserFILE: + p.EnterOuterAlt(localctx, 2) + p.SetState(9721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserEXECUTABLE { + { + p.SetState(9720) + p.Match(TSqlParserEXECUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9723) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9724) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9725) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Existing_keysContext).path_to_file = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9733) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1307, p.GetParserRuleContext()) == 1 { + { + p.SetState(9726) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9727) + p.Match(TSqlParserPRIVATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9728) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9729) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9730) + p.Private_key_options() + } + { + p.SetState(9731) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivate_key_optionsContext is an interface to support dynamic dispatch. +type IPrivate_key_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPath returns the path token. + GetPath() antlr.Token + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // SetPath sets the path token. + SetPath(antlr.Token) + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // Getter signatures + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + FILE() antlr.TerminalNode + BINARY() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + BY() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + DECRYPTION() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + + // IsPrivate_key_optionsContext differentiates from other interfaces. + IsPrivate_key_optionsContext() +} + +type Private_key_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + path antlr.Token + password antlr.Token +} + +func NewEmptyPrivate_key_optionsContext() *Private_key_optionsContext { + var p = new(Private_key_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_private_key_options + return p +} + +func InitEmptyPrivate_key_optionsContext(p *Private_key_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_private_key_options +} + +func (*Private_key_optionsContext) IsPrivate_key_optionsContext() {} + +func NewPrivate_key_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Private_key_optionsContext { + var p = new(Private_key_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_private_key_options + + return p +} + +func (s *Private_key_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Private_key_optionsContext) GetPath() antlr.Token { return s.path } + +func (s *Private_key_optionsContext) GetPassword() antlr.Token { return s.password } + +func (s *Private_key_optionsContext) SetPath(v antlr.Token) { s.path = v } + +func (s *Private_key_optionsContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Private_key_optionsContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Private_key_optionsContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Private_key_optionsContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Private_key_optionsContext) BINARY() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY, 0) +} + +func (s *Private_key_optionsContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Private_key_optionsContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Private_key_optionsContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Private_key_optionsContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Private_key_optionsContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Private_key_optionsContext) DECRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserDECRYPTION, 0) +} + +func (s *Private_key_optionsContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Private_key_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Private_key_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Private_key_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPrivate_key_options(s) + } +} + +func (s *Private_key_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPrivate_key_options(s) + } +} + +func (s *Private_key_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPrivate_key_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Private_key_options() (localctx IPrivate_key_optionsContext) { + localctx = NewPrivate_key_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 782, TSqlParserRULE_private_key_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9737) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFILE || _la == TSqlParserBINARY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9738) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9739) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Private_key_optionsContext).path = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9746) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9740) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9741) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDECRYPTION || _la == TSqlParserENCRYPTION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9742) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9743) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9744) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9745) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Private_key_optionsContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGenerate_new_keysContext is an interface to support dynamic dispatch. +type IGenerate_new_keysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // GetCertificate_subject_name returns the certificate_subject_name token. + GetCertificate_subject_name() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // SetCertificate_subject_name sets the certificate_subject_name token. + SetCertificate_subject_name(antlr.Token) + + // Getter signatures + WITH() antlr.TerminalNode + SUBJECT() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + BY() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllDate_options() []IDate_optionsContext + Date_options(i int) IDate_optionsContext + + // IsGenerate_new_keysContext differentiates from other interfaces. + IsGenerate_new_keysContext() +} + +type Generate_new_keysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + password antlr.Token + certificate_subject_name antlr.Token +} + +func NewEmptyGenerate_new_keysContext() *Generate_new_keysContext { + var p = new(Generate_new_keysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_generate_new_keys + return p +} + +func InitEmptyGenerate_new_keysContext(p *Generate_new_keysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_generate_new_keys +} + +func (*Generate_new_keysContext) IsGenerate_new_keysContext() {} + +func NewGenerate_new_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generate_new_keysContext { + var p = new(Generate_new_keysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_generate_new_keys + + return p +} + +func (s *Generate_new_keysContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generate_new_keysContext) GetPassword() antlr.Token { return s.password } + +func (s *Generate_new_keysContext) GetCertificate_subject_name() antlr.Token { + return s.certificate_subject_name +} + +func (s *Generate_new_keysContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Generate_new_keysContext) SetCertificate_subject_name(v antlr.Token) { + s.certificate_subject_name = v +} + +func (s *Generate_new_keysContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Generate_new_keysContext) SUBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserSUBJECT, 0) +} + +func (s *Generate_new_keysContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Generate_new_keysContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Generate_new_keysContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Generate_new_keysContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Generate_new_keysContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Generate_new_keysContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Generate_new_keysContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Generate_new_keysContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Generate_new_keysContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Generate_new_keysContext) AllDate_options() []IDate_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDate_optionsContext); ok { + len++ + } + } + + tst := make([]IDate_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDate_optionsContext); ok { + tst[i] = t.(IDate_optionsContext) + i++ + } + } + + return tst +} + +func (s *Generate_new_keysContext) Date_options(i int) IDate_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDate_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDate_optionsContext) +} + +func (s *Generate_new_keysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generate_new_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generate_new_keysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterGenerate_new_keys(s) + } +} + +func (s *Generate_new_keysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitGenerate_new_keys(s) + } +} + +func (s *Generate_new_keysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitGenerate_new_keys(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Generate_new_keys() (localctx IGenerate_new_keysContext) { + localctx = NewGenerate_new_keysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 784, TSqlParserRULE_generate_new_keys) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserENCRYPTION { + { + p.SetState(9748) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9749) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9750) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9751) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9752) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Generate_new_keysContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9755) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9756) + p.Match(TSqlParserSUBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9757) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9758) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Generate_new_keysContext).certificate_subject_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(9759) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9760) + p.Date_options() + } + + p.SetState(9765) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDate_optionsContext is an interface to support dynamic dispatch. +type IDate_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQUAL() antlr.TerminalNode + STRING() antlr.TerminalNode + START_DATE() antlr.TerminalNode + EXPIRY_DATE() antlr.TerminalNode + + // IsDate_optionsContext differentiates from other interfaces. + IsDate_optionsContext() +} + +type Date_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDate_optionsContext() *Date_optionsContext { + var p = new(Date_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_date_options + return p +} + +func InitEmptyDate_optionsContext(p *Date_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_date_options +} + +func (*Date_optionsContext) IsDate_optionsContext() {} + +func NewDate_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Date_optionsContext { + var p = new(Date_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_date_options + + return p +} + +func (s *Date_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Date_optionsContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Date_optionsContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Date_optionsContext) START_DATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTART_DATE, 0) +} + +func (s *Date_optionsContext) EXPIRY_DATE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXPIRY_DATE, 0) +} + +func (s *Date_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Date_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Date_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDate_options(s) + } +} + +func (s *Date_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDate_options(s) + } +} + +func (s *Date_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDate_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Date_options() (localctx IDate_optionsContext) { + localctx = NewDate_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 786, TSqlParserRULE_date_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9766) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserEXPIRY_DATE || _la == TSqlParserSTART_DATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9767) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9768) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpen_keyContext is an interface to support dynamic dispatch. +type IOpen_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // GetKey_name returns the key_name rule contexts. + GetKey_name() IId_Context + + // SetKey_name sets the key_name rule contexts. + SetKey_name(IId_Context) + + // Getter signatures + OPEN() antlr.TerminalNode + SYMMETRIC() antlr.TerminalNode + KEY() antlr.TerminalNode + DECRYPTION() antlr.TerminalNode + BY() antlr.TerminalNode + Decryption_mechanism() IDecryption_mechanismContext + Id_() IId_Context + MASTER() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + EQUAL() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsOpen_keyContext differentiates from other interfaces. + IsOpen_keyContext() +} + +type Open_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + key_name IId_Context + password antlr.Token +} + +func NewEmptyOpen_keyContext() *Open_keyContext { + var p = new(Open_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_open_key + return p +} + +func InitEmptyOpen_keyContext(p *Open_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_open_key +} + +func (*Open_keyContext) IsOpen_keyContext() {} + +func NewOpen_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Open_keyContext { + var p = new(Open_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_open_key + + return p +} + +func (s *Open_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Open_keyContext) GetPassword() antlr.Token { return s.password } + +func (s *Open_keyContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Open_keyContext) GetKey_name() IId_Context { return s.key_name } + +func (s *Open_keyContext) SetKey_name(v IId_Context) { s.key_name = v } + +func (s *Open_keyContext) OPEN() antlr.TerminalNode { + return s.GetToken(TSqlParserOPEN, 0) +} + +func (s *Open_keyContext) SYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserSYMMETRIC, 0) +} + +func (s *Open_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Open_keyContext) DECRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserDECRYPTION, 0) +} + +func (s *Open_keyContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Open_keyContext) Decryption_mechanism() IDecryption_mechanismContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecryption_mechanismContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecryption_mechanismContext) +} + +func (s *Open_keyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Open_keyContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *Open_keyContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Open_keyContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Open_keyContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Open_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Open_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Open_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOpen_key(s) + } +} + +func (s *Open_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOpen_key(s) + } +} + +func (s *Open_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOpen_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Open_key() (localctx IOpen_keyContext) { + localctx = NewOpen_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 788, TSqlParserRULE_open_key) + p.SetState(9786) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1312, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9770) + p.Match(TSqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9771) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9772) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9773) + + var _x = p.Id_() + + localctx.(*Open_keyContext).key_name = _x + } + { + p.SetState(9774) + p.Match(TSqlParserDECRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9775) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9776) + p.Decryption_mechanism() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9778) + p.Match(TSqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9779) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9780) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9781) + p.Match(TSqlParserDECRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9782) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9783) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9784) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9785) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Open_keyContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClose_keyContext is an interface to support dynamic dispatch. +type IClose_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKey_name returns the key_name rule contexts. + GetKey_name() IId_Context + + // SetKey_name sets the key_name rule contexts. + SetKey_name(IId_Context) + + // Getter signatures + CLOSE() antlr.TerminalNode + SYMMETRIC() antlr.TerminalNode + KEY() antlr.TerminalNode + Id_() IId_Context + ALL() antlr.TerminalNode + KEYS() antlr.TerminalNode + MASTER() antlr.TerminalNode + + // IsClose_keyContext differentiates from other interfaces. + IsClose_keyContext() +} + +type Close_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + key_name IId_Context +} + +func NewEmptyClose_keyContext() *Close_keyContext { + var p = new(Close_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_close_key + return p +} + +func InitEmptyClose_keyContext(p *Close_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_close_key +} + +func (*Close_keyContext) IsClose_keyContext() {} + +func NewClose_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Close_keyContext { + var p = new(Close_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_close_key + + return p +} + +func (s *Close_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Close_keyContext) GetKey_name() IId_Context { return s.key_name } + +func (s *Close_keyContext) SetKey_name(v IId_Context) { s.key_name = v } + +func (s *Close_keyContext) CLOSE() antlr.TerminalNode { + return s.GetToken(TSqlParserCLOSE, 0) +} + +func (s *Close_keyContext) SYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserSYMMETRIC, 0) +} + +func (s *Close_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Close_keyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Close_keyContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Close_keyContext) KEYS() antlr.TerminalNode { + return s.GetToken(TSqlParserKEYS, 0) +} + +func (s *Close_keyContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *Close_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Close_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Close_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterClose_key(s) + } +} + +func (s *Close_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitClose_key(s) + } +} + +func (s *Close_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitClose_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Close_key() (localctx IClose_keyContext) { + localctx = NewClose_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 790, TSqlParserRULE_close_key) + p.SetState(9799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1313, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9788) + p.Match(TSqlParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9789) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9790) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9791) + + var _x = p.Id_() + + localctx.(*Close_keyContext).key_name = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9792) + p.Match(TSqlParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9793) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9794) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9795) + p.Match(TSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9796) + p.Match(TSqlParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9797) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9798) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_keyContext is an interface to support dynamic dispatch. +type ICreate_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPassword returns the password token. + GetPassword() antlr.Token + + // SetPassword sets the password token. + SetPassword(antlr.Token) + + // GetKey_name returns the key_name rule contexts. + GetKey_name() IId_Context + + // GetUser_name returns the user_name rule contexts. + GetUser_name() IId_Context + + // GetProvider_name returns the provider_name rule contexts. + GetProvider_name() IId_Context + + // SetKey_name sets the key_name rule contexts. + SetKey_name(IId_Context) + + // SetUser_name sets the user_name rule contexts. + SetUser_name(IId_Context) + + // SetProvider_name sets the provider_name rule contexts. + SetProvider_name(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + MASTER() antlr.TerminalNode + KEY() antlr.TerminalNode + AllENCRYPTION() []antlr.TerminalNode + ENCRYPTION(i int) antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + PASSWORD() antlr.TerminalNode + EQUAL() antlr.TerminalNode + STRING() antlr.TerminalNode + SYMMETRIC() antlr.TerminalNode + WITH() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AUTHORIZATION() antlr.TerminalNode + FROM() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + AllKey_options() []IKey_optionsContext + Key_options(i int) IKey_optionsContext + AllEncryption_mechanism() []IEncryption_mechanismContext + Encryption_mechanism(i int) IEncryption_mechanismContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_keyContext differentiates from other interfaces. + IsCreate_keyContext() +} + +type Create_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + password antlr.Token + key_name IId_Context + user_name IId_Context + provider_name IId_Context +} + +func NewEmptyCreate_keyContext() *Create_keyContext { + var p = new(Create_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_key + return p +} + +func InitEmptyCreate_keyContext(p *Create_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_key +} + +func (*Create_keyContext) IsCreate_keyContext() {} + +func NewCreate_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_keyContext { + var p = new(Create_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_key + + return p +} + +func (s *Create_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_keyContext) GetPassword() antlr.Token { return s.password } + +func (s *Create_keyContext) SetPassword(v antlr.Token) { s.password = v } + +func (s *Create_keyContext) GetKey_name() IId_Context { return s.key_name } + +func (s *Create_keyContext) GetUser_name() IId_Context { return s.user_name } + +func (s *Create_keyContext) GetProvider_name() IId_Context { return s.provider_name } + +func (s *Create_keyContext) SetKey_name(v IId_Context) { s.key_name = v } + +func (s *Create_keyContext) SetUser_name(v IId_Context) { s.user_name = v } + +func (s *Create_keyContext) SetProvider_name(v IId_Context) { s.provider_name = v } + +func (s *Create_keyContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Create_keyContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *Create_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Create_keyContext) AllENCRYPTION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserENCRYPTION) +} + +func (s *Create_keyContext) ENCRYPTION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, i) +} + +func (s *Create_keyContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(TSqlParserBY) +} + +func (s *Create_keyContext) BY(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserBY, i) +} + +func (s *Create_keyContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Create_keyContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_keyContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_keyContext) SYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserSYMMETRIC, 0) +} + +func (s *Create_keyContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Create_keyContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_keyContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_keyContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHORIZATION, 0) +} + +func (s *Create_keyContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Create_keyContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER, 0) +} + +func (s *Create_keyContext) AllKey_options() []IKey_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_optionsContext); ok { + len++ + } + } + + tst := make([]IKey_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_optionsContext); ok { + tst[i] = t.(IKey_optionsContext) + i++ + } + } + + return tst +} + +func (s *Create_keyContext) Key_options(i int) IKey_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_optionsContext) +} + +func (s *Create_keyContext) AllEncryption_mechanism() []IEncryption_mechanismContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEncryption_mechanismContext); ok { + len++ + } + } + + tst := make([]IEncryption_mechanismContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEncryption_mechanismContext); ok { + tst[i] = t.(IEncryption_mechanismContext) + i++ + } + } + + return tst +} + +func (s *Create_keyContext) Encryption_mechanism(i int) IEncryption_mechanismContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryption_mechanismContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEncryption_mechanismContext) +} + +func (s *Create_keyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_keyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_key(s) + } +} + +func (s *Create_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_key(s) + } +} + +func (s *Create_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_key() (localctx ICreate_keyContext) { + localctx = NewCreate_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 792, TSqlParserRULE_create_key) + var _la int + + var _alt int + + p.SetState(9836) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1319, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9801) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9802) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9803) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9804) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9805) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9806) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9807) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9808) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Create_keyContext).password = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9809) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9810) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9811) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9812) + + var _x = p.Id_() + + localctx.(*Create_keyContext).key_name = _x + } + p.SetState(9815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAUTHORIZATION { + { + p.SetState(9813) + p.Match(TSqlParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9814) + + var _x = p.Id_() + + localctx.(*Create_keyContext).user_name = _x + } + + } + p.SetState(9820) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFROM { + { + p.SetState(9817) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9818) + p.Match(TSqlParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9819) + + var _x = p.Id_() + + localctx.(*Create_keyContext).provider_name = _x + } + + } + { + p.SetState(9822) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(9827) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALGORITHM, TSqlParserCREATION_DISPOSITION, TSqlParserIDENTITY_VALUE, TSqlParserKEY_SOURCE, TSqlParserPROVIDER_KEY_NAME: + { + p.SetState(9823) + p.Key_options() + } + + case TSqlParserENCRYPTION: + { + p.SetState(9824) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9825) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9826) + p.Encryption_mechanism() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9830) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(9829) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9834) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1318, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKey_optionsContext is an interface to support dynamic dispatch. +type IKey_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPass_phrase returns the pass_phrase token. + GetPass_phrase() antlr.Token + + // GetIdentity_phrase returns the identity_phrase token. + GetIdentity_phrase() antlr.Token + + // GetKey_name_in_provider returns the key_name_in_provider token. + GetKey_name_in_provider() antlr.Token + + // SetPass_phrase sets the pass_phrase token. + SetPass_phrase(antlr.Token) + + // SetIdentity_phrase sets the identity_phrase token. + SetIdentity_phrase(antlr.Token) + + // SetKey_name_in_provider sets the key_name_in_provider token. + SetKey_name_in_provider(antlr.Token) + + // Getter signatures + KEY_SOURCE() antlr.TerminalNode + EQUAL() antlr.TerminalNode + STRING() antlr.TerminalNode + ALGORITHM() antlr.TerminalNode + Algorithm() IAlgorithmContext + IDENTITY_VALUE() antlr.TerminalNode + PROVIDER_KEY_NAME() antlr.TerminalNode + CREATION_DISPOSITION() antlr.TerminalNode + CREATE_NEW() antlr.TerminalNode + OPEN_EXISTING() antlr.TerminalNode + + // IsKey_optionsContext differentiates from other interfaces. + IsKey_optionsContext() +} + +type Key_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + pass_phrase antlr.Token + identity_phrase antlr.Token + key_name_in_provider antlr.Token +} + +func NewEmptyKey_optionsContext() *Key_optionsContext { + var p = new(Key_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_key_options + return p +} + +func InitEmptyKey_optionsContext(p *Key_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_key_options +} + +func (*Key_optionsContext) IsKey_optionsContext() {} + +func NewKey_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_optionsContext { + var p = new(Key_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_key_options + + return p +} + +func (s *Key_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Key_optionsContext) GetPass_phrase() antlr.Token { return s.pass_phrase } + +func (s *Key_optionsContext) GetIdentity_phrase() antlr.Token { return s.identity_phrase } + +func (s *Key_optionsContext) GetKey_name_in_provider() antlr.Token { return s.key_name_in_provider } + +func (s *Key_optionsContext) SetPass_phrase(v antlr.Token) { s.pass_phrase = v } + +func (s *Key_optionsContext) SetIdentity_phrase(v antlr.Token) { s.identity_phrase = v } + +func (s *Key_optionsContext) SetKey_name_in_provider(v antlr.Token) { s.key_name_in_provider = v } + +func (s *Key_optionsContext) KEY_SOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY_SOURCE, 0) +} + +func (s *Key_optionsContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Key_optionsContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Key_optionsContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(TSqlParserALGORITHM, 0) +} + +func (s *Key_optionsContext) Algorithm() IAlgorithmContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlgorithmContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlgorithmContext) +} + +func (s *Key_optionsContext) IDENTITY_VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENTITY_VALUE, 0) +} + +func (s *Key_optionsContext) PROVIDER_KEY_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER_KEY_NAME, 0) +} + +func (s *Key_optionsContext) CREATION_DISPOSITION() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATION_DISPOSITION, 0) +} + +func (s *Key_optionsContext) CREATE_NEW() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE_NEW, 0) +} + +func (s *Key_optionsContext) OPEN_EXISTING() antlr.TerminalNode { + return s.GetToken(TSqlParserOPEN_EXISTING, 0) +} + +func (s *Key_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Key_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Key_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterKey_options(s) + } +} + +func (s *Key_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitKey_options(s) + } +} + +func (s *Key_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitKey_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Key_options() (localctx IKey_optionsContext) { + localctx = NewKey_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 794, TSqlParserRULE_key_options) + var _la int + + p.SetState(9853) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserKEY_SOURCE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9838) + p.Match(TSqlParserKEY_SOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9839) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9840) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Key_optionsContext).pass_phrase = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserALGORITHM: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9841) + p.Match(TSqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9842) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9843) + p.Algorithm() + } + + case TSqlParserIDENTITY_VALUE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9844) + p.Match(TSqlParserIDENTITY_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9845) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9846) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Key_optionsContext).identity_phrase = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPROVIDER_KEY_NAME: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9847) + p.Match(TSqlParserPROVIDER_KEY_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9848) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9849) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Key_optionsContext).key_name_in_provider = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCREATION_DISPOSITION: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9850) + p.Match(TSqlParserCREATION_DISPOSITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9851) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9852) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCREATE_NEW || _la == TSqlParserOPEN_EXISTING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlgorithmContext is an interface to support dynamic dispatch. +type IAlgorithmContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DES() antlr.TerminalNode + TRIPLE_DES() antlr.TerminalNode + TRIPLE_DES_3KEY() antlr.TerminalNode + RC2() antlr.TerminalNode + RC4() antlr.TerminalNode + RC4_128() antlr.TerminalNode + DESX() antlr.TerminalNode + AES_128() antlr.TerminalNode + AES_192() antlr.TerminalNode + AES_256() antlr.TerminalNode + + // IsAlgorithmContext differentiates from other interfaces. + IsAlgorithmContext() +} + +type AlgorithmContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlgorithmContext() *AlgorithmContext { + var p = new(AlgorithmContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_algorithm + return p +} + +func InitEmptyAlgorithmContext(p *AlgorithmContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_algorithm +} + +func (*AlgorithmContext) IsAlgorithmContext() {} + +func NewAlgorithmContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlgorithmContext { + var p = new(AlgorithmContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_algorithm + + return p +} + +func (s *AlgorithmContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlgorithmContext) DES() antlr.TerminalNode { + return s.GetToken(TSqlParserDES, 0) +} + +func (s *AlgorithmContext) TRIPLE_DES() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIPLE_DES, 0) +} + +func (s *AlgorithmContext) TRIPLE_DES_3KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIPLE_DES_3KEY, 0) +} + +func (s *AlgorithmContext) RC2() antlr.TerminalNode { + return s.GetToken(TSqlParserRC2, 0) +} + +func (s *AlgorithmContext) RC4() antlr.TerminalNode { + return s.GetToken(TSqlParserRC4, 0) +} + +func (s *AlgorithmContext) RC4_128() antlr.TerminalNode { + return s.GetToken(TSqlParserRC4_128, 0) +} + +func (s *AlgorithmContext) DESX() antlr.TerminalNode { + return s.GetToken(TSqlParserDESX, 0) +} + +func (s *AlgorithmContext) AES_128() antlr.TerminalNode { + return s.GetToken(TSqlParserAES_128, 0) +} + +func (s *AlgorithmContext) AES_192() antlr.TerminalNode { + return s.GetToken(TSqlParserAES_192, 0) +} + +func (s *AlgorithmContext) AES_256() antlr.TerminalNode { + return s.GetToken(TSqlParserAES_256, 0) +} + +func (s *AlgorithmContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlgorithmContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlgorithmContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlgorithm(s) + } +} + +func (s *AlgorithmContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlgorithm(s) + } +} + +func (s *AlgorithmContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlgorithm(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Algorithm() (localctx IAlgorithmContext) { + localctx = NewAlgorithmContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 796, TSqlParserRULE_algorithm) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9855) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&229376) != 0) || _la == TSqlParserDES || _la == TSqlParserDESX || ((int64((_la-764)) & ^0x3f) == 0 && ((int64(1)<<(_la-764))&7) != 0) || _la == TSqlParserTRIPLE_DES || _la == TSqlParserTRIPLE_DES_3KEY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEncryption_mechanismContext is an interface to support dynamic dispatch. +type IEncryption_mechanismContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCertificate_name returns the certificate_name rule contexts. + GetCertificate_name() IId_Context + + // GetAsym_key_name returns the asym_key_name rule contexts. + GetAsym_key_name() IId_Context + + // GetDecrypting_Key_name returns the decrypting_Key_name rule contexts. + GetDecrypting_Key_name() IId_Context + + // SetCertificate_name sets the certificate_name rule contexts. + SetCertificate_name(IId_Context) + + // SetAsym_key_name sets the asym_key_name rule contexts. + SetAsym_key_name(IId_Context) + + // SetDecrypting_Key_name sets the decrypting_Key_name rule contexts. + SetDecrypting_Key_name(IId_Context) + + // Getter signatures + CERTIFICATE() antlr.TerminalNode + Id_() IId_Context + ASYMMETRIC() antlr.TerminalNode + KEY() antlr.TerminalNode + SYMMETRIC() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + EQUAL() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsEncryption_mechanismContext differentiates from other interfaces. + IsEncryption_mechanismContext() +} + +type Encryption_mechanismContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + certificate_name IId_Context + asym_key_name IId_Context + decrypting_Key_name IId_Context +} + +func NewEmptyEncryption_mechanismContext() *Encryption_mechanismContext { + var p = new(Encryption_mechanismContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_encryption_mechanism + return p +} + +func InitEmptyEncryption_mechanismContext(p *Encryption_mechanismContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_encryption_mechanism +} + +func (*Encryption_mechanismContext) IsEncryption_mechanismContext() {} + +func NewEncryption_mechanismContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Encryption_mechanismContext { + var p = new(Encryption_mechanismContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_encryption_mechanism + + return p +} + +func (s *Encryption_mechanismContext) GetParser() antlr.Parser { return s.parser } + +func (s *Encryption_mechanismContext) GetCertificate_name() IId_Context { return s.certificate_name } + +func (s *Encryption_mechanismContext) GetAsym_key_name() IId_Context { return s.asym_key_name } + +func (s *Encryption_mechanismContext) GetDecrypting_Key_name() IId_Context { + return s.decrypting_Key_name +} + +func (s *Encryption_mechanismContext) SetCertificate_name(v IId_Context) { s.certificate_name = v } + +func (s *Encryption_mechanismContext) SetAsym_key_name(v IId_Context) { s.asym_key_name = v } + +func (s *Encryption_mechanismContext) SetDecrypting_Key_name(v IId_Context) { + s.decrypting_Key_name = v +} + +func (s *Encryption_mechanismContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Encryption_mechanismContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Encryption_mechanismContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, 0) +} + +func (s *Encryption_mechanismContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Encryption_mechanismContext) SYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserSYMMETRIC, 0) +} + +func (s *Encryption_mechanismContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Encryption_mechanismContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Encryption_mechanismContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Encryption_mechanismContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Encryption_mechanismContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Encryption_mechanismContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEncryption_mechanism(s) + } +} + +func (s *Encryption_mechanismContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEncryption_mechanism(s) + } +} + +func (s *Encryption_mechanismContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEncryption_mechanism(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Encryption_mechanism() (localctx IEncryption_mechanismContext) { + localctx = NewEncryption_mechanismContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 798, TSqlParserRULE_encryption_mechanism) + p.SetState(9868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCERTIFICATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9857) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9858) + + var _x = p.Id_() + + localctx.(*Encryption_mechanismContext).certificate_name = _x + } + + case TSqlParserASYMMETRIC: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9859) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9860) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9861) + + var _x = p.Id_() + + localctx.(*Encryption_mechanismContext).asym_key_name = _x + } + + case TSqlParserSYMMETRIC: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9862) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9863) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9864) + + var _x = p.Id_() + + localctx.(*Encryption_mechanismContext).decrypting_Key_name = _x + } + + case TSqlParserPASSWORD: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9865) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9866) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9867) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecryption_mechanismContext is an interface to support dynamic dispatch. +type IDecryption_mechanismContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCertificate_name returns the certificate_name rule contexts. + GetCertificate_name() IId_Context + + // GetAsym_key_name returns the asym_key_name rule contexts. + GetAsym_key_name() IId_Context + + // GetDecrypting_Key_name returns the decrypting_Key_name rule contexts. + GetDecrypting_Key_name() IId_Context + + // SetCertificate_name sets the certificate_name rule contexts. + SetCertificate_name(IId_Context) + + // SetAsym_key_name sets the asym_key_name rule contexts. + SetAsym_key_name(IId_Context) + + // SetDecrypting_Key_name sets the decrypting_Key_name rule contexts. + SetDecrypting_Key_name(IId_Context) + + // Getter signatures + CERTIFICATE() antlr.TerminalNode + Id_() IId_Context + WITH() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + EQUAL() antlr.TerminalNode + STRING() antlr.TerminalNode + ASYMMETRIC() antlr.TerminalNode + KEY() antlr.TerminalNode + SYMMETRIC() antlr.TerminalNode + + // IsDecryption_mechanismContext differentiates from other interfaces. + IsDecryption_mechanismContext() +} + +type Decryption_mechanismContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + certificate_name IId_Context + asym_key_name IId_Context + decrypting_Key_name IId_Context +} + +func NewEmptyDecryption_mechanismContext() *Decryption_mechanismContext { + var p = new(Decryption_mechanismContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_decryption_mechanism + return p +} + +func InitEmptyDecryption_mechanismContext(p *Decryption_mechanismContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_decryption_mechanism +} + +func (*Decryption_mechanismContext) IsDecryption_mechanismContext() {} + +func NewDecryption_mechanismContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decryption_mechanismContext { + var p = new(Decryption_mechanismContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_decryption_mechanism + + return p +} + +func (s *Decryption_mechanismContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decryption_mechanismContext) GetCertificate_name() IId_Context { return s.certificate_name } + +func (s *Decryption_mechanismContext) GetAsym_key_name() IId_Context { return s.asym_key_name } + +func (s *Decryption_mechanismContext) GetDecrypting_Key_name() IId_Context { + return s.decrypting_Key_name +} + +func (s *Decryption_mechanismContext) SetCertificate_name(v IId_Context) { s.certificate_name = v } + +func (s *Decryption_mechanismContext) SetAsym_key_name(v IId_Context) { s.asym_key_name = v } + +func (s *Decryption_mechanismContext) SetDecrypting_Key_name(v IId_Context) { + s.decrypting_Key_name = v +} + +func (s *Decryption_mechanismContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Decryption_mechanismContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Decryption_mechanismContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Decryption_mechanismContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *Decryption_mechanismContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Decryption_mechanismContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Decryption_mechanismContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, 0) +} + +func (s *Decryption_mechanismContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Decryption_mechanismContext) SYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserSYMMETRIC, 0) +} + +func (s *Decryption_mechanismContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decryption_mechanismContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decryption_mechanismContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDecryption_mechanism(s) + } +} + +func (s *Decryption_mechanismContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDecryption_mechanism(s) + } +} + +func (s *Decryption_mechanismContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDecryption_mechanism(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Decryption_mechanism() (localctx IDecryption_mechanismContext) { + localctx = NewDecryption_mechanismContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 800, TSqlParserRULE_decryption_mechanism) + p.SetState(9893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCERTIFICATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9870) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9871) + + var _x = p.Id_() + + localctx.(*Decryption_mechanismContext).certificate_name = _x + } + p.SetState(9876) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1322, p.GetParserRuleContext()) == 1 { + { + p.SetState(9872) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9873) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9874) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9875) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserASYMMETRIC: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9878) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9879) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9880) + + var _x = p.Id_() + + localctx.(*Decryption_mechanismContext).asym_key_name = _x + } + p.SetState(9885) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1323, p.GetParserRuleContext()) == 1 { + { + p.SetState(9881) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9882) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9883) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9884) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserSYMMETRIC: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9887) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9888) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9889) + + var _x = p.Id_() + + localctx.(*Decryption_mechanismContext).decrypting_Key_name = _x + } + + case TSqlParserPASSWORD: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9890) + p.Match(TSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9891) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9892) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_permissionContext is an interface to support dynamic dispatch. +type IGrant_permissionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADMINISTER() antlr.TerminalNode + BULK() antlr.TerminalNode + OPERATIONS() antlr.TerminalNode + DATABASE() antlr.TerminalNode + ALTER() antlr.TerminalNode + ANY() antlr.TerminalNode + RESOURCES() antlr.TerminalNode + SERVER() antlr.TerminalNode + STATE() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + TRACE() antlr.TerminalNode + APPLICATION() antlr.TerminalNode + ROLE() antlr.TerminalNode + ASSEMBLY() antlr.TerminalNode + ASYMMETRIC() antlr.TerminalNode + KEY() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + GROUP() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + COLUMN() antlr.TerminalNode + CONNECTION() antlr.TerminalNode + CONTRACT() antlr.TerminalNode + CREDENTIAL() antlr.TerminalNode + DATASPACE() antlr.TerminalNode + ENDPOINT() antlr.TerminalNode + EVENT() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + FULLTEXT() antlr.TerminalNode + CATALOG() antlr.TerminalNode + LINKED() antlr.TerminalNode + LOGIN() antlr.TerminalNode + MASK() antlr.TerminalNode + MESSAGE() antlr.TerminalNode + TYPE() antlr.TerminalNode + REMOTE() antlr.TerminalNode + SERVICE() antlr.TerminalNode + BINDING() antlr.TerminalNode + ROUTE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + SECURITY() antlr.TerminalNode + POLICY() antlr.TerminalNode + SYMMETRIC() antlr.TerminalNode + USER() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + SESSION() antlr.TerminalNode + AUDIT() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + MASTER() antlr.TerminalNode + DATA() antlr.TerminalNode + SOURCE() antlr.TerminalNode + FILE() antlr.TerminalNode + FORMAT() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + DDL() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + SCOPED() antlr.TerminalNode + CONFIGURATION() antlr.TerminalNode + AUTHENTICATE() antlr.TerminalNode + BACKUP() antlr.TerminalNode + LOG() antlr.TerminalNode + CHECKPOINT() antlr.TerminalNode + CONNECT() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + SQL() antlr.TerminalNode + CONTROL() antlr.TerminalNode + CREATE() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + QUEUE() antlr.TerminalNode + RULE() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + TABLE() antlr.TerminalNode + VIEW() antlr.TerminalNode + XML() antlr.TerminalNode + COLLECTION() antlr.TerminalNode + DELETE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + SCRIPT() antlr.TerminalNode + ACCESS() antlr.TerminalNode + IMPERSONATE() antlr.TerminalNode + INSERT() antlr.TerminalNode + KILL() antlr.TerminalNode + RECEIVE() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + SELECT() antlr.TerminalNode + ALL() antlr.TerminalNode + SECURABLES() antlr.TerminalNode + SEND() antlr.TerminalNode + SHOWPLAN() antlr.TerminalNode + SHUTDOWN() antlr.TerminalNode + SUBSCRIBE() antlr.TerminalNode + QUERY() antlr.TerminalNode + NOTIFICATIONS() antlr.TerminalNode + TAKE() antlr.TerminalNode + OWNERSHIP() antlr.TerminalNode + UNMASK() antlr.TerminalNode + UNSAFE() antlr.TerminalNode + UPDATE() antlr.TerminalNode + CHANGE() antlr.TerminalNode + TRACKING() antlr.TerminalNode + DEFINITION() antlr.TerminalNode + + // IsGrant_permissionContext differentiates from other interfaces. + IsGrant_permissionContext() +} + +type Grant_permissionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_permissionContext() *Grant_permissionContext { + var p = new(Grant_permissionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_grant_permission + return p +} + +func InitEmptyGrant_permissionContext(p *Grant_permissionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_grant_permission +} + +func (*Grant_permissionContext) IsGrant_permissionContext() {} + +func NewGrant_permissionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_permissionContext { + var p = new(Grant_permissionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_grant_permission + + return p +} + +func (s *Grant_permissionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_permissionContext) ADMINISTER() antlr.TerminalNode { + return s.GetToken(TSqlParserADMINISTER, 0) +} + +func (s *Grant_permissionContext) BULK() antlr.TerminalNode { + return s.GetToken(TSqlParserBULK, 0) +} + +func (s *Grant_permissionContext) OPERATIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserOPERATIONS, 0) +} + +func (s *Grant_permissionContext) DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE, 0) +} + +func (s *Grant_permissionContext) ALTER() antlr.TerminalNode { + return s.GetToken(TSqlParserALTER, 0) +} + +func (s *Grant_permissionContext) ANY() antlr.TerminalNode { + return s.GetToken(TSqlParserANY, 0) +} + +func (s *Grant_permissionContext) RESOURCES() antlr.TerminalNode { + return s.GetToken(TSqlParserRESOURCES, 0) +} + +func (s *Grant_permissionContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *Grant_permissionContext) STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATE, 0) +} + +func (s *Grant_permissionContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(TSqlParserSETTINGS, 0) +} + +func (s *Grant_permissionContext) TRACE() antlr.TerminalNode { + return s.GetToken(TSqlParserTRACE, 0) +} + +func (s *Grant_permissionContext) APPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLICATION, 0) +} + +func (s *Grant_permissionContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *Grant_permissionContext) ASSEMBLY() antlr.TerminalNode { + return s.GetToken(TSqlParserASSEMBLY, 0) +} + +func (s *Grant_permissionContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, 0) +} + +func (s *Grant_permissionContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Grant_permissionContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(TSqlParserAVAILABILITY, 0) +} + +func (s *Grant_permissionContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *Grant_permissionContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *Grant_permissionContext) COLUMN() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMN, 0) +} + +func (s *Grant_permissionContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONNECTION, 0) +} + +func (s *Grant_permissionContext) CONTRACT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTRACT, 0) +} + +func (s *Grant_permissionContext) CREDENTIAL() antlr.TerminalNode { + return s.GetToken(TSqlParserCREDENTIAL, 0) +} + +func (s *Grant_permissionContext) DATASPACE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATASPACE, 0) +} + +func (s *Grant_permissionContext) ENDPOINT() antlr.TerminalNode { + return s.GetToken(TSqlParserENDPOINT, 0) +} + +func (s *Grant_permissionContext) EVENT() antlr.TerminalNode { + return s.GetToken(TSqlParserEVENT, 0) +} + +func (s *Grant_permissionContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL, 0) +} + +func (s *Grant_permissionContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXT, 0) +} + +func (s *Grant_permissionContext) CATALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserCATALOG, 0) +} + +func (s *Grant_permissionContext) LINKED() antlr.TerminalNode { + return s.GetToken(TSqlParserLINKED, 0) +} + +func (s *Grant_permissionContext) LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, 0) +} + +func (s *Grant_permissionContext) MASK() antlr.TerminalNode { + return s.GetToken(TSqlParserMASK, 0) +} + +func (s *Grant_permissionContext) MESSAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE, 0) +} + +func (s *Grant_permissionContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *Grant_permissionContext) REMOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOTE, 0) +} + +func (s *Grant_permissionContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *Grant_permissionContext) BINDING() antlr.TerminalNode { + return s.GetToken(TSqlParserBINDING, 0) +} + +func (s *Grant_permissionContext) ROUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserROUTE, 0) +} + +func (s *Grant_permissionContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA, 0) +} + +func (s *Grant_permissionContext) SECURITY() antlr.TerminalNode { + return s.GetToken(TSqlParserSECURITY, 0) +} + +func (s *Grant_permissionContext) POLICY() antlr.TerminalNode { + return s.GetToken(TSqlParserPOLICY, 0) +} + +func (s *Grant_permissionContext) SYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserSYMMETRIC, 0) +} + +func (s *Grant_permissionContext) USER() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER, 0) +} + +func (s *Grant_permissionContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserNOTIFICATION, 0) +} + +func (s *Grant_permissionContext) SESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserSESSION, 0) +} + +func (s *Grant_permissionContext) AUDIT() antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT, 0) +} + +func (s *Grant_permissionContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Grant_permissionContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *Grant_permissionContext) DATA() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA, 0) +} + +func (s *Grant_permissionContext) SOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserSOURCE, 0) +} + +func (s *Grant_permissionContext) FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE, 0) +} + +func (s *Grant_permissionContext) FORMAT() antlr.TerminalNode { + return s.GetToken(TSqlParserFORMAT, 0) +} + +func (s *Grant_permissionContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(TSqlParserLIBRARY, 0) +} + +func (s *Grant_permissionContext) DDL() antlr.TerminalNode { + return s.GetToken(TSqlParserDDL, 0) +} + +func (s *Grant_permissionContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIGGER, 0) +} + +func (s *Grant_permissionContext) SCOPED() antlr.TerminalNode { + return s.GetToken(TSqlParserSCOPED, 0) +} + +func (s *Grant_permissionContext) CONFIGURATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONFIGURATION, 0) +} + +func (s *Grant_permissionContext) AUTHENTICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHENTICATE, 0) +} + +func (s *Grant_permissionContext) BACKUP() antlr.TerminalNode { + return s.GetToken(TSqlParserBACKUP, 0) +} + +func (s *Grant_permissionContext) LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserLOG, 0) +} + +func (s *Grant_permissionContext) CHECKPOINT() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKPOINT, 0) +} + +func (s *Grant_permissionContext) CONNECT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONNECT, 0) +} + +func (s *Grant_permissionContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLICATION, 0) +} + +func (s *Grant_permissionContext) SQL() antlr.TerminalNode { + return s.GetToken(TSqlParserSQL, 0) +} + +func (s *Grant_permissionContext) CONTROL() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTROL, 0) +} + +func (s *Grant_permissionContext) CREATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE, 0) +} + +func (s *Grant_permissionContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(TSqlParserAGGREGATE, 0) +} + +func (s *Grant_permissionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Grant_permissionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(TSqlParserFUNCTION, 0) +} + +func (s *Grant_permissionContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(TSqlParserPROCEDURE, 0) +} + +func (s *Grant_permissionContext) QUEUE() antlr.TerminalNode { + return s.GetToken(TSqlParserQUEUE, 0) +} + +func (s *Grant_permissionContext) RULE() antlr.TerminalNode { + return s.GetToken(TSqlParserRULE, 0) +} + +func (s *Grant_permissionContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(TSqlParserSEQUENCE, 0) +} + +func (s *Grant_permissionContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(TSqlParserSYNONYM, 0) +} + +func (s *Grant_permissionContext) TABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLE, 0) +} + +func (s *Grant_permissionContext) VIEW() antlr.TerminalNode { + return s.GetToken(TSqlParserVIEW, 0) +} + +func (s *Grant_permissionContext) XML() antlr.TerminalNode { + return s.GetToken(TSqlParserXML, 0) +} + +func (s *Grant_permissionContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLECTION, 0) +} + +func (s *Grant_permissionContext) DELETE() antlr.TerminalNode { + return s.GetToken(TSqlParserDELETE, 0) +} + +func (s *Grant_permissionContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXECUTE, 0) +} + +func (s *Grant_permissionContext) SCRIPT() antlr.TerminalNode { + return s.GetToken(TSqlParserSCRIPT, 0) +} + +func (s *Grant_permissionContext) ACCESS() antlr.TerminalNode { + return s.GetToken(TSqlParserACCESS, 0) +} + +func (s *Grant_permissionContext) IMPERSONATE() antlr.TerminalNode { + return s.GetToken(TSqlParserIMPERSONATE, 0) +} + +func (s *Grant_permissionContext) INSERT() antlr.TerminalNode { + return s.GetToken(TSqlParserINSERT, 0) +} + +func (s *Grant_permissionContext) KILL() antlr.TerminalNode { + return s.GetToken(TSqlParserKILL, 0) +} + +func (s *Grant_permissionContext) RECEIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserRECEIVE, 0) +} + +func (s *Grant_permissionContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(TSqlParserREFERENCES, 0) +} + +func (s *Grant_permissionContext) SELECT() antlr.TerminalNode { + return s.GetToken(TSqlParserSELECT, 0) +} + +func (s *Grant_permissionContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Grant_permissionContext) SECURABLES() antlr.TerminalNode { + return s.GetToken(TSqlParserSECURABLES, 0) +} + +func (s *Grant_permissionContext) SEND() antlr.TerminalNode { + return s.GetToken(TSqlParserSEND, 0) +} + +func (s *Grant_permissionContext) SHOWPLAN() antlr.TerminalNode { + return s.GetToken(TSqlParserSHOWPLAN, 0) +} + +func (s *Grant_permissionContext) SHUTDOWN() antlr.TerminalNode { + return s.GetToken(TSqlParserSHUTDOWN, 0) +} + +func (s *Grant_permissionContext) SUBSCRIBE() antlr.TerminalNode { + return s.GetToken(TSqlParserSUBSCRIBE, 0) +} + +func (s *Grant_permissionContext) QUERY() antlr.TerminalNode { + return s.GetToken(TSqlParserQUERY, 0) +} + +func (s *Grant_permissionContext) NOTIFICATIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserNOTIFICATIONS, 0) +} + +func (s *Grant_permissionContext) TAKE() antlr.TerminalNode { + return s.GetToken(TSqlParserTAKE, 0) +} + +func (s *Grant_permissionContext) OWNERSHIP() antlr.TerminalNode { + return s.GetToken(TSqlParserOWNERSHIP, 0) +} + +func (s *Grant_permissionContext) UNMASK() antlr.TerminalNode { + return s.GetToken(TSqlParserUNMASK, 0) +} + +func (s *Grant_permissionContext) UNSAFE() antlr.TerminalNode { + return s.GetToken(TSqlParserUNSAFE, 0) +} + +func (s *Grant_permissionContext) UPDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserUPDATE, 0) +} + +func (s *Grant_permissionContext) CHANGE() antlr.TerminalNode { + return s.GetToken(TSqlParserCHANGE, 0) +} + +func (s *Grant_permissionContext) TRACKING() antlr.TerminalNode { + return s.GetToken(TSqlParserTRACKING, 0) +} + +func (s *Grant_permissionContext) DEFINITION() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFINITION, 0) +} + +func (s *Grant_permissionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_permissionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_permissionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterGrant_permission(s) + } +} + +func (s *Grant_permissionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitGrant_permission(s) + } +} + +func (s *Grant_permissionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitGrant_permission(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Grant_permission() (localctx IGrant_permissionContext) { + localctx = NewGrant_permissionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 802, TSqlParserRULE_grant_permission) + var _la int + + p.SetState(10108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserADMINISTER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9895) + p.Match(TSqlParserADMINISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserBULK: + { + p.SetState(9896) + p.Match(TSqlParserBULK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9897) + p.Match(TSqlParserOPERATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDATABASE: + { + p.SetState(9898) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9899) + p.Match(TSqlParserBULK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9900) + p.Match(TSqlParserOPERATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserALTER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9903) + p.Match(TSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case TSqlParserANY: + { + p.SetState(9904) + p.Match(TSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAPPLICATION: + { + p.SetState(9905) + p.Match(TSqlParserAPPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9906) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserASSEMBLY: + { + p.SetState(9907) + p.Match(TSqlParserASSEMBLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserASYMMETRIC: + { + p.SetState(9908) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9909) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserAVAILABILITY: + { + p.SetState(9910) + p.Match(TSqlParserAVAILABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9911) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCERTIFICATE: + { + p.SetState(9912) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCOLUMN: + { + p.SetState(9913) + p.Match(TSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserENCRYPTION: + { + p.SetState(9914) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9915) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMASTER: + { + p.SetState(9916) + p.Match(TSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9917) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserCONNECTION: + { + p.SetState(9920) + p.Match(TSqlParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCONTRACT: + { + p.SetState(9921) + p.Match(TSqlParserCONTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCREDENTIAL: + { + p.SetState(9922) + p.Match(TSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDATABASE: + { + p.SetState(9923) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9931) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case TSqlParserAUDIT: + { + p.SetState(9924) + p.Match(TSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDDL: + { + p.SetState(9925) + p.Match(TSqlParserDDL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9926) + p.Match(TSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEVENT: + { + p.SetState(9927) + p.Match(TSqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9928) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNOTIFICATION || _la == TSqlParserSESSION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserSCOPED: + { + p.SetState(9929) + p.Match(TSqlParserSCOPED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9930) + p.Match(TSqlParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserON, TSqlParserTO, TSqlParserLR_BRACKET: + + default: + } + + case TSqlParserDATASPACE: + { + p.SetState(9933) + p.Match(TSqlParserDATASPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserENDPOINT: + { + p.SetState(9934) + p.Match(TSqlParserENDPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEVENT: + { + p.SetState(9935) + p.Match(TSqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9936) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNOTIFICATION || _la == TSqlParserSESSION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserEXTERNAL: + { + p.SetState(9937) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9943) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDATA: + { + p.SetState(9938) + p.Match(TSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9939) + p.Match(TSqlParserSOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserFILE: + { + p.SetState(9940) + p.Match(TSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9941) + p.Match(TSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserLIBRARY: + { + p.SetState(9942) + p.Match(TSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserFULLTEXT: + { + p.SetState(9945) + p.Match(TSqlParserFULLTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9946) + p.Match(TSqlParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserLINKED: + { + p.SetState(9947) + p.Match(TSqlParserLINKED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9948) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserLOGIN: + { + p.SetState(9949) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMASK: + { + p.SetState(9950) + p.Match(TSqlParserMASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMESSAGE: + { + p.SetState(9951) + p.Match(TSqlParserMESSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9952) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserREMOTE: + { + p.SetState(9953) + p.Match(TSqlParserREMOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9954) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9955) + p.Match(TSqlParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserROLE: + { + p.SetState(9956) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserROUTE: + { + p.SetState(9957) + p.Match(TSqlParserROUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSCHEMA: + { + p.SetState(9958) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSECURITY: + { + p.SetState(9959) + p.Match(TSqlParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9960) + p.Match(TSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSERVER: + { + p.SetState(9961) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9962) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAUDIT || _la == TSqlParserROLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserSERVICE: + { + p.SetState(9963) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSYMMETRIC: + { + p.SetState(9964) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9965) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserUSER: + { + p.SetState(9966) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserRESOURCES: + { + p.SetState(9969) + p.Match(TSqlParserRESOURCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSERVER: + { + p.SetState(9970) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9971) + p.Match(TSqlParserSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSETTINGS: + { + p.SetState(9972) + p.Match(TSqlParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTRACE: + { + p.SetState(9973) + p.Match(TSqlParserTRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserON, TSqlParserTO, TSqlParserLR_BRACKET: + + default: + } + + case TSqlParserAUTHENTICATE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9976) + p.Match(TSqlParserAUTHENTICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9978) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSERVER { + { + p.SetState(9977) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserBACKUP: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9980) + p.Match(TSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9981) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDATABASE || _la == TSqlParserLOG) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserCHECKPOINT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9982) + p.Match(TSqlParserCHECKPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCONNECT: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9983) + p.Match(TSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case TSqlParserANY: + { + p.SetState(9984) + p.Match(TSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9985) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserREPLICATION: + { + p.SetState(9986) + p.Match(TSqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSQL: + { + p.SetState(9987) + p.Match(TSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserON, TSqlParserTO, TSqlParserLR_BRACKET: + + default: + } + + case TSqlParserCONTROL: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(9990) + p.Match(TSqlParserCONTROL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSERVER { + { + p.SetState(9991) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserCREATE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(9994) + p.Match(TSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10048) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAGGREGATE: + { + p.SetState(9995) + p.Match(TSqlParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserANY: + { + p.SetState(9996) + p.Match(TSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9997) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserASSEMBLY: + { + p.SetState(9998) + p.Match(TSqlParserASSEMBLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserASYMMETRIC: + { + p.SetState(9999) + p.Match(TSqlParserASYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10000) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserAVAILABILITY: + { + p.SetState(10001) + p.Match(TSqlParserAVAILABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10002) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCERTIFICATE: + { + p.SetState(10003) + p.Match(TSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCONTRACT: + { + p.SetState(10004) + p.Match(TSqlParserCONTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDATABASE: + { + p.SetState(10005) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10009) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserDDL { + { + p.SetState(10006) + p.Match(TSqlParserDDL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10007) + p.Match(TSqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10008) + p.Match(TSqlParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserDDL: + { + p.SetState(10011) + p.Match(TSqlParserDDL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10012) + p.Match(TSqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10013) + p.Match(TSqlParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDEFAULT: + { + p.SetState(10014) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserENDPOINT: + { + p.SetState(10015) + p.Match(TSqlParserENDPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEXTERNAL: + { + p.SetState(10016) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10017) + p.Match(TSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserFULLTEXT: + { + p.SetState(10018) + p.Match(TSqlParserFULLTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10019) + p.Match(TSqlParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserFUNCTION: + { + p.SetState(10020) + p.Match(TSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMESSAGE: + { + p.SetState(10021) + p.Match(TSqlParserMESSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10022) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPROCEDURE: + { + p.SetState(10023) + p.Match(TSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserQUEUE: + { + p.SetState(10024) + p.Match(TSqlParserQUEUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserREMOTE: + { + p.SetState(10025) + p.Match(TSqlParserREMOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10026) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10027) + p.Match(TSqlParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserROLE: + { + p.SetState(10028) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserROUTE: + { + p.SetState(10029) + p.Match(TSqlParserROUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserRULE: + { + p.SetState(10030) + p.Match(TSqlParserRULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSCHEMA: + { + p.SetState(10031) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSEQUENCE: + { + p.SetState(10032) + p.Match(TSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSERVER: + { + p.SetState(10033) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10034) + p.Match(TSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSERVICE: + { + p.SetState(10035) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSYMMETRIC: + { + p.SetState(10036) + p.Match(TSqlParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10037) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSYNONYM: + { + p.SetState(10038) + p.Match(TSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTABLE: + { + p.SetState(10039) + p.Match(TSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTRACE: + { + p.SetState(10040) + p.Match(TSqlParserTRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10041) + p.Match(TSqlParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10042) + p.Match(TSqlParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTYPE: + { + p.SetState(10043) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserVIEW: + { + p.SetState(10044) + p.Match(TSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserXML: + { + p.SetState(10045) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10046) + p.Match(TSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10047) + p.Match(TSqlParserCOLLECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserDELETE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(10050) + p.Match(TSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEXECUTE: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(10051) + p.Match(TSqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10055) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserANY { + { + p.SetState(10052) + p.Match(TSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10053) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10054) + p.Match(TSqlParserSCRIPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserEXTERNAL: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(10057) + p.Match(TSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10058) + p.Match(TSqlParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10059) + p.Match(TSqlParserASSEMBLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserIMPERSONATE: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(10060) + p.Match(TSqlParserIMPERSONATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserANY { + { + p.SetState(10061) + p.Match(TSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10062) + p.Match(TSqlParserLOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserINSERT: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(10065) + p.Match(TSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserKILL: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(10066) + p.Match(TSqlParserKILL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10067) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10068) + p.Match(TSqlParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserRECEIVE: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(10069) + p.Match(TSqlParserRECEIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserREFERENCES: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(10070) + p.Match(TSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSELECT: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(10071) + p.Match(TSqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10075) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserALL { + { + p.SetState(10072) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10073) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10074) + p.Match(TSqlParserSECURABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserSEND: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(10077) + p.Match(TSqlParserSEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSHOWPLAN: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(10078) + p.Match(TSqlParserSHOWPLAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSHUTDOWN: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(10079) + p.Match(TSqlParserSHUTDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSUBSCRIBE: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(10080) + p.Match(TSqlParserSUBSCRIBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10081) + p.Match(TSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10082) + p.Match(TSqlParserNOTIFICATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTAKE: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(10083) + p.Match(TSqlParserTAKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10084) + p.Match(TSqlParserOWNERSHIP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserUNMASK: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(10085) + p.Match(TSqlParserUNMASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserUNSAFE: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(10086) + p.Match(TSqlParserUNSAFE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10087) + p.Match(TSqlParserASSEMBLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserUPDATE: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(10088) + p.Match(TSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserVIEW: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(10089) + p.Match(TSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10106) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserANY: + { + p.SetState(10090) + p.Match(TSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10097) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDATABASE: + { + p.SetState(10091) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDEFINITION: + { + p.SetState(10092) + p.Match(TSqlParserDEFINITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCOLUMN: + { + p.SetState(10093) + p.Match(TSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10094) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserENCRYPTION || _la == TSqlParserMASTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10095) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10096) + p.Match(TSqlParserDEFINITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserCHANGE: + { + p.SetState(10099) + p.Match(TSqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10100) + p.Match(TSqlParserTRACKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDATABASE: + { + p.SetState(10101) + p.Match(TSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10102) + p.Match(TSqlParserSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDEFINITION: + { + p.SetState(10103) + p.Match(TSqlParserDEFINITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSERVER: + { + p.SetState(10104) + p.Match(TSqlParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10105) + p.Match(TSqlParserSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_statementContext is an interface to support dynamic dispatch. +type ISet_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMember_name returns the member_name rule contexts. + GetMember_name() IId_Context + + // SetMember_name sets the member_name rule contexts. + SetMember_name(IId_Context) + + // Getter signatures + SET() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + EQUAL() antlr.TerminalNode + Expression() IExpressionContext + DOT() antlr.TerminalNode + Id_() IId_Context + Assignment_operator() IAssignment_operatorContext + CURSOR() antlr.TerminalNode + Declare_set_cursor_common() IDeclare_set_cursor_commonContext + FOR() antlr.TerminalNode + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + UPDATE() antlr.TerminalNode + OF() antlr.TerminalNode + Column_name_list() IColumn_name_listContext + Set_special() ISet_specialContext + + // IsSet_statementContext differentiates from other interfaces. + IsSet_statementContext() +} + +type Set_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + member_name IId_Context +} + +func NewEmptySet_statementContext() *Set_statementContext { + var p = new(Set_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_set_statement + return p +} + +func InitEmptySet_statementContext(p *Set_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_set_statement +} + +func (*Set_statementContext) IsSet_statementContext() {} + +func NewSet_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_statementContext { + var p = new(Set_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_set_statement + + return p +} + +func (s *Set_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_statementContext) GetMember_name() IId_Context { return s.member_name } + +func (s *Set_statementContext) SetMember_name(v IId_Context) { s.member_name = v } + +func (s *Set_statementContext) SET() antlr.TerminalNode { + return s.GetToken(TSqlParserSET, 0) +} + +func (s *Set_statementContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Set_statementContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Set_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Set_statementContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Set_statementContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Set_statementContext) Assignment_operator() IAssignment_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignment_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignment_operatorContext) +} + +func (s *Set_statementContext) CURSOR() antlr.TerminalNode { + return s.GetToken(TSqlParserCURSOR, 0) +} + +func (s *Set_statementContext) Declare_set_cursor_common() IDeclare_set_cursor_commonContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclare_set_cursor_commonContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeclare_set_cursor_commonContext) +} + +func (s *Set_statementContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Set_statementContext) READ() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD, 0) +} + +func (s *Set_statementContext) ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserONLY, 0) +} + +func (s *Set_statementContext) UPDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserUPDATE, 0) +} + +func (s *Set_statementContext) OF() antlr.TerminalNode { + return s.GetToken(TSqlParserOF, 0) +} + +func (s *Set_statementContext) Column_name_list() IColumn_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Set_statementContext) Set_special() ISet_specialContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_specialContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_specialContext) +} + +func (s *Set_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSet_statement(s) + } +} + +func (s *Set_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSet_statement(s) + } +} + +func (s *Set_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSet_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Set_statement() (localctx ISet_statementContext) { + localctx = NewSet_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 804, TSqlParserRULE_set_statement) + var _la int + + p.SetState(10141) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1346, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10110) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10111) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserDOT { + { + p.SetState(10112) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10113) + + var _x = p.Id_() + + localctx.(*Set_statementContext).member_name = _x + } + + } + { + p.SetState(10116) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10117) + p.expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10118) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10119) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10120) + p.Assignment_operator() + } + { + p.SetState(10121) + p.expression(0) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10123) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10124) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10125) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10126) + p.Match(TSqlParserCURSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10127) + p.Declare_set_cursor_common() + } + p.SetState(10138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR { + { + p.SetState(10128) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserREAD: + { + p.SetState(10129) + p.Match(TSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10130) + p.Match(TSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserUPDATE: + { + p.SetState(10131) + p.Match(TSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOF { + { + p.SetState(10132) + p.Match(TSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10133) + p.Column_name_list() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10140) + p.Set_special() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransaction_statementContext is an interface to support dynamic dispatch. +type ITransaction_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BEGIN() antlr.TerminalNode + DISTRIBUTED() antlr.TerminalNode + TRAN() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + Id_() IId_Context + LOCAL_ID() antlr.TerminalNode + WITH() antlr.TerminalNode + MARK() antlr.TerminalNode + STRING() antlr.TerminalNode + COMMIT() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + DELAYED_DURABILITY() antlr.TerminalNode + EQUAL() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + OFF() antlr.TerminalNode + ON() antlr.TerminalNode + WORK() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SAVE() antlr.TerminalNode + + // IsTransaction_statementContext differentiates from other interfaces. + IsTransaction_statementContext() +} + +type Transaction_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransaction_statementContext() *Transaction_statementContext { + var p = new(Transaction_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_transaction_statement + return p +} + +func InitEmptyTransaction_statementContext(p *Transaction_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_transaction_statement +} + +func (*Transaction_statementContext) IsTransaction_statementContext() {} + +func NewTransaction_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_statementContext { + var p = new(Transaction_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_transaction_statement + + return p +} + +func (s *Transaction_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Transaction_statementContext) BEGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserBEGIN, 0) +} + +func (s *Transaction_statementContext) DISTRIBUTED() antlr.TerminalNode { + return s.GetToken(TSqlParserDISTRIBUTED, 0) +} + +func (s *Transaction_statementContext) TRAN() antlr.TerminalNode { + return s.GetToken(TSqlParserTRAN, 0) +} + +func (s *Transaction_statementContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(TSqlParserTRANSACTION, 0) +} + +func (s *Transaction_statementContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Transaction_statementContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Transaction_statementContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Transaction_statementContext) MARK() antlr.TerminalNode { + return s.GetToken(TSqlParserMARK, 0) +} + +func (s *Transaction_statementContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Transaction_statementContext) COMMIT() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMIT, 0) +} + +func (s *Transaction_statementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Transaction_statementContext) DELAYED_DURABILITY() antlr.TerminalNode { + return s.GetToken(TSqlParserDELAYED_DURABILITY, 0) +} + +func (s *Transaction_statementContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Transaction_statementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Transaction_statementContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Transaction_statementContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Transaction_statementContext) WORK() antlr.TerminalNode { + return s.GetToken(TSqlParserWORK, 0) +} + +func (s *Transaction_statementContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(TSqlParserROLLBACK, 0) +} + +func (s *Transaction_statementContext) SAVE() antlr.TerminalNode { + return s.GetToken(TSqlParserSAVE, 0) +} + +func (s *Transaction_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Transaction_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Transaction_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTransaction_statement(s) + } +} + +func (s *Transaction_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTransaction_statement(s) + } +} + +func (s *Transaction_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTransaction_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Transaction_statement() (localctx ITransaction_statementContext) { + localctx = NewTransaction_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 806, TSqlParserRULE_transaction_statement) + var _la int + + p.SetState(10203) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1358, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10143) + p.Match(TSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10144) + p.Match(TSqlParserDISTRIBUTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10145) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserTRAN || _la == TSqlParserTRANSACTION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10148) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1347, p.GetParserRuleContext()) == 1 { + { + p.SetState(10146) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1347, p.GetParserRuleContext()) == 2 { + { + p.SetState(10147) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10150) + p.Match(TSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10151) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserTRAN || _la == TSqlParserTRANSACTION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10161) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1350, p.GetParserRuleContext()) == 1 { + p.SetState(10154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(10152) + p.Id_() + } + + case TSqlParserLOCAL_ID: + { + p.SetState(10153) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10159) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1349, p.GetParserRuleContext()) == 1 { + { + p.SetState(10156) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10157) + p.Match(TSqlParserMARK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10158) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10163) + p.Match(TSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10164) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserTRAN || _la == TSqlParserTRANSACTION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10177) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1353, p.GetParserRuleContext()) == 1 { + p.SetState(10167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(10165) + p.Id_() + } + + case TSqlParserLOCAL_ID: + { + p.SetState(10166) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10175) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1352, p.GetParserRuleContext()) == 1 { + { + p.SetState(10169) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10170) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10171) + p.Match(TSqlParserDELAYED_DURABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10172) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10173) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10174) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10179) + p.Match(TSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10181) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1354, p.GetParserRuleContext()) == 1 { + { + p.SetState(10180) + p.Match(TSqlParserWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10183) + p.Match(TSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10184) + p.Id_() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10185) + p.Match(TSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10186) + p.Id_() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(10187) + p.Match(TSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10188) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserTRAN || _la == TSqlParserTRANSACTION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10191) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1355, p.GetParserRuleContext()) == 1 { + { + p.SetState(10189) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1355, p.GetParserRuleContext()) == 2 { + { + p.SetState(10190) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(10193) + p.Match(TSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10195) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1356, p.GetParserRuleContext()) == 1 { + { + p.SetState(10194) + p.Match(TSqlParserWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(10197) + p.Match(TSqlParserSAVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10198) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserTRAN || _la == TSqlParserTRANSACTION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10201) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1357, p.GetParserRuleContext()) == 1 { + { + p.SetState(10199) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1357, p.GetParserRuleContext()) == 2 { + { + p.SetState(10200) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGo_statementContext is an interface to support dynamic dispatch. +type IGo_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCount returns the count token. + GetCount() antlr.Token + + // SetCount sets the count token. + SetCount(antlr.Token) + + // Getter signatures + GO() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + + // IsGo_statementContext differentiates from other interfaces. + IsGo_statementContext() +} + +type Go_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + count antlr.Token +} + +func NewEmptyGo_statementContext() *Go_statementContext { + var p = new(Go_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_go_statement + return p +} + +func InitEmptyGo_statementContext(p *Go_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_go_statement +} + +func (*Go_statementContext) IsGo_statementContext() {} + +func NewGo_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Go_statementContext { + var p = new(Go_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_go_statement + + return p +} + +func (s *Go_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Go_statementContext) GetCount() antlr.Token { return s.count } + +func (s *Go_statementContext) SetCount(v antlr.Token) { s.count = v } + +func (s *Go_statementContext) GO() antlr.TerminalNode { + return s.GetToken(TSqlParserGO, 0) +} + +func (s *Go_statementContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Go_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Go_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Go_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterGo_statement(s) + } +} + +func (s *Go_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitGo_statement(s) + } +} + +func (s *Go_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitGo_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Go_statement() (localctx IGo_statementContext) { + localctx = NewGo_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 808, TSqlParserRULE_go_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10205) + p.Match(TSqlParserGO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10207) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserDECIMAL { + { + p.SetState(10206) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Go_statementContext).count = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUse_statementContext is an interface to support dynamic dispatch. +type IUse_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatabase returns the database rule contexts. + GetDatabase() IId_Context + + // SetDatabase sets the database rule contexts. + SetDatabase(IId_Context) + + // Getter signatures + USE() antlr.TerminalNode + Id_() IId_Context + + // IsUse_statementContext differentiates from other interfaces. + IsUse_statementContext() +} + +type Use_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database IId_Context +} + +func NewEmptyUse_statementContext() *Use_statementContext { + var p = new(Use_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_use_statement + return p +} + +func InitEmptyUse_statementContext(p *Use_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_use_statement +} + +func (*Use_statementContext) IsUse_statementContext() {} + +func NewUse_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Use_statementContext { + var p = new(Use_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_use_statement + + return p +} + +func (s *Use_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Use_statementContext) GetDatabase() IId_Context { return s.database } + +func (s *Use_statementContext) SetDatabase(v IId_Context) { s.database = v } + +func (s *Use_statementContext) USE() antlr.TerminalNode { + return s.GetToken(TSqlParserUSE, 0) +} + +func (s *Use_statementContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Use_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Use_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Use_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUse_statement(s) + } +} + +func (s *Use_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUse_statement(s) + } +} + +func (s *Use_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUse_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Use_statement() (localctx IUse_statementContext) { + localctx = NewUse_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 810, TSqlParserRULE_use_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10209) + p.Match(TSqlParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10210) + + var _x = p.Id_() + + localctx.(*Use_statementContext).database = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISetuser_statementContext is an interface to support dynamic dispatch. +type ISetuser_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUser returns the user token. + GetUser() antlr.Token + + // SetUser sets the user token. + SetUser(antlr.Token) + + // Getter signatures + SETUSER() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsSetuser_statementContext differentiates from other interfaces. + IsSetuser_statementContext() +} + +type Setuser_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + user antlr.Token +} + +func NewEmptySetuser_statementContext() *Setuser_statementContext { + var p = new(Setuser_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_setuser_statement + return p +} + +func InitEmptySetuser_statementContext(p *Setuser_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_setuser_statement +} + +func (*Setuser_statementContext) IsSetuser_statementContext() {} + +func NewSetuser_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Setuser_statementContext { + var p = new(Setuser_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_setuser_statement + + return p +} + +func (s *Setuser_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Setuser_statementContext) GetUser() antlr.Token { return s.user } + +func (s *Setuser_statementContext) SetUser(v antlr.Token) { s.user = v } + +func (s *Setuser_statementContext) SETUSER() antlr.TerminalNode { + return s.GetToken(TSqlParserSETUSER, 0) +} + +func (s *Setuser_statementContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Setuser_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Setuser_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Setuser_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSetuser_statement(s) + } +} + +func (s *Setuser_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSetuser_statement(s) + } +} + +func (s *Setuser_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSetuser_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Setuser_statement() (localctx ISetuser_statementContext) { + localctx = NewSetuser_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 812, TSqlParserRULE_setuser_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10212) + p.Match(TSqlParserSETUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10214) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSTRING { + { + p.SetState(10213) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Setuser_statementContext).user = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReconfigure_statementContext is an interface to support dynamic dispatch. +type IReconfigure_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECONFIGURE() antlr.TerminalNode + WITH() antlr.TerminalNode + OVERRIDE() antlr.TerminalNode + + // IsReconfigure_statementContext differentiates from other interfaces. + IsReconfigure_statementContext() +} + +type Reconfigure_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReconfigure_statementContext() *Reconfigure_statementContext { + var p = new(Reconfigure_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_reconfigure_statement + return p +} + +func InitEmptyReconfigure_statementContext(p *Reconfigure_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_reconfigure_statement +} + +func (*Reconfigure_statementContext) IsReconfigure_statementContext() {} + +func NewReconfigure_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reconfigure_statementContext { + var p = new(Reconfigure_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_reconfigure_statement + + return p +} + +func (s *Reconfigure_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reconfigure_statementContext) RECONFIGURE() antlr.TerminalNode { + return s.GetToken(TSqlParserRECONFIGURE, 0) +} + +func (s *Reconfigure_statementContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Reconfigure_statementContext) OVERRIDE() antlr.TerminalNode { + return s.GetToken(TSqlParserOVERRIDE, 0) +} + +func (s *Reconfigure_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reconfigure_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reconfigure_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterReconfigure_statement(s) + } +} + +func (s *Reconfigure_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitReconfigure_statement(s) + } +} + +func (s *Reconfigure_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitReconfigure_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Reconfigure_statement() (localctx IReconfigure_statementContext) { + localctx = NewReconfigure_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 814, TSqlParserRULE_reconfigure_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10216) + p.Match(TSqlParserRECONFIGURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10219) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1361, p.GetParserRuleContext()) == 1 { + { + p.SetState(10217) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10218) + p.Match(TSqlParserOVERRIDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShutdown_statementContext is an interface to support dynamic dispatch. +type IShutdown_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHUTDOWN() antlr.TerminalNode + WITH() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + + // IsShutdown_statementContext differentiates from other interfaces. + IsShutdown_statementContext() +} + +type Shutdown_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShutdown_statementContext() *Shutdown_statementContext { + var p = new(Shutdown_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_shutdown_statement + return p +} + +func InitEmptyShutdown_statementContext(p *Shutdown_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_shutdown_statement +} + +func (*Shutdown_statementContext) IsShutdown_statementContext() {} + +func NewShutdown_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Shutdown_statementContext { + var p = new(Shutdown_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_shutdown_statement + + return p +} + +func (s *Shutdown_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Shutdown_statementContext) SHUTDOWN() antlr.TerminalNode { + return s.GetToken(TSqlParserSHUTDOWN, 0) +} + +func (s *Shutdown_statementContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Shutdown_statementContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOWAIT, 0) +} + +func (s *Shutdown_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Shutdown_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Shutdown_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterShutdown_statement(s) + } +} + +func (s *Shutdown_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitShutdown_statement(s) + } +} + +func (s *Shutdown_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitShutdown_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Shutdown_statement() (localctx IShutdown_statementContext) { + localctx = NewShutdown_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 816, TSqlParserRULE_shutdown_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10221) + p.Match(TSqlParserSHUTDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10224) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1362, p.GetParserRuleContext()) == 1 { + { + p.SetState(10222) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10223) + p.Match(TSqlParserNOWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICheckpoint_statementContext is an interface to support dynamic dispatch. +type ICheckpoint_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCheckPointDuration returns the checkPointDuration token. + GetCheckPointDuration() antlr.Token + + // SetCheckPointDuration sets the checkPointDuration token. + SetCheckPointDuration(antlr.Token) + + // Getter signatures + CHECKPOINT() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + + // IsCheckpoint_statementContext differentiates from other interfaces. + IsCheckpoint_statementContext() +} + +type Checkpoint_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + checkPointDuration antlr.Token +} + +func NewEmptyCheckpoint_statementContext() *Checkpoint_statementContext { + var p = new(Checkpoint_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_checkpoint_statement + return p +} + +func InitEmptyCheckpoint_statementContext(p *Checkpoint_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_checkpoint_statement +} + +func (*Checkpoint_statementContext) IsCheckpoint_statementContext() {} + +func NewCheckpoint_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Checkpoint_statementContext { + var p = new(Checkpoint_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_checkpoint_statement + + return p +} + +func (s *Checkpoint_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Checkpoint_statementContext) GetCheckPointDuration() antlr.Token { + return s.checkPointDuration +} + +func (s *Checkpoint_statementContext) SetCheckPointDuration(v antlr.Token) { s.checkPointDuration = v } + +func (s *Checkpoint_statementContext) CHECKPOINT() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKPOINT, 0) +} + +func (s *Checkpoint_statementContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Checkpoint_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Checkpoint_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Checkpoint_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCheckpoint_statement(s) + } +} + +func (s *Checkpoint_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCheckpoint_statement(s) + } +} + +func (s *Checkpoint_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCheckpoint_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Checkpoint_statement() (localctx ICheckpoint_statementContext) { + localctx = NewCheckpoint_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 818, TSqlParserRULE_checkpoint_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10226) + p.Match(TSqlParserCHECKPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserDECIMAL { + { + p.SetState(10227) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Checkpoint_statementContext).checkPointDuration = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_checkalloc_optionContext is an interface to support dynamic dispatch. +type IDbcc_checkalloc_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL_ERRORMSGS() antlr.TerminalNode + NO_INFOMSGS() antlr.TerminalNode + TABLOCK() antlr.TerminalNode + ESTIMATEONLY() antlr.TerminalNode + + // IsDbcc_checkalloc_optionContext differentiates from other interfaces. + IsDbcc_checkalloc_optionContext() +} + +type Dbcc_checkalloc_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDbcc_checkalloc_optionContext() *Dbcc_checkalloc_optionContext { + var p = new(Dbcc_checkalloc_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkalloc_option + return p +} + +func InitEmptyDbcc_checkalloc_optionContext(p *Dbcc_checkalloc_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkalloc_option +} + +func (*Dbcc_checkalloc_optionContext) IsDbcc_checkalloc_optionContext() {} + +func NewDbcc_checkalloc_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_checkalloc_optionContext { + var p = new(Dbcc_checkalloc_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_checkalloc_option + + return p +} + +func (s *Dbcc_checkalloc_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_checkalloc_optionContext) ALL_ERRORMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserALL_ERRORMSGS, 0) +} + +func (s *Dbcc_checkalloc_optionContext) NO_INFOMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_INFOMSGS, 0) +} + +func (s *Dbcc_checkalloc_optionContext) TABLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLOCK, 0) +} + +func (s *Dbcc_checkalloc_optionContext) ESTIMATEONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserESTIMATEONLY, 0) +} + +func (s *Dbcc_checkalloc_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_checkalloc_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_checkalloc_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_checkalloc_option(s) + } +} + +func (s *Dbcc_checkalloc_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_checkalloc_option(s) + } +} + +func (s *Dbcc_checkalloc_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_checkalloc_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_checkalloc_option() (localctx IDbcc_checkalloc_optionContext) { + localctx = NewDbcc_checkalloc_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 820, TSqlParserRULE_dbcc_checkalloc_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10230) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALL_ERRORMSGS || _la == TSqlParserESTIMATEONLY || _la == TSqlParserNO_INFOMSGS || _la == TSqlParserTABLOCK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_checkallocContext is an interface to support dynamic dispatch. +type IDbcc_checkallocContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // GetDatabaseid returns the databaseid token. + GetDatabaseid() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // SetDatabaseid sets the databaseid token. + SetDatabaseid(antlr.Token) + + // GetDatabase returns the database rule contexts. + GetDatabase() IId_Context + + // GetDbcc_option returns the dbcc_option rule contexts. + GetDbcc_option() IDbcc_checkalloc_optionContext + + // SetDatabase sets the database rule contexts. + SetDatabase(IId_Context) + + // SetDbcc_option sets the dbcc_option rule contexts. + SetDbcc_option(IDbcc_checkalloc_optionContext) + + // Getter signatures + CHECKALLOC() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + Id_() IId_Context + STRING() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + NOINDEX() antlr.TerminalNode + WITH() antlr.TerminalNode + REPAIR_ALLOW_DATA_LOSS() antlr.TerminalNode + REPAIR_FAST() antlr.TerminalNode + REPAIR_REBUILD() antlr.TerminalNode + AllDbcc_checkalloc_option() []IDbcc_checkalloc_optionContext + Dbcc_checkalloc_option(i int) IDbcc_checkalloc_optionContext + + // IsDbcc_checkallocContext differentiates from other interfaces. + IsDbcc_checkallocContext() +} + +type Dbcc_checkallocContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + database IId_Context + databaseid antlr.Token + dbcc_option IDbcc_checkalloc_optionContext +} + +func NewEmptyDbcc_checkallocContext() *Dbcc_checkallocContext { + var p = new(Dbcc_checkallocContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkalloc + return p +} + +func InitEmptyDbcc_checkallocContext(p *Dbcc_checkallocContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkalloc +} + +func (*Dbcc_checkallocContext) IsDbcc_checkallocContext() {} + +func NewDbcc_checkallocContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_checkallocContext { + var p = new(Dbcc_checkallocContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_checkalloc + + return p +} + +func (s *Dbcc_checkallocContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_checkallocContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_checkallocContext) GetDatabaseid() antlr.Token { return s.databaseid } + +func (s *Dbcc_checkallocContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_checkallocContext) SetDatabaseid(v antlr.Token) { s.databaseid = v } + +func (s *Dbcc_checkallocContext) GetDatabase() IId_Context { return s.database } + +func (s *Dbcc_checkallocContext) GetDbcc_option() IDbcc_checkalloc_optionContext { + return s.dbcc_option +} + +func (s *Dbcc_checkallocContext) SetDatabase(v IId_Context) { s.database = v } + +func (s *Dbcc_checkallocContext) SetDbcc_option(v IDbcc_checkalloc_optionContext) { s.dbcc_option = v } + +func (s *Dbcc_checkallocContext) CHECKALLOC() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKALLOC, 0) +} + +func (s *Dbcc_checkallocContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_checkallocContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_checkallocContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Dbcc_checkallocContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Dbcc_checkallocContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Dbcc_checkallocContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Dbcc_checkallocContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Dbcc_checkallocContext) NOINDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserNOINDEX, 0) +} + +func (s *Dbcc_checkallocContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_checkallocContext) REPAIR_ALLOW_DATA_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_ALLOW_DATA_LOSS, 0) +} + +func (s *Dbcc_checkallocContext) REPAIR_FAST() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_FAST, 0) +} + +func (s *Dbcc_checkallocContext) REPAIR_REBUILD() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_REBUILD, 0) +} + +func (s *Dbcc_checkallocContext) AllDbcc_checkalloc_option() []IDbcc_checkalloc_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDbcc_checkalloc_optionContext); ok { + len++ + } + } + + tst := make([]IDbcc_checkalloc_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDbcc_checkalloc_optionContext); ok { + tst[i] = t.(IDbcc_checkalloc_optionContext) + i++ + } + } + + return tst +} + +func (s *Dbcc_checkallocContext) Dbcc_checkalloc_option(i int) IDbcc_checkalloc_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_checkalloc_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_checkalloc_optionContext) +} + +func (s *Dbcc_checkallocContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_checkallocContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_checkallocContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_checkalloc(s) + } +} + +func (s *Dbcc_checkallocContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_checkalloc(s) + } +} + +func (s *Dbcc_checkallocContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_checkalloc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_checkalloc() (localctx IDbcc_checkallocContext) { + localctx = NewDbcc_checkallocContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 822, TSqlParserRULE_dbcc_checkalloc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10232) + + var _m = p.Match(TSqlParserCHECKALLOC) + + localctx.(*Dbcc_checkallocContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10257) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1368, p.GetParserRuleContext()) == 1 { + { + p.SetState(10233) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(10234) + + var _x = p.Id_() + + localctx.(*Dbcc_checkallocContext).database = _x + } + + case TSqlParserSTRING: + { + p.SetState(10235) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Dbcc_checkallocContext).databaseid = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL: + { + p.SetState(10236) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10243) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1365, p.GetParserRuleContext()) == 1 { + { + p.SetState(10239) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10240) + p.Match(TSqlParserNOINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1365, p.GetParserRuleContext()) == 2 { + { + p.SetState(10241) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10242) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-796)) & ^0x3f) == 0 && ((int64(1)<<(_la-796))&7) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10245) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10255) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1367, p.GetParserRuleContext()) == 1 { + { + p.SetState(10246) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10247) + + var _x = p.Dbcc_checkalloc_option() + + localctx.(*Dbcc_checkallocContext).dbcc_option = _x + } + p.SetState(10252) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(10248) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10249) + + var _x = p.Dbcc_checkalloc_option() + + localctx.(*Dbcc_checkallocContext).dbcc_option = _x + } + + p.SetState(10254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_checkcatalogContext is an interface to support dynamic dispatch. +type IDbcc_checkcatalogContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // GetDatabasename returns the databasename token. + GetDatabasename() antlr.Token + + // GetDbcc_option returns the dbcc_option token. + GetDbcc_option() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // SetDatabasename sets the databasename token. + SetDatabasename(antlr.Token) + + // SetDbcc_option sets the dbcc_option token. + SetDbcc_option(antlr.Token) + + // GetDatabase returns the database rule contexts. + GetDatabase() IId_Context + + // SetDatabase sets the database rule contexts. + SetDatabase(IId_Context) + + // Getter signatures + CHECKCATALOG() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + WITH() antlr.TerminalNode + NO_INFOMSGS() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + Id_() IId_Context + STRING() antlr.TerminalNode + + // IsDbcc_checkcatalogContext differentiates from other interfaces. + IsDbcc_checkcatalogContext() +} + +type Dbcc_checkcatalogContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + database IId_Context + databasename antlr.Token + dbcc_option antlr.Token +} + +func NewEmptyDbcc_checkcatalogContext() *Dbcc_checkcatalogContext { + var p = new(Dbcc_checkcatalogContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkcatalog + return p +} + +func InitEmptyDbcc_checkcatalogContext(p *Dbcc_checkcatalogContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkcatalog +} + +func (*Dbcc_checkcatalogContext) IsDbcc_checkcatalogContext() {} + +func NewDbcc_checkcatalogContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_checkcatalogContext { + var p = new(Dbcc_checkcatalogContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_checkcatalog + + return p +} + +func (s *Dbcc_checkcatalogContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_checkcatalogContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_checkcatalogContext) GetDatabasename() antlr.Token { return s.databasename } + +func (s *Dbcc_checkcatalogContext) GetDbcc_option() antlr.Token { return s.dbcc_option } + +func (s *Dbcc_checkcatalogContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_checkcatalogContext) SetDatabasename(v antlr.Token) { s.databasename = v } + +func (s *Dbcc_checkcatalogContext) SetDbcc_option(v antlr.Token) { s.dbcc_option = v } + +func (s *Dbcc_checkcatalogContext) GetDatabase() IId_Context { return s.database } + +func (s *Dbcc_checkcatalogContext) SetDatabase(v IId_Context) { s.database = v } + +func (s *Dbcc_checkcatalogContext) CHECKCATALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKCATALOG, 0) +} + +func (s *Dbcc_checkcatalogContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_checkcatalogContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_checkcatalogContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_checkcatalogContext) NO_INFOMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_INFOMSGS, 0) +} + +func (s *Dbcc_checkcatalogContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Dbcc_checkcatalogContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Dbcc_checkcatalogContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Dbcc_checkcatalogContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_checkcatalogContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_checkcatalogContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_checkcatalog(s) + } +} + +func (s *Dbcc_checkcatalogContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_checkcatalog(s) + } +} + +func (s *Dbcc_checkcatalogContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_checkcatalog(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_checkcatalog() (localctx IDbcc_checkcatalogContext) { + localctx = NewDbcc_checkcatalogContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 824, TSqlParserRULE_dbcc_checkcatalog) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10259) + + var _m = p.Match(TSqlParserCHECKCATALOG) + + localctx.(*Dbcc_checkcatalogContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10267) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1370, p.GetParserRuleContext()) == 1 { + { + p.SetState(10260) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10264) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(10261) + + var _x = p.Id_() + + localctx.(*Dbcc_checkcatalogContext).database = _x + } + + case TSqlParserSTRING: + { + p.SetState(10262) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Dbcc_checkcatalogContext).databasename = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL: + { + p.SetState(10263) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(10266) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10271) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1371, p.GetParserRuleContext()) == 1 { + { + p.SetState(10269) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10270) + + var _m = p.Match(TSqlParserNO_INFOMSGS) + + localctx.(*Dbcc_checkcatalogContext).dbcc_option = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_checkconstraints_optionContext is an interface to support dynamic dispatch. +type IDbcc_checkconstraints_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL_CONSTRAINTS() antlr.TerminalNode + ALL_ERRORMSGS() antlr.TerminalNode + NO_INFOMSGS() antlr.TerminalNode + + // IsDbcc_checkconstraints_optionContext differentiates from other interfaces. + IsDbcc_checkconstraints_optionContext() +} + +type Dbcc_checkconstraints_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDbcc_checkconstraints_optionContext() *Dbcc_checkconstraints_optionContext { + var p = new(Dbcc_checkconstraints_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkconstraints_option + return p +} + +func InitEmptyDbcc_checkconstraints_optionContext(p *Dbcc_checkconstraints_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkconstraints_option +} + +func (*Dbcc_checkconstraints_optionContext) IsDbcc_checkconstraints_optionContext() {} + +func NewDbcc_checkconstraints_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_checkconstraints_optionContext { + var p = new(Dbcc_checkconstraints_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_checkconstraints_option + + return p +} + +func (s *Dbcc_checkconstraints_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_checkconstraints_optionContext) ALL_CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(TSqlParserALL_CONSTRAINTS, 0) +} + +func (s *Dbcc_checkconstraints_optionContext) ALL_ERRORMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserALL_ERRORMSGS, 0) +} + +func (s *Dbcc_checkconstraints_optionContext) NO_INFOMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_INFOMSGS, 0) +} + +func (s *Dbcc_checkconstraints_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_checkconstraints_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_checkconstraints_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_checkconstraints_option(s) + } +} + +func (s *Dbcc_checkconstraints_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_checkconstraints_option(s) + } +} + +func (s *Dbcc_checkconstraints_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_checkconstraints_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_checkconstraints_option() (localctx IDbcc_checkconstraints_optionContext) { + localctx = NewDbcc_checkconstraints_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 826, TSqlParserRULE_dbcc_checkconstraints_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10273) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALL_CONSTRAINTS || _la == TSqlParserALL_ERRORMSGS || _la == TSqlParserNO_INFOMSGS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_checkconstraintsContext is an interface to support dynamic dispatch. +type IDbcc_checkconstraintsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // GetTable_or_constraint_name returns the table_or_constraint_name token. + GetTable_or_constraint_name() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // SetTable_or_constraint_name sets the table_or_constraint_name token. + SetTable_or_constraint_name(antlr.Token) + + // GetTable_or_constraint returns the table_or_constraint rule contexts. + GetTable_or_constraint() IId_Context + + // GetDbcc_option returns the dbcc_option rule contexts. + GetDbcc_option() IDbcc_checkconstraints_optionContext + + // SetTable_or_constraint sets the table_or_constraint rule contexts. + SetTable_or_constraint(IId_Context) + + // SetDbcc_option sets the dbcc_option rule contexts. + SetDbcc_option(IDbcc_checkconstraints_optionContext) + + // Getter signatures + CHECKCONSTRAINTS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + WITH() antlr.TerminalNode + AllDbcc_checkconstraints_option() []IDbcc_checkconstraints_optionContext + Dbcc_checkconstraints_option(i int) IDbcc_checkconstraints_optionContext + Id_() IId_Context + STRING() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDbcc_checkconstraintsContext differentiates from other interfaces. + IsDbcc_checkconstraintsContext() +} + +type Dbcc_checkconstraintsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + table_or_constraint IId_Context + table_or_constraint_name antlr.Token + dbcc_option IDbcc_checkconstraints_optionContext +} + +func NewEmptyDbcc_checkconstraintsContext() *Dbcc_checkconstraintsContext { + var p = new(Dbcc_checkconstraintsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkconstraints + return p +} + +func InitEmptyDbcc_checkconstraintsContext(p *Dbcc_checkconstraintsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkconstraints +} + +func (*Dbcc_checkconstraintsContext) IsDbcc_checkconstraintsContext() {} + +func NewDbcc_checkconstraintsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_checkconstraintsContext { + var p = new(Dbcc_checkconstraintsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_checkconstraints + + return p +} + +func (s *Dbcc_checkconstraintsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_checkconstraintsContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_checkconstraintsContext) GetTable_or_constraint_name() antlr.Token { + return s.table_or_constraint_name +} + +func (s *Dbcc_checkconstraintsContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_checkconstraintsContext) SetTable_or_constraint_name(v antlr.Token) { + s.table_or_constraint_name = v +} + +func (s *Dbcc_checkconstraintsContext) GetTable_or_constraint() IId_Context { + return s.table_or_constraint +} + +func (s *Dbcc_checkconstraintsContext) GetDbcc_option() IDbcc_checkconstraints_optionContext { + return s.dbcc_option +} + +func (s *Dbcc_checkconstraintsContext) SetTable_or_constraint(v IId_Context) { + s.table_or_constraint = v +} + +func (s *Dbcc_checkconstraintsContext) SetDbcc_option(v IDbcc_checkconstraints_optionContext) { + s.dbcc_option = v +} + +func (s *Dbcc_checkconstraintsContext) CHECKCONSTRAINTS() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKCONSTRAINTS, 0) +} + +func (s *Dbcc_checkconstraintsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_checkconstraintsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_checkconstraintsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_checkconstraintsContext) AllDbcc_checkconstraints_option() []IDbcc_checkconstraints_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDbcc_checkconstraints_optionContext); ok { + len++ + } + } + + tst := make([]IDbcc_checkconstraints_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDbcc_checkconstraints_optionContext); ok { + tst[i] = t.(IDbcc_checkconstraints_optionContext) + i++ + } + } + + return tst +} + +func (s *Dbcc_checkconstraintsContext) Dbcc_checkconstraints_option(i int) IDbcc_checkconstraints_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_checkconstraints_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_checkconstraints_optionContext) +} + +func (s *Dbcc_checkconstraintsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Dbcc_checkconstraintsContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Dbcc_checkconstraintsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Dbcc_checkconstraintsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Dbcc_checkconstraintsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_checkconstraintsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_checkconstraintsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_checkconstraints(s) + } +} + +func (s *Dbcc_checkconstraintsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_checkconstraints(s) + } +} + +func (s *Dbcc_checkconstraintsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_checkconstraints(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_checkconstraints() (localctx IDbcc_checkconstraintsContext) { + localctx = NewDbcc_checkconstraintsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 828, TSqlParserRULE_dbcc_checkconstraints) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10275) + + var _m = p.Match(TSqlParserCHECKCONSTRAINTS) + + localctx.(*Dbcc_checkconstraintsContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10282) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1373, p.GetParserRuleContext()) == 1 { + { + p.SetState(10276) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(10277) + + var _x = p.Id_() + + localctx.(*Dbcc_checkconstraintsContext).table_or_constraint = _x + } + + case TSqlParserSTRING: + { + p.SetState(10278) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Dbcc_checkconstraintsContext).table_or_constraint_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(10281) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10293) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1375, p.GetParserRuleContext()) == 1 { + { + p.SetState(10284) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10285) + + var _x = p.Dbcc_checkconstraints_option() + + localctx.(*Dbcc_checkconstraintsContext).dbcc_option = _x + } + p.SetState(10290) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(10286) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10287) + + var _x = p.Dbcc_checkconstraints_option() + + localctx.(*Dbcc_checkconstraintsContext).dbcc_option = _x + } + + p.SetState(10292) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_checkdb_table_optionContext is an interface to support dynamic dispatch. +type IDbcc_checkdb_table_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMax_dregree_of_parallelism returns the max_dregree_of_parallelism token. + GetMax_dregree_of_parallelism() antlr.Token + + // SetMax_dregree_of_parallelism sets the max_dregree_of_parallelism token. + SetMax_dregree_of_parallelism(antlr.Token) + + // Getter signatures + ALL_ERRORMSGS() antlr.TerminalNode + EXTENDED_LOGICAL_CHECKS() antlr.TerminalNode + NO_INFOMSGS() antlr.TerminalNode + TABLOCK() antlr.TerminalNode + ESTIMATEONLY() antlr.TerminalNode + PHYSICAL_ONLY() antlr.TerminalNode + DATA_PURITY() antlr.TerminalNode + MAXDOP() antlr.TerminalNode + EQUAL() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + + // IsDbcc_checkdb_table_optionContext differentiates from other interfaces. + IsDbcc_checkdb_table_optionContext() +} + +type Dbcc_checkdb_table_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + max_dregree_of_parallelism antlr.Token +} + +func NewEmptyDbcc_checkdb_table_optionContext() *Dbcc_checkdb_table_optionContext { + var p = new(Dbcc_checkdb_table_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkdb_table_option + return p +} + +func InitEmptyDbcc_checkdb_table_optionContext(p *Dbcc_checkdb_table_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkdb_table_option +} + +func (*Dbcc_checkdb_table_optionContext) IsDbcc_checkdb_table_optionContext() {} + +func NewDbcc_checkdb_table_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_checkdb_table_optionContext { + var p = new(Dbcc_checkdb_table_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_checkdb_table_option + + return p +} + +func (s *Dbcc_checkdb_table_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_checkdb_table_optionContext) GetMax_dregree_of_parallelism() antlr.Token { + return s.max_dregree_of_parallelism +} + +func (s *Dbcc_checkdb_table_optionContext) SetMax_dregree_of_parallelism(v antlr.Token) { + s.max_dregree_of_parallelism = v +} + +func (s *Dbcc_checkdb_table_optionContext) ALL_ERRORMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserALL_ERRORMSGS, 0) +} + +func (s *Dbcc_checkdb_table_optionContext) EXTENDED_LOGICAL_CHECKS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTENDED_LOGICAL_CHECKS, 0) +} + +func (s *Dbcc_checkdb_table_optionContext) NO_INFOMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_INFOMSGS, 0) +} + +func (s *Dbcc_checkdb_table_optionContext) TABLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLOCK, 0) +} + +func (s *Dbcc_checkdb_table_optionContext) ESTIMATEONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserESTIMATEONLY, 0) +} + +func (s *Dbcc_checkdb_table_optionContext) PHYSICAL_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserPHYSICAL_ONLY, 0) +} + +func (s *Dbcc_checkdb_table_optionContext) DATA_PURITY() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA_PURITY, 0) +} + +func (s *Dbcc_checkdb_table_optionContext) MAXDOP() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXDOP, 0) +} + +func (s *Dbcc_checkdb_table_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Dbcc_checkdb_table_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Dbcc_checkdb_table_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_checkdb_table_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_checkdb_table_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_checkdb_table_option(s) + } +} + +func (s *Dbcc_checkdb_table_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_checkdb_table_option(s) + } +} + +func (s *Dbcc_checkdb_table_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_checkdb_table_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_checkdb_table_option() (localctx IDbcc_checkdb_table_optionContext) { + localctx = NewDbcc_checkdb_table_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 830, TSqlParserRULE_dbcc_checkdb_table_option) + p.SetState(10305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALL_ERRORMSGS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10295) + p.Match(TSqlParserALL_ERRORMSGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEXTENDED_LOGICAL_CHECKS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10296) + p.Match(TSqlParserEXTENDED_LOGICAL_CHECKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNO_INFOMSGS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10297) + p.Match(TSqlParserNO_INFOMSGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTABLOCK: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10298) + p.Match(TSqlParserTABLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserESTIMATEONLY: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10299) + p.Match(TSqlParserESTIMATEONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPHYSICAL_ONLY: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10300) + p.Match(TSqlParserPHYSICAL_ONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDATA_PURITY: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(10301) + p.Match(TSqlParserDATA_PURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMAXDOP: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(10302) + p.Match(TSqlParserMAXDOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10303) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10304) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Dbcc_checkdb_table_optionContext).max_dregree_of_parallelism = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_checkdbContext is an interface to support dynamic dispatch. +type IDbcc_checkdbContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // GetDatabasename returns the databasename token. + GetDatabasename() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // SetDatabasename sets the databasename token. + SetDatabasename(antlr.Token) + + // GetDatabase returns the database rule contexts. + GetDatabase() IId_Context + + // GetDbcc_option returns the dbcc_option rule contexts. + GetDbcc_option() IDbcc_checkdb_table_optionContext + + // SetDatabase sets the database rule contexts. + SetDatabase(IId_Context) + + // SetDbcc_option sets the dbcc_option rule contexts. + SetDbcc_option(IDbcc_checkdb_table_optionContext) + + // Getter signatures + CHECKDB() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + WITH() antlr.TerminalNode + AllDbcc_checkdb_table_option() []IDbcc_checkdb_table_optionContext + Dbcc_checkdb_table_option(i int) IDbcc_checkdb_table_optionContext + DECIMAL() antlr.TerminalNode + Id_() IId_Context + STRING() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + NOINDEX() antlr.TerminalNode + REPAIR_ALLOW_DATA_LOSS() antlr.TerminalNode + REPAIR_FAST() antlr.TerminalNode + REPAIR_REBUILD() antlr.TerminalNode + + // IsDbcc_checkdbContext differentiates from other interfaces. + IsDbcc_checkdbContext() +} + +type Dbcc_checkdbContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + database IId_Context + databasename antlr.Token + dbcc_option IDbcc_checkdb_table_optionContext +} + +func NewEmptyDbcc_checkdbContext() *Dbcc_checkdbContext { + var p = new(Dbcc_checkdbContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkdb + return p +} + +func InitEmptyDbcc_checkdbContext(p *Dbcc_checkdbContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkdb +} + +func (*Dbcc_checkdbContext) IsDbcc_checkdbContext() {} + +func NewDbcc_checkdbContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_checkdbContext { + var p = new(Dbcc_checkdbContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_checkdb + + return p +} + +func (s *Dbcc_checkdbContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_checkdbContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_checkdbContext) GetDatabasename() antlr.Token { return s.databasename } + +func (s *Dbcc_checkdbContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_checkdbContext) SetDatabasename(v antlr.Token) { s.databasename = v } + +func (s *Dbcc_checkdbContext) GetDatabase() IId_Context { return s.database } + +func (s *Dbcc_checkdbContext) GetDbcc_option() IDbcc_checkdb_table_optionContext { + return s.dbcc_option +} + +func (s *Dbcc_checkdbContext) SetDatabase(v IId_Context) { s.database = v } + +func (s *Dbcc_checkdbContext) SetDbcc_option(v IDbcc_checkdb_table_optionContext) { s.dbcc_option = v } + +func (s *Dbcc_checkdbContext) CHECKDB() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKDB, 0) +} + +func (s *Dbcc_checkdbContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_checkdbContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_checkdbContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_checkdbContext) AllDbcc_checkdb_table_option() []IDbcc_checkdb_table_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDbcc_checkdb_table_optionContext); ok { + len++ + } + } + + tst := make([]IDbcc_checkdb_table_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDbcc_checkdb_table_optionContext); ok { + tst[i] = t.(IDbcc_checkdb_table_optionContext) + i++ + } + } + + return tst +} + +func (s *Dbcc_checkdbContext) Dbcc_checkdb_table_option(i int) IDbcc_checkdb_table_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_checkdb_table_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_checkdb_table_optionContext) +} + +func (s *Dbcc_checkdbContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Dbcc_checkdbContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Dbcc_checkdbContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Dbcc_checkdbContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Dbcc_checkdbContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Dbcc_checkdbContext) NOINDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserNOINDEX, 0) +} + +func (s *Dbcc_checkdbContext) REPAIR_ALLOW_DATA_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_ALLOW_DATA_LOSS, 0) +} + +func (s *Dbcc_checkdbContext) REPAIR_FAST() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_FAST, 0) +} + +func (s *Dbcc_checkdbContext) REPAIR_REBUILD() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_REBUILD, 0) +} + +func (s *Dbcc_checkdbContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_checkdbContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_checkdbContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_checkdb(s) + } +} + +func (s *Dbcc_checkdbContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_checkdb(s) + } +} + +func (s *Dbcc_checkdbContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_checkdb(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_checkdb() (localctx IDbcc_checkdbContext) { + localctx = NewDbcc_checkdbContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 832, TSqlParserRULE_dbcc_checkdb) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10307) + + var _m = p.Match(TSqlParserCHECKDB) + + localctx.(*Dbcc_checkdbContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10319) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1379, p.GetParserRuleContext()) == 1 { + { + p.SetState(10308) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(10309) + + var _x = p.Id_() + + localctx.(*Dbcc_checkdbContext).database = _x + } + + case TSqlParserSTRING: + { + p.SetState(10310) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Dbcc_checkdbContext).databasename = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL: + { + p.SetState(10311) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(10314) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10315) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNOINDEX || ((int64((_la-796)) & ^0x3f) == 0 && ((int64(1)<<(_la-796))&7) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(10318) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10330) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1381, p.GetParserRuleContext()) == 1 { + { + p.SetState(10321) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10322) + + var _x = p.Dbcc_checkdb_table_option() + + localctx.(*Dbcc_checkdbContext).dbcc_option = _x + } + p.SetState(10327) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(10323) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10324) + + var _x = p.Dbcc_checkdb_table_option() + + localctx.(*Dbcc_checkdbContext).dbcc_option = _x + } + + p.SetState(10329) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_checkfilegroup_optionContext is an interface to support dynamic dispatch. +type IDbcc_checkfilegroup_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMax_dregree_of_parallelism returns the max_dregree_of_parallelism token. + GetMax_dregree_of_parallelism() antlr.Token + + // SetMax_dregree_of_parallelism sets the max_dregree_of_parallelism token. + SetMax_dregree_of_parallelism(antlr.Token) + + // Getter signatures + ALL_ERRORMSGS() antlr.TerminalNode + NO_INFOMSGS() antlr.TerminalNode + TABLOCK() antlr.TerminalNode + ESTIMATEONLY() antlr.TerminalNode + PHYSICAL_ONLY() antlr.TerminalNode + MAXDOP() antlr.TerminalNode + EQUAL() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + + // IsDbcc_checkfilegroup_optionContext differentiates from other interfaces. + IsDbcc_checkfilegroup_optionContext() +} + +type Dbcc_checkfilegroup_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + max_dregree_of_parallelism antlr.Token +} + +func NewEmptyDbcc_checkfilegroup_optionContext() *Dbcc_checkfilegroup_optionContext { + var p = new(Dbcc_checkfilegroup_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkfilegroup_option + return p +} + +func InitEmptyDbcc_checkfilegroup_optionContext(p *Dbcc_checkfilegroup_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkfilegroup_option +} + +func (*Dbcc_checkfilegroup_optionContext) IsDbcc_checkfilegroup_optionContext() {} + +func NewDbcc_checkfilegroup_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_checkfilegroup_optionContext { + var p = new(Dbcc_checkfilegroup_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_checkfilegroup_option + + return p +} + +func (s *Dbcc_checkfilegroup_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_checkfilegroup_optionContext) GetMax_dregree_of_parallelism() antlr.Token { + return s.max_dregree_of_parallelism +} + +func (s *Dbcc_checkfilegroup_optionContext) SetMax_dregree_of_parallelism(v antlr.Token) { + s.max_dregree_of_parallelism = v +} + +func (s *Dbcc_checkfilegroup_optionContext) ALL_ERRORMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserALL_ERRORMSGS, 0) +} + +func (s *Dbcc_checkfilegroup_optionContext) NO_INFOMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_INFOMSGS, 0) +} + +func (s *Dbcc_checkfilegroup_optionContext) TABLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLOCK, 0) +} + +func (s *Dbcc_checkfilegroup_optionContext) ESTIMATEONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserESTIMATEONLY, 0) +} + +func (s *Dbcc_checkfilegroup_optionContext) PHYSICAL_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserPHYSICAL_ONLY, 0) +} + +func (s *Dbcc_checkfilegroup_optionContext) MAXDOP() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXDOP, 0) +} + +func (s *Dbcc_checkfilegroup_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Dbcc_checkfilegroup_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Dbcc_checkfilegroup_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_checkfilegroup_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_checkfilegroup_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_checkfilegroup_option(s) + } +} + +func (s *Dbcc_checkfilegroup_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_checkfilegroup_option(s) + } +} + +func (s *Dbcc_checkfilegroup_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_checkfilegroup_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_checkfilegroup_option() (localctx IDbcc_checkfilegroup_optionContext) { + localctx = NewDbcc_checkfilegroup_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 834, TSqlParserRULE_dbcc_checkfilegroup_option) + p.SetState(10340) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserALL_ERRORMSGS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10332) + p.Match(TSqlParserALL_ERRORMSGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNO_INFOMSGS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10333) + p.Match(TSqlParserNO_INFOMSGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTABLOCK: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10334) + p.Match(TSqlParserTABLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserESTIMATEONLY: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10335) + p.Match(TSqlParserESTIMATEONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPHYSICAL_ONLY: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10336) + p.Match(TSqlParserPHYSICAL_ONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMAXDOP: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10337) + p.Match(TSqlParserMAXDOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10338) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10339) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Dbcc_checkfilegroup_optionContext).max_dregree_of_parallelism = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_checkfilegroupContext is an interface to support dynamic dispatch. +type IDbcc_checkfilegroupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // GetFilegroup_id returns the filegroup_id token. + GetFilegroup_id() antlr.Token + + // GetFilegroup_name returns the filegroup_name token. + GetFilegroup_name() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // SetFilegroup_id sets the filegroup_id token. + SetFilegroup_id(antlr.Token) + + // SetFilegroup_name sets the filegroup_name token. + SetFilegroup_name(antlr.Token) + + // GetDbcc_option returns the dbcc_option rule contexts. + GetDbcc_option() IDbcc_checkfilegroup_optionContext + + // SetDbcc_option sets the dbcc_option rule contexts. + SetDbcc_option(IDbcc_checkfilegroup_optionContext) + + // Getter signatures + CHECKFILEGROUP() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + WITH() antlr.TerminalNode + AllDbcc_checkfilegroup_option() []IDbcc_checkfilegroup_optionContext + Dbcc_checkfilegroup_option(i int) IDbcc_checkfilegroup_optionContext + DECIMAL() antlr.TerminalNode + STRING() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + NOINDEX() antlr.TerminalNode + REPAIR_ALLOW_DATA_LOSS() antlr.TerminalNode + REPAIR_FAST() antlr.TerminalNode + REPAIR_REBUILD() antlr.TerminalNode + + // IsDbcc_checkfilegroupContext differentiates from other interfaces. + IsDbcc_checkfilegroupContext() +} + +type Dbcc_checkfilegroupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + filegroup_id antlr.Token + filegroup_name antlr.Token + dbcc_option IDbcc_checkfilegroup_optionContext +} + +func NewEmptyDbcc_checkfilegroupContext() *Dbcc_checkfilegroupContext { + var p = new(Dbcc_checkfilegroupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkfilegroup + return p +} + +func InitEmptyDbcc_checkfilegroupContext(p *Dbcc_checkfilegroupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checkfilegroup +} + +func (*Dbcc_checkfilegroupContext) IsDbcc_checkfilegroupContext() {} + +func NewDbcc_checkfilegroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_checkfilegroupContext { + var p = new(Dbcc_checkfilegroupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_checkfilegroup + + return p +} + +func (s *Dbcc_checkfilegroupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_checkfilegroupContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_checkfilegroupContext) GetFilegroup_id() antlr.Token { return s.filegroup_id } + +func (s *Dbcc_checkfilegroupContext) GetFilegroup_name() antlr.Token { return s.filegroup_name } + +func (s *Dbcc_checkfilegroupContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_checkfilegroupContext) SetFilegroup_id(v antlr.Token) { s.filegroup_id = v } + +func (s *Dbcc_checkfilegroupContext) SetFilegroup_name(v antlr.Token) { s.filegroup_name = v } + +func (s *Dbcc_checkfilegroupContext) GetDbcc_option() IDbcc_checkfilegroup_optionContext { + return s.dbcc_option +} + +func (s *Dbcc_checkfilegroupContext) SetDbcc_option(v IDbcc_checkfilegroup_optionContext) { + s.dbcc_option = v +} + +func (s *Dbcc_checkfilegroupContext) CHECKFILEGROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKFILEGROUP, 0) +} + +func (s *Dbcc_checkfilegroupContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_checkfilegroupContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_checkfilegroupContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_checkfilegroupContext) AllDbcc_checkfilegroup_option() []IDbcc_checkfilegroup_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDbcc_checkfilegroup_optionContext); ok { + len++ + } + } + + tst := make([]IDbcc_checkfilegroup_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDbcc_checkfilegroup_optionContext); ok { + tst[i] = t.(IDbcc_checkfilegroup_optionContext) + i++ + } + } + + return tst +} + +func (s *Dbcc_checkfilegroupContext) Dbcc_checkfilegroup_option(i int) IDbcc_checkfilegroup_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_checkfilegroup_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_checkfilegroup_optionContext) +} + +func (s *Dbcc_checkfilegroupContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Dbcc_checkfilegroupContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Dbcc_checkfilegroupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Dbcc_checkfilegroupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Dbcc_checkfilegroupContext) NOINDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserNOINDEX, 0) +} + +func (s *Dbcc_checkfilegroupContext) REPAIR_ALLOW_DATA_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_ALLOW_DATA_LOSS, 0) +} + +func (s *Dbcc_checkfilegroupContext) REPAIR_FAST() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_FAST, 0) +} + +func (s *Dbcc_checkfilegroupContext) REPAIR_REBUILD() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_REBUILD, 0) +} + +func (s *Dbcc_checkfilegroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_checkfilegroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_checkfilegroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_checkfilegroup(s) + } +} + +func (s *Dbcc_checkfilegroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_checkfilegroup(s) + } +} + +func (s *Dbcc_checkfilegroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_checkfilegroup(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_checkfilegroup() (localctx IDbcc_checkfilegroupContext) { + localctx = NewDbcc_checkfilegroupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 836, TSqlParserRULE_dbcc_checkfilegroup) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10342) + + var _m = p.Match(TSqlParserCHECKFILEGROUP) + + localctx.(*Dbcc_checkfilegroupContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10353) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1385, p.GetParserRuleContext()) == 1 { + { + p.SetState(10343) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10346) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(10344) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Dbcc_checkfilegroupContext).filegroup_id = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSTRING: + { + p.SetState(10345) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Dbcc_checkfilegroupContext).filegroup_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10350) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(10348) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10349) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNOINDEX || ((int64((_la-796)) & ^0x3f) == 0 && ((int64(1)<<(_la-796))&7) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(10352) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10364) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1387, p.GetParserRuleContext()) == 1 { + { + p.SetState(10355) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10356) + + var _x = p.Dbcc_checkfilegroup_option() + + localctx.(*Dbcc_checkfilegroupContext).dbcc_option = _x + } + p.SetState(10361) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(10357) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10358) + + var _x = p.Dbcc_checkfilegroup_option() + + localctx.(*Dbcc_checkfilegroupContext).dbcc_option = _x + } + + p.SetState(10363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_checktableContext is an interface to support dynamic dispatch. +type IDbcc_checktableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // GetTable_or_view_name returns the table_or_view_name token. + GetTable_or_view_name() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // SetTable_or_view_name sets the table_or_view_name token. + SetTable_or_view_name(antlr.Token) + + // GetIndex_id returns the index_id rule contexts. + GetIndex_id() IExpressionContext + + // GetDbcc_option returns the dbcc_option rule contexts. + GetDbcc_option() IDbcc_checkdb_table_optionContext + + // SetIndex_id sets the index_id rule contexts. + SetIndex_id(IExpressionContext) + + // SetDbcc_option sets the dbcc_option rule contexts. + SetDbcc_option(IDbcc_checkdb_table_optionContext) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + CHECKTABLE() antlr.TerminalNode + STRING() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + AllDbcc_checkdb_table_option() []IDbcc_checkdb_table_optionContext + Dbcc_checkdb_table_option(i int) IDbcc_checkdb_table_optionContext + NOINDEX() antlr.TerminalNode + REPAIR_ALLOW_DATA_LOSS() antlr.TerminalNode + REPAIR_FAST() antlr.TerminalNode + REPAIR_REBUILD() antlr.TerminalNode + Expression() IExpressionContext + + // IsDbcc_checktableContext differentiates from other interfaces. + IsDbcc_checktableContext() +} + +type Dbcc_checktableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + table_or_view_name antlr.Token + index_id IExpressionContext + dbcc_option IDbcc_checkdb_table_optionContext +} + +func NewEmptyDbcc_checktableContext() *Dbcc_checktableContext { + var p = new(Dbcc_checktableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checktable + return p +} + +func InitEmptyDbcc_checktableContext(p *Dbcc_checktableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_checktable +} + +func (*Dbcc_checktableContext) IsDbcc_checktableContext() {} + +func NewDbcc_checktableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_checktableContext { + var p = new(Dbcc_checktableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_checktable + + return p +} + +func (s *Dbcc_checktableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_checktableContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_checktableContext) GetTable_or_view_name() antlr.Token { return s.table_or_view_name } + +func (s *Dbcc_checktableContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_checktableContext) SetTable_or_view_name(v antlr.Token) { s.table_or_view_name = v } + +func (s *Dbcc_checktableContext) GetIndex_id() IExpressionContext { return s.index_id } + +func (s *Dbcc_checktableContext) GetDbcc_option() IDbcc_checkdb_table_optionContext { + return s.dbcc_option +} + +func (s *Dbcc_checktableContext) SetIndex_id(v IExpressionContext) { s.index_id = v } + +func (s *Dbcc_checktableContext) SetDbcc_option(v IDbcc_checkdb_table_optionContext) { + s.dbcc_option = v +} + +func (s *Dbcc_checktableContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_checktableContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_checktableContext) CHECKTABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKTABLE, 0) +} + +func (s *Dbcc_checktableContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Dbcc_checktableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Dbcc_checktableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Dbcc_checktableContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_checktableContext) AllDbcc_checkdb_table_option() []IDbcc_checkdb_table_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDbcc_checkdb_table_optionContext); ok { + len++ + } + } + + tst := make([]IDbcc_checkdb_table_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDbcc_checkdb_table_optionContext); ok { + tst[i] = t.(IDbcc_checkdb_table_optionContext) + i++ + } + } + + return tst +} + +func (s *Dbcc_checktableContext) Dbcc_checkdb_table_option(i int) IDbcc_checkdb_table_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_checkdb_table_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_checkdb_table_optionContext) +} + +func (s *Dbcc_checktableContext) NOINDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserNOINDEX, 0) +} + +func (s *Dbcc_checktableContext) REPAIR_ALLOW_DATA_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_ALLOW_DATA_LOSS, 0) +} + +func (s *Dbcc_checktableContext) REPAIR_FAST() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_FAST, 0) +} + +func (s *Dbcc_checktableContext) REPAIR_REBUILD() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_REBUILD, 0) +} + +func (s *Dbcc_checktableContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Dbcc_checktableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_checktableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_checktableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_checktable(s) + } +} + +func (s *Dbcc_checktableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_checktable(s) + } +} + +func (s *Dbcc_checktableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_checktable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_checktable() (localctx IDbcc_checktableContext) { + localctx = NewDbcc_checktableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 838, TSqlParserRULE_dbcc_checktable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10366) + + var _m = p.Match(TSqlParserCHECKTABLE) + + localctx.(*Dbcc_checktableContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10367) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10368) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Dbcc_checktableContext).table_or_view_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(10369) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1388, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10370) + p.Match(TSqlParserNOINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(10371) + + var _x = p.expression(0) + + localctx.(*Dbcc_checktableContext).index_id = _x + } + + case 3: + { + p.SetState(10372) + p.Match(TSqlParserREPAIR_ALLOW_DATA_LOSS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(10373) + p.Match(TSqlParserREPAIR_FAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(10374) + p.Match(TSqlParserREPAIR_REBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + { + p.SetState(10379) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10389) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1391, p.GetParserRuleContext()) == 1 { + { + p.SetState(10380) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10381) + + var _x = p.Dbcc_checkdb_table_option() + + localctx.(*Dbcc_checktableContext).dbcc_option = _x + } + p.SetState(10386) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(10382) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10383) + + var _x = p.Dbcc_checkdb_table_option() + + localctx.(*Dbcc_checktableContext).dbcc_option = _x + } + + p.SetState(10388) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_cleantableContext is an interface to support dynamic dispatch. +type IDbcc_cleantableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // GetDatabasename returns the databasename token. + GetDatabasename() antlr.Token + + // GetTable_or_view_name returns the table_or_view_name token. + GetTable_or_view_name() antlr.Token + + // GetBatch_size returns the batch_size token. + GetBatch_size() antlr.Token + + // GetDbcc_option returns the dbcc_option token. + GetDbcc_option() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // SetDatabasename sets the databasename token. + SetDatabasename(antlr.Token) + + // SetTable_or_view_name sets the table_or_view_name token. + SetTable_or_view_name(antlr.Token) + + // SetBatch_size sets the batch_size token. + SetBatch_size(antlr.Token) + + // SetDbcc_option sets the dbcc_option token. + SetDbcc_option(antlr.Token) + + // GetDatabase returns the database rule contexts. + GetDatabase() IId_Context + + // GetTable_or_view returns the table_or_view rule contexts. + GetTable_or_view() IId_Context + + // SetDatabase sets the database rule contexts. + SetDatabase(IId_Context) + + // SetTable_or_view sets the table_or_view rule contexts. + SetTable_or_view(IId_Context) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + CLEANTABLE() antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + NO_INFOMSGS() antlr.TerminalNode + + // IsDbcc_cleantableContext differentiates from other interfaces. + IsDbcc_cleantableContext() +} + +type Dbcc_cleantableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + database IId_Context + databasename antlr.Token + table_or_view IId_Context + table_or_view_name antlr.Token + batch_size antlr.Token + dbcc_option antlr.Token +} + +func NewEmptyDbcc_cleantableContext() *Dbcc_cleantableContext { + var p = new(Dbcc_cleantableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_cleantable + return p +} + +func InitEmptyDbcc_cleantableContext(p *Dbcc_cleantableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_cleantable +} + +func (*Dbcc_cleantableContext) IsDbcc_cleantableContext() {} + +func NewDbcc_cleantableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_cleantableContext { + var p = new(Dbcc_cleantableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_cleantable + + return p +} + +func (s *Dbcc_cleantableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_cleantableContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_cleantableContext) GetDatabasename() antlr.Token { return s.databasename } + +func (s *Dbcc_cleantableContext) GetTable_or_view_name() antlr.Token { return s.table_or_view_name } + +func (s *Dbcc_cleantableContext) GetBatch_size() antlr.Token { return s.batch_size } + +func (s *Dbcc_cleantableContext) GetDbcc_option() antlr.Token { return s.dbcc_option } + +func (s *Dbcc_cleantableContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_cleantableContext) SetDatabasename(v antlr.Token) { s.databasename = v } + +func (s *Dbcc_cleantableContext) SetTable_or_view_name(v antlr.Token) { s.table_or_view_name = v } + +func (s *Dbcc_cleantableContext) SetBatch_size(v antlr.Token) { s.batch_size = v } + +func (s *Dbcc_cleantableContext) SetDbcc_option(v antlr.Token) { s.dbcc_option = v } + +func (s *Dbcc_cleantableContext) GetDatabase() IId_Context { return s.database } + +func (s *Dbcc_cleantableContext) GetTable_or_view() IId_Context { return s.table_or_view } + +func (s *Dbcc_cleantableContext) SetDatabase(v IId_Context) { s.database = v } + +func (s *Dbcc_cleantableContext) SetTable_or_view(v IId_Context) { s.table_or_view = v } + +func (s *Dbcc_cleantableContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_cleantableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Dbcc_cleantableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Dbcc_cleantableContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_cleantableContext) CLEANTABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserCLEANTABLE, 0) +} + +func (s *Dbcc_cleantableContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Dbcc_cleantableContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Dbcc_cleantableContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Dbcc_cleantableContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Dbcc_cleantableContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Dbcc_cleantableContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Dbcc_cleantableContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_cleantableContext) NO_INFOMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_INFOMSGS, 0) +} + +func (s *Dbcc_cleantableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_cleantableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_cleantableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_cleantable(s) + } +} + +func (s *Dbcc_cleantableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_cleantable(s) + } +} + +func (s *Dbcc_cleantableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_cleantable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_cleantable() (localctx IDbcc_cleantableContext) { + localctx = NewDbcc_cleantableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 840, TSqlParserRULE_dbcc_cleantable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10391) + + var _m = p.Match(TSqlParserCLEANTABLE) + + localctx.(*Dbcc_cleantableContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10392) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(10393) + + var _x = p.Id_() + + localctx.(*Dbcc_cleantableContext).database = _x + } + + case TSqlParserSTRING: + { + p.SetState(10394) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Dbcc_cleantableContext).databasename = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL: + { + p.SetState(10395) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(10398) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10401) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(10399) + + var _x = p.Id_() + + localctx.(*Dbcc_cleantableContext).table_or_view = _x + } + + case TSqlParserSTRING: + { + p.SetState(10400) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Dbcc_cleantableContext).table_or_view_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(10403) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10404) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Dbcc_cleantableContext).batch_size = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10407) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10410) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1395, p.GetParserRuleContext()) == 1 { + { + p.SetState(10408) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10409) + + var _m = p.Match(TSqlParserNO_INFOMSGS) + + localctx.(*Dbcc_cleantableContext).dbcc_option = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_clonedatabase_optionContext is an interface to support dynamic dispatch. +type IDbcc_clonedatabase_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO_STATISTICS() antlr.TerminalNode + NO_QUERYSTORE() antlr.TerminalNode + SERVICEBROKER() antlr.TerminalNode + VERIFY_CLONEDB() antlr.TerminalNode + BACKUP_CLONEDB() antlr.TerminalNode + + // IsDbcc_clonedatabase_optionContext differentiates from other interfaces. + IsDbcc_clonedatabase_optionContext() +} + +type Dbcc_clonedatabase_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDbcc_clonedatabase_optionContext() *Dbcc_clonedatabase_optionContext { + var p = new(Dbcc_clonedatabase_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_clonedatabase_option + return p +} + +func InitEmptyDbcc_clonedatabase_optionContext(p *Dbcc_clonedatabase_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_clonedatabase_option +} + +func (*Dbcc_clonedatabase_optionContext) IsDbcc_clonedatabase_optionContext() {} + +func NewDbcc_clonedatabase_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_clonedatabase_optionContext { + var p = new(Dbcc_clonedatabase_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_clonedatabase_option + + return p +} + +func (s *Dbcc_clonedatabase_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_clonedatabase_optionContext) NO_STATISTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_STATISTICS, 0) +} + +func (s *Dbcc_clonedatabase_optionContext) NO_QUERYSTORE() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_QUERYSTORE, 0) +} + +func (s *Dbcc_clonedatabase_optionContext) SERVICEBROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICEBROKER, 0) +} + +func (s *Dbcc_clonedatabase_optionContext) VERIFY_CLONEDB() antlr.TerminalNode { + return s.GetToken(TSqlParserVERIFY_CLONEDB, 0) +} + +func (s *Dbcc_clonedatabase_optionContext) BACKUP_CLONEDB() antlr.TerminalNode { + return s.GetToken(TSqlParserBACKUP_CLONEDB, 0) +} + +func (s *Dbcc_clonedatabase_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_clonedatabase_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_clonedatabase_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_clonedatabase_option(s) + } +} + +func (s *Dbcc_clonedatabase_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_clonedatabase_option(s) + } +} + +func (s *Dbcc_clonedatabase_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_clonedatabase_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_clonedatabase_option() (localctx IDbcc_clonedatabase_optionContext) { + localctx = NewDbcc_clonedatabase_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 842, TSqlParserRULE_dbcc_clonedatabase_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10412) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserBACKUP_CLONEDB || _la == TSqlParserNO_QUERYSTORE || _la == TSqlParserNO_STATISTICS || _la == TSqlParserSERVICEBROKER || _la == TSqlParserVERIFY_CLONEDB) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_clonedatabaseContext is an interface to support dynamic dispatch. +type IDbcc_clonedatabaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // GetSource_database returns the source_database rule contexts. + GetSource_database() IId_Context + + // GetTarget_database returns the target_database rule contexts. + GetTarget_database() IId_Context + + // GetDbcc_option returns the dbcc_option rule contexts. + GetDbcc_option() IDbcc_clonedatabase_optionContext + + // SetSource_database sets the source_database rule contexts. + SetSource_database(IId_Context) + + // SetTarget_database sets the target_database rule contexts. + SetTarget_database(IId_Context) + + // SetDbcc_option sets the dbcc_option rule contexts. + SetDbcc_option(IDbcc_clonedatabase_optionContext) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + CLONEDATABASE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + WITH() antlr.TerminalNode + AllDbcc_clonedatabase_option() []IDbcc_clonedatabase_optionContext + Dbcc_clonedatabase_option(i int) IDbcc_clonedatabase_optionContext + + // IsDbcc_clonedatabaseContext differentiates from other interfaces. + IsDbcc_clonedatabaseContext() +} + +type Dbcc_clonedatabaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + source_database IId_Context + target_database IId_Context + dbcc_option IDbcc_clonedatabase_optionContext +} + +func NewEmptyDbcc_clonedatabaseContext() *Dbcc_clonedatabaseContext { + var p = new(Dbcc_clonedatabaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_clonedatabase + return p +} + +func InitEmptyDbcc_clonedatabaseContext(p *Dbcc_clonedatabaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_clonedatabase +} + +func (*Dbcc_clonedatabaseContext) IsDbcc_clonedatabaseContext() {} + +func NewDbcc_clonedatabaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_clonedatabaseContext { + var p = new(Dbcc_clonedatabaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_clonedatabase + + return p +} + +func (s *Dbcc_clonedatabaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_clonedatabaseContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_clonedatabaseContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_clonedatabaseContext) GetSource_database() IId_Context { return s.source_database } + +func (s *Dbcc_clonedatabaseContext) GetTarget_database() IId_Context { return s.target_database } + +func (s *Dbcc_clonedatabaseContext) GetDbcc_option() IDbcc_clonedatabase_optionContext { + return s.dbcc_option +} + +func (s *Dbcc_clonedatabaseContext) SetSource_database(v IId_Context) { s.source_database = v } + +func (s *Dbcc_clonedatabaseContext) SetTarget_database(v IId_Context) { s.target_database = v } + +func (s *Dbcc_clonedatabaseContext) SetDbcc_option(v IDbcc_clonedatabase_optionContext) { + s.dbcc_option = v +} + +func (s *Dbcc_clonedatabaseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_clonedatabaseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Dbcc_clonedatabaseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Dbcc_clonedatabaseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_clonedatabaseContext) CLONEDATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserCLONEDATABASE, 0) +} + +func (s *Dbcc_clonedatabaseContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Dbcc_clonedatabaseContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Dbcc_clonedatabaseContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_clonedatabaseContext) AllDbcc_clonedatabase_option() []IDbcc_clonedatabase_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDbcc_clonedatabase_optionContext); ok { + len++ + } + } + + tst := make([]IDbcc_clonedatabase_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDbcc_clonedatabase_optionContext); ok { + tst[i] = t.(IDbcc_clonedatabase_optionContext) + i++ + } + } + + return tst +} + +func (s *Dbcc_clonedatabaseContext) Dbcc_clonedatabase_option(i int) IDbcc_clonedatabase_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_clonedatabase_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_clonedatabase_optionContext) +} + +func (s *Dbcc_clonedatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_clonedatabaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_clonedatabaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_clonedatabase(s) + } +} + +func (s *Dbcc_clonedatabaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_clonedatabase(s) + } +} + +func (s *Dbcc_clonedatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_clonedatabase(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_clonedatabase() (localctx IDbcc_clonedatabaseContext) { + localctx = NewDbcc_clonedatabaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 844, TSqlParserRULE_dbcc_clonedatabase) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10414) + + var _m = p.Match(TSqlParserCLONEDATABASE) + + localctx.(*Dbcc_clonedatabaseContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10415) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10416) + + var _x = p.Id_() + + localctx.(*Dbcc_clonedatabaseContext).source_database = _x + } + { + p.SetState(10417) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10418) + + var _x = p.Id_() + + localctx.(*Dbcc_clonedatabaseContext).target_database = _x + } + { + p.SetState(10419) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10429) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1397, p.GetParserRuleContext()) == 1 { + { + p.SetState(10420) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10421) + + var _x = p.Dbcc_clonedatabase_option() + + localctx.(*Dbcc_clonedatabaseContext).dbcc_option = _x + } + p.SetState(10426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(10422) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10423) + + var _x = p.Dbcc_clonedatabase_option() + + localctx.(*Dbcc_clonedatabaseContext).dbcc_option = _x + } + + p.SetState(10428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_pdw_showspaceusedContext is an interface to support dynamic dispatch. +type IDbcc_pdw_showspaceusedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // GetDbcc_option returns the dbcc_option token. + GetDbcc_option() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // SetDbcc_option sets the dbcc_option token. + SetDbcc_option(antlr.Token) + + // GetTablename returns the tablename rule contexts. + GetTablename() IId_Context + + // SetTablename sets the tablename rule contexts. + SetTablename(IId_Context) + + // Getter signatures + PDW_SHOWSPACEUSED() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + WITH() antlr.TerminalNode + Id_() IId_Context + IGNORE_REPLICATED_TABLE_CACHE() antlr.TerminalNode + + // IsDbcc_pdw_showspaceusedContext differentiates from other interfaces. + IsDbcc_pdw_showspaceusedContext() +} + +type Dbcc_pdw_showspaceusedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + tablename IId_Context + dbcc_option antlr.Token +} + +func NewEmptyDbcc_pdw_showspaceusedContext() *Dbcc_pdw_showspaceusedContext { + var p = new(Dbcc_pdw_showspaceusedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_pdw_showspaceused + return p +} + +func InitEmptyDbcc_pdw_showspaceusedContext(p *Dbcc_pdw_showspaceusedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_pdw_showspaceused +} + +func (*Dbcc_pdw_showspaceusedContext) IsDbcc_pdw_showspaceusedContext() {} + +func NewDbcc_pdw_showspaceusedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_pdw_showspaceusedContext { + var p = new(Dbcc_pdw_showspaceusedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_pdw_showspaceused + + return p +} + +func (s *Dbcc_pdw_showspaceusedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_pdw_showspaceusedContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_pdw_showspaceusedContext) GetDbcc_option() antlr.Token { return s.dbcc_option } + +func (s *Dbcc_pdw_showspaceusedContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_pdw_showspaceusedContext) SetDbcc_option(v antlr.Token) { s.dbcc_option = v } + +func (s *Dbcc_pdw_showspaceusedContext) GetTablename() IId_Context { return s.tablename } + +func (s *Dbcc_pdw_showspaceusedContext) SetTablename(v IId_Context) { s.tablename = v } + +func (s *Dbcc_pdw_showspaceusedContext) PDW_SHOWSPACEUSED() antlr.TerminalNode { + return s.GetToken(TSqlParserPDW_SHOWSPACEUSED, 0) +} + +func (s *Dbcc_pdw_showspaceusedContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_pdw_showspaceusedContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_pdw_showspaceusedContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_pdw_showspaceusedContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Dbcc_pdw_showspaceusedContext) IGNORE_REPLICATED_TABLE_CACHE() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_REPLICATED_TABLE_CACHE, 0) +} + +func (s *Dbcc_pdw_showspaceusedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_pdw_showspaceusedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_pdw_showspaceusedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_pdw_showspaceused(s) + } +} + +func (s *Dbcc_pdw_showspaceusedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_pdw_showspaceused(s) + } +} + +func (s *Dbcc_pdw_showspaceusedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_pdw_showspaceused(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_pdw_showspaceused() (localctx IDbcc_pdw_showspaceusedContext) { + localctx = NewDbcc_pdw_showspaceusedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 846, TSqlParserRULE_dbcc_pdw_showspaceused) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10431) + + var _m = p.Match(TSqlParserPDW_SHOWSPACEUSED) + + localctx.(*Dbcc_pdw_showspaceusedContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10436) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1398, p.GetParserRuleContext()) == 1 { + { + p.SetState(10432) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10433) + + var _x = p.Id_() + + localctx.(*Dbcc_pdw_showspaceusedContext).tablename = _x + } + { + p.SetState(10434) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10440) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1399, p.GetParserRuleContext()) == 1 { + { + p.SetState(10438) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10439) + + var _m = p.Match(TSqlParserIGNORE_REPLICATED_TABLE_CACHE) + + localctx.(*Dbcc_pdw_showspaceusedContext).dbcc_option = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_proccacheContext is an interface to support dynamic dispatch. +type IDbcc_proccacheContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // GetDbcc_option returns the dbcc_option token. + GetDbcc_option() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // SetDbcc_option sets the dbcc_option token. + SetDbcc_option(antlr.Token) + + // Getter signatures + PROCCACHE() antlr.TerminalNode + WITH() antlr.TerminalNode + NO_INFOMSGS() antlr.TerminalNode + + // IsDbcc_proccacheContext differentiates from other interfaces. + IsDbcc_proccacheContext() +} + +type Dbcc_proccacheContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + dbcc_option antlr.Token +} + +func NewEmptyDbcc_proccacheContext() *Dbcc_proccacheContext { + var p = new(Dbcc_proccacheContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_proccache + return p +} + +func InitEmptyDbcc_proccacheContext(p *Dbcc_proccacheContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_proccache +} + +func (*Dbcc_proccacheContext) IsDbcc_proccacheContext() {} + +func NewDbcc_proccacheContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_proccacheContext { + var p = new(Dbcc_proccacheContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_proccache + + return p +} + +func (s *Dbcc_proccacheContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_proccacheContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_proccacheContext) GetDbcc_option() antlr.Token { return s.dbcc_option } + +func (s *Dbcc_proccacheContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_proccacheContext) SetDbcc_option(v antlr.Token) { s.dbcc_option = v } + +func (s *Dbcc_proccacheContext) PROCCACHE() antlr.TerminalNode { + return s.GetToken(TSqlParserPROCCACHE, 0) +} + +func (s *Dbcc_proccacheContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_proccacheContext) NO_INFOMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_INFOMSGS, 0) +} + +func (s *Dbcc_proccacheContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_proccacheContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_proccacheContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_proccache(s) + } +} + +func (s *Dbcc_proccacheContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_proccache(s) + } +} + +func (s *Dbcc_proccacheContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_proccache(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_proccache() (localctx IDbcc_proccacheContext) { + localctx = NewDbcc_proccacheContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 848, TSqlParserRULE_dbcc_proccache) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10442) + + var _m = p.Match(TSqlParserPROCCACHE) + + localctx.(*Dbcc_proccacheContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10445) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1400, p.GetParserRuleContext()) == 1 { + { + p.SetState(10443) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10444) + + var _m = p.Match(TSqlParserNO_INFOMSGS) + + localctx.(*Dbcc_proccacheContext).dbcc_option = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_showcontig_optionContext is an interface to support dynamic dispatch. +type IDbcc_showcontig_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL_INDEXES() antlr.TerminalNode + TABLERESULTS() antlr.TerminalNode + FAST() antlr.TerminalNode + ALL_LEVELS() antlr.TerminalNode + NO_INFOMSGS() antlr.TerminalNode + + // IsDbcc_showcontig_optionContext differentiates from other interfaces. + IsDbcc_showcontig_optionContext() +} + +type Dbcc_showcontig_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDbcc_showcontig_optionContext() *Dbcc_showcontig_optionContext { + var p = new(Dbcc_showcontig_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_showcontig_option + return p +} + +func InitEmptyDbcc_showcontig_optionContext(p *Dbcc_showcontig_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_showcontig_option +} + +func (*Dbcc_showcontig_optionContext) IsDbcc_showcontig_optionContext() {} + +func NewDbcc_showcontig_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_showcontig_optionContext { + var p = new(Dbcc_showcontig_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_showcontig_option + + return p +} + +func (s *Dbcc_showcontig_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_showcontig_optionContext) ALL_INDEXES() antlr.TerminalNode { + return s.GetToken(TSqlParserALL_INDEXES, 0) +} + +func (s *Dbcc_showcontig_optionContext) TABLERESULTS() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLERESULTS, 0) +} + +func (s *Dbcc_showcontig_optionContext) FAST() antlr.TerminalNode { + return s.GetToken(TSqlParserFAST, 0) +} + +func (s *Dbcc_showcontig_optionContext) ALL_LEVELS() antlr.TerminalNode { + return s.GetToken(TSqlParserALL_LEVELS, 0) +} + +func (s *Dbcc_showcontig_optionContext) NO_INFOMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_INFOMSGS, 0) +} + +func (s *Dbcc_showcontig_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_showcontig_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_showcontig_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_showcontig_option(s) + } +} + +func (s *Dbcc_showcontig_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_showcontig_option(s) + } +} + +func (s *Dbcc_showcontig_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_showcontig_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_showcontig_option() (localctx IDbcc_showcontig_optionContext) { + localctx = NewDbcc_showcontig_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 850, TSqlParserRULE_dbcc_showcontig_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10447) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALL_INDEXES || _la == TSqlParserALL_LEVELS || _la == TSqlParserFAST || _la == TSqlParserNO_INFOMSGS || _la == TSqlParserTABLERESULTS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_showcontigContext is an interface to support dynamic dispatch. +type IDbcc_showcontigContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // GetTable_or_view returns the table_or_view rule contexts. + GetTable_or_view() IExpressionContext + + // GetIndex returns the index rule contexts. + GetIndex() IExpressionContext + + // GetDbcc_option returns the dbcc_option rule contexts. + GetDbcc_option() IDbcc_showcontig_optionContext + + // SetTable_or_view sets the table_or_view rule contexts. + SetTable_or_view(IExpressionContext) + + // SetIndex sets the index rule contexts. + SetIndex(IExpressionContext) + + // SetDbcc_option sets the dbcc_option rule contexts. + SetDbcc_option(IDbcc_showcontig_optionContext) + + // Getter signatures + SHOWCONTIG() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + WITH() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllDbcc_showcontig_option() []IDbcc_showcontig_optionContext + Dbcc_showcontig_option(i int) IDbcc_showcontig_optionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDbcc_showcontigContext differentiates from other interfaces. + IsDbcc_showcontigContext() +} + +type Dbcc_showcontigContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + table_or_view IExpressionContext + index IExpressionContext + dbcc_option IDbcc_showcontig_optionContext +} + +func NewEmptyDbcc_showcontigContext() *Dbcc_showcontigContext { + var p = new(Dbcc_showcontigContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_showcontig + return p +} + +func InitEmptyDbcc_showcontigContext(p *Dbcc_showcontigContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_showcontig +} + +func (*Dbcc_showcontigContext) IsDbcc_showcontigContext() {} + +func NewDbcc_showcontigContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_showcontigContext { + var p = new(Dbcc_showcontigContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_showcontig + + return p +} + +func (s *Dbcc_showcontigContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_showcontigContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_showcontigContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_showcontigContext) GetTable_or_view() IExpressionContext { return s.table_or_view } + +func (s *Dbcc_showcontigContext) GetIndex() IExpressionContext { return s.index } + +func (s *Dbcc_showcontigContext) GetDbcc_option() IDbcc_showcontig_optionContext { + return s.dbcc_option +} + +func (s *Dbcc_showcontigContext) SetTable_or_view(v IExpressionContext) { s.table_or_view = v } + +func (s *Dbcc_showcontigContext) SetIndex(v IExpressionContext) { s.index = v } + +func (s *Dbcc_showcontigContext) SetDbcc_option(v IDbcc_showcontig_optionContext) { s.dbcc_option = v } + +func (s *Dbcc_showcontigContext) SHOWCONTIG() antlr.TerminalNode { + return s.GetToken(TSqlParserSHOWCONTIG, 0) +} + +func (s *Dbcc_showcontigContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_showcontigContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_showcontigContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_showcontigContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Dbcc_showcontigContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Dbcc_showcontigContext) AllDbcc_showcontig_option() []IDbcc_showcontig_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDbcc_showcontig_optionContext); ok { + len++ + } + } + + tst := make([]IDbcc_showcontig_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDbcc_showcontig_optionContext); ok { + tst[i] = t.(IDbcc_showcontig_optionContext) + i++ + } + } + + return tst +} + +func (s *Dbcc_showcontigContext) Dbcc_showcontig_option(i int) IDbcc_showcontig_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_showcontig_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_showcontig_optionContext) +} + +func (s *Dbcc_showcontigContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Dbcc_showcontigContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Dbcc_showcontigContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_showcontigContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_showcontigContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_showcontig(s) + } +} + +func (s *Dbcc_showcontigContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_showcontig(s) + } +} + +func (s *Dbcc_showcontigContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_showcontig(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_showcontig() (localctx IDbcc_showcontigContext) { + localctx = NewDbcc_showcontigContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 852, TSqlParserRULE_dbcc_showcontig) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10449) + + var _m = p.Match(TSqlParserSHOWCONTIG) + + localctx.(*Dbcc_showcontigContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10458) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1402, p.GetParserRuleContext()) == 1 { + { + p.SetState(10450) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10451) + + var _x = p.expression(0) + + localctx.(*Dbcc_showcontigContext).table_or_view = _x + } + p.SetState(10454) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(10452) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10453) + + var _x = p.expression(0) + + localctx.(*Dbcc_showcontigContext).index = _x + } + + } + { + p.SetState(10456) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10469) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1404, p.GetParserRuleContext()) == 1 { + { + p.SetState(10460) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10461) + + var _x = p.Dbcc_showcontig_option() + + localctx.(*Dbcc_showcontigContext).dbcc_option = _x + } + p.SetState(10466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(10462) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10463) + p.Dbcc_showcontig_option() + } + + p.SetState(10468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_shrinklogContext is an interface to support dynamic dispatch. +type IDbcc_shrinklogContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // GetDbcc_option returns the dbcc_option token. + GetDbcc_option() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // SetDbcc_option sets the dbcc_option token. + SetDbcc_option(antlr.Token) + + // Getter signatures + SHRINKLOG() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + SIZE() antlr.TerminalNode + EQUAL() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + WITH() antlr.TerminalNode + NO_INFOMSGS() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + MB() antlr.TerminalNode + GB() antlr.TerminalNode + TB() antlr.TerminalNode + + // IsDbcc_shrinklogContext differentiates from other interfaces. + IsDbcc_shrinklogContext() +} + +type Dbcc_shrinklogContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + dbcc_option antlr.Token +} + +func NewEmptyDbcc_shrinklogContext() *Dbcc_shrinklogContext { + var p = new(Dbcc_shrinklogContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_shrinklog + return p +} + +func InitEmptyDbcc_shrinklogContext(p *Dbcc_shrinklogContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_shrinklog +} + +func (*Dbcc_shrinklogContext) IsDbcc_shrinklogContext() {} + +func NewDbcc_shrinklogContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_shrinklogContext { + var p = new(Dbcc_shrinklogContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_shrinklog + + return p +} + +func (s *Dbcc_shrinklogContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_shrinklogContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_shrinklogContext) GetDbcc_option() antlr.Token { return s.dbcc_option } + +func (s *Dbcc_shrinklogContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_shrinklogContext) SetDbcc_option(v antlr.Token) { s.dbcc_option = v } + +func (s *Dbcc_shrinklogContext) SHRINKLOG() antlr.TerminalNode { + return s.GetToken(TSqlParserSHRINKLOG, 0) +} + +func (s *Dbcc_shrinklogContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_shrinklogContext) SIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserSIZE, 0) +} + +func (s *Dbcc_shrinklogContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Dbcc_shrinklogContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_shrinklogContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_shrinklogContext) NO_INFOMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_INFOMSGS, 0) +} + +func (s *Dbcc_shrinklogContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Dbcc_shrinklogContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Dbcc_shrinklogContext) MB() antlr.TerminalNode { + return s.GetToken(TSqlParserMB, 0) +} + +func (s *Dbcc_shrinklogContext) GB() antlr.TerminalNode { + return s.GetToken(TSqlParserGB, 0) +} + +func (s *Dbcc_shrinklogContext) TB() antlr.TerminalNode { + return s.GetToken(TSqlParserTB, 0) +} + +func (s *Dbcc_shrinklogContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_shrinklogContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_shrinklogContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_shrinklog(s) + } +} + +func (s *Dbcc_shrinklogContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_shrinklog(s) + } +} + +func (s *Dbcc_shrinklogContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_shrinklog(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_shrinklog() (localctx IDbcc_shrinklogContext) { + localctx = NewDbcc_shrinklogContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 854, TSqlParserRULE_dbcc_shrinklog) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10471) + + var _m = p.Match(TSqlParserSHRINKLOG) + + localctx.(*Dbcc_shrinklogContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10481) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1406, p.GetParserRuleContext()) == 1 { + { + p.SetState(10472) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10473) + p.Match(TSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10474) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10478) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(10475) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10476) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserGB || _la == TSqlParserMB || _la == TSqlParserTB) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserDEFAULT: + { + p.SetState(10477) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(10480) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10485) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1407, p.GetParserRuleContext()) == 1 { + { + p.SetState(10483) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10484) + + var _m = p.Match(TSqlParserNO_INFOMSGS) + + localctx.(*Dbcc_shrinklogContext).dbcc_option = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_dbreindexContext is an interface to support dynamic dispatch. +type IDbcc_dbreindexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // GetDbcc_option returns the dbcc_option token. + GetDbcc_option() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // SetDbcc_option sets the dbcc_option token. + SetDbcc_option(antlr.Token) + + // GetTable returns the table rule contexts. + GetTable() IId_or_stringContext + + // GetIndex_name returns the index_name rule contexts. + GetIndex_name() IId_or_stringContext + + // GetFillfactor returns the fillfactor rule contexts. + GetFillfactor() IExpressionContext + + // SetTable sets the table rule contexts. + SetTable(IId_or_stringContext) + + // SetIndex_name sets the index_name rule contexts. + SetIndex_name(IId_or_stringContext) + + // SetFillfactor sets the fillfactor rule contexts. + SetFillfactor(IExpressionContext) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + DBREINDEX() antlr.TerminalNode + AllId_or_string() []IId_or_stringContext + Id_or_string(i int) IId_or_stringContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + NO_INFOMSGS() antlr.TerminalNode + Expression() IExpressionContext + + // IsDbcc_dbreindexContext differentiates from other interfaces. + IsDbcc_dbreindexContext() +} + +type Dbcc_dbreindexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + table IId_or_stringContext + index_name IId_or_stringContext + fillfactor IExpressionContext + dbcc_option antlr.Token +} + +func NewEmptyDbcc_dbreindexContext() *Dbcc_dbreindexContext { + var p = new(Dbcc_dbreindexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_dbreindex + return p +} + +func InitEmptyDbcc_dbreindexContext(p *Dbcc_dbreindexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_dbreindex +} + +func (*Dbcc_dbreindexContext) IsDbcc_dbreindexContext() {} + +func NewDbcc_dbreindexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_dbreindexContext { + var p = new(Dbcc_dbreindexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_dbreindex + + return p +} + +func (s *Dbcc_dbreindexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_dbreindexContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_dbreindexContext) GetDbcc_option() antlr.Token { return s.dbcc_option } + +func (s *Dbcc_dbreindexContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_dbreindexContext) SetDbcc_option(v antlr.Token) { s.dbcc_option = v } + +func (s *Dbcc_dbreindexContext) GetTable() IId_or_stringContext { return s.table } + +func (s *Dbcc_dbreindexContext) GetIndex_name() IId_or_stringContext { return s.index_name } + +func (s *Dbcc_dbreindexContext) GetFillfactor() IExpressionContext { return s.fillfactor } + +func (s *Dbcc_dbreindexContext) SetTable(v IId_or_stringContext) { s.table = v } + +func (s *Dbcc_dbreindexContext) SetIndex_name(v IId_or_stringContext) { s.index_name = v } + +func (s *Dbcc_dbreindexContext) SetFillfactor(v IExpressionContext) { s.fillfactor = v } + +func (s *Dbcc_dbreindexContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_dbreindexContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_dbreindexContext) DBREINDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserDBREINDEX, 0) +} + +func (s *Dbcc_dbreindexContext) AllId_or_string() []IId_or_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_or_stringContext); ok { + len++ + } + } + + tst := make([]IId_or_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_or_stringContext); ok { + tst[i] = t.(IId_or_stringContext) + i++ + } + } + + return tst +} + +func (s *Dbcc_dbreindexContext) Id_or_string(i int) IId_or_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_or_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_or_stringContext) +} + +func (s *Dbcc_dbreindexContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Dbcc_dbreindexContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Dbcc_dbreindexContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_dbreindexContext) NO_INFOMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_INFOMSGS, 0) +} + +func (s *Dbcc_dbreindexContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Dbcc_dbreindexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_dbreindexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_dbreindexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_dbreindex(s) + } +} + +func (s *Dbcc_dbreindexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_dbreindex(s) + } +} + +func (s *Dbcc_dbreindexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_dbreindex(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_dbreindex() (localctx IDbcc_dbreindexContext) { + localctx = NewDbcc_dbreindexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 856, TSqlParserRULE_dbcc_dbreindex) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10487) + + var _m = p.Match(TSqlParserDBREINDEX) + + localctx.(*Dbcc_dbreindexContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10488) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10489) + + var _x = p.Id_or_string() + + localctx.(*Dbcc_dbreindexContext).table = _x + } + p.SetState(10496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(10490) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10491) + + var _x = p.Id_or_string() + + localctx.(*Dbcc_dbreindexContext).index_name = _x + } + p.SetState(10494) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(10492) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10493) + + var _x = p.expression(0) + + localctx.(*Dbcc_dbreindexContext).fillfactor = _x + } + + } + + } + { + p.SetState(10498) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10501) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1410, p.GetParserRuleContext()) == 1 { + { + p.SetState(10499) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10500) + + var _m = p.Match(TSqlParserNO_INFOMSGS) + + localctx.(*Dbcc_dbreindexContext).dbcc_option = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_dll_freeContext is an interface to support dynamic dispatch. +type IDbcc_dll_freeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // GetDbcc_option returns the dbcc_option token. + GetDbcc_option() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // SetDbcc_option sets the dbcc_option token. + SetDbcc_option(antlr.Token) + + // GetDllname returns the dllname rule contexts. + GetDllname() IId_Context + + // SetDllname sets the dllname rule contexts. + SetDllname(IId_Context) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Id_() IId_Context + FREE() antlr.TerminalNode + WITH() antlr.TerminalNode + NO_INFOMSGS() antlr.TerminalNode + + // IsDbcc_dll_freeContext differentiates from other interfaces. + IsDbcc_dll_freeContext() +} + +type Dbcc_dll_freeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dllname IId_Context + name antlr.Token + dbcc_option antlr.Token +} + +func NewEmptyDbcc_dll_freeContext() *Dbcc_dll_freeContext { + var p = new(Dbcc_dll_freeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_dll_free + return p +} + +func InitEmptyDbcc_dll_freeContext(p *Dbcc_dll_freeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_dll_free +} + +func (*Dbcc_dll_freeContext) IsDbcc_dll_freeContext() {} + +func NewDbcc_dll_freeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_dll_freeContext { + var p = new(Dbcc_dll_freeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_dll_free + + return p +} + +func (s *Dbcc_dll_freeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_dll_freeContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_dll_freeContext) GetDbcc_option() antlr.Token { return s.dbcc_option } + +func (s *Dbcc_dll_freeContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_dll_freeContext) SetDbcc_option(v antlr.Token) { s.dbcc_option = v } + +func (s *Dbcc_dll_freeContext) GetDllname() IId_Context { return s.dllname } + +func (s *Dbcc_dll_freeContext) SetDllname(v IId_Context) { s.dllname = v } + +func (s *Dbcc_dll_freeContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_dll_freeContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_dll_freeContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Dbcc_dll_freeContext) FREE() antlr.TerminalNode { + return s.GetToken(TSqlParserFREE, 0) +} + +func (s *Dbcc_dll_freeContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_dll_freeContext) NO_INFOMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_INFOMSGS, 0) +} + +func (s *Dbcc_dll_freeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_dll_freeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_dll_freeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_dll_free(s) + } +} + +func (s *Dbcc_dll_freeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_dll_free(s) + } +} + +func (s *Dbcc_dll_freeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_dll_free(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_dll_free() (localctx IDbcc_dll_freeContext) { + localctx = NewDbcc_dll_freeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 858, TSqlParserRULE_dbcc_dll_free) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10503) + + var _x = p.Id_() + + localctx.(*Dbcc_dll_freeContext).dllname = _x + } + { + p.SetState(10504) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10505) + + var _m = p.Match(TSqlParserFREE) + + localctx.(*Dbcc_dll_freeContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10506) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10509) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1411, p.GetParserRuleContext()) == 1 { + { + p.SetState(10507) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10508) + + var _m = p.Match(TSqlParserNO_INFOMSGS) + + localctx.(*Dbcc_dll_freeContext).dbcc_option = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_dropcleanbuffersContext is an interface to support dynamic dispatch. +type IDbcc_dropcleanbuffersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetName returns the name token. + GetName() antlr.Token + + // GetDbcc_option returns the dbcc_option token. + GetDbcc_option() antlr.Token + + // SetName sets the name token. + SetName(antlr.Token) + + // SetDbcc_option sets the dbcc_option token. + SetDbcc_option(antlr.Token) + + // Getter signatures + DROPCLEANBUFFERS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + COMPUTE() antlr.TerminalNode + ALL() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + WITH() antlr.TerminalNode + NO_INFOMSGS() antlr.TerminalNode + + // IsDbcc_dropcleanbuffersContext differentiates from other interfaces. + IsDbcc_dropcleanbuffersContext() +} + +type Dbcc_dropcleanbuffersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + name antlr.Token + dbcc_option antlr.Token +} + +func NewEmptyDbcc_dropcleanbuffersContext() *Dbcc_dropcleanbuffersContext { + var p = new(Dbcc_dropcleanbuffersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_dropcleanbuffers + return p +} + +func InitEmptyDbcc_dropcleanbuffersContext(p *Dbcc_dropcleanbuffersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_dropcleanbuffers +} + +func (*Dbcc_dropcleanbuffersContext) IsDbcc_dropcleanbuffersContext() {} + +func NewDbcc_dropcleanbuffersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_dropcleanbuffersContext { + var p = new(Dbcc_dropcleanbuffersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_dropcleanbuffers + + return p +} + +func (s *Dbcc_dropcleanbuffersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_dropcleanbuffersContext) GetName() antlr.Token { return s.name } + +func (s *Dbcc_dropcleanbuffersContext) GetDbcc_option() antlr.Token { return s.dbcc_option } + +func (s *Dbcc_dropcleanbuffersContext) SetName(v antlr.Token) { s.name = v } + +func (s *Dbcc_dropcleanbuffersContext) SetDbcc_option(v antlr.Token) { s.dbcc_option = v } + +func (s *Dbcc_dropcleanbuffersContext) DROPCLEANBUFFERS() antlr.TerminalNode { + return s.GetToken(TSqlParserDROPCLEANBUFFERS, 0) +} + +func (s *Dbcc_dropcleanbuffersContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Dbcc_dropcleanbuffersContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPUTE, 0) +} + +func (s *Dbcc_dropcleanbuffersContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Dbcc_dropcleanbuffersContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Dbcc_dropcleanbuffersContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Dbcc_dropcleanbuffersContext) NO_INFOMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_INFOMSGS, 0) +} + +func (s *Dbcc_dropcleanbuffersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_dropcleanbuffersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_dropcleanbuffersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_dropcleanbuffers(s) + } +} + +func (s *Dbcc_dropcleanbuffersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_dropcleanbuffers(s) + } +} + +func (s *Dbcc_dropcleanbuffersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_dropcleanbuffers(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_dropcleanbuffers() (localctx IDbcc_dropcleanbuffersContext) { + localctx = NewDbcc_dropcleanbuffersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 860, TSqlParserRULE_dbcc_dropcleanbuffers) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10511) + + var _m = p.Match(TSqlParserDROPCLEANBUFFERS) + + localctx.(*Dbcc_dropcleanbuffersContext).name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10516) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1412, p.GetParserRuleContext()) == 1 { + { + p.SetState(10512) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10513) + p.Match(TSqlParserCOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1412, p.GetParserRuleContext()) == 2 { + { + p.SetState(10514) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10515) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10520) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1413, p.GetParserRuleContext()) == 1 { + { + p.SetState(10518) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10519) + + var _m = p.Match(TSqlParserNO_INFOMSGS) + + localctx.(*Dbcc_dropcleanbuffersContext).dbcc_option = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDbcc_clauseContext is an interface to support dynamic dispatch. +type IDbcc_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DBCC() antlr.TerminalNode + Dbcc_checkalloc() IDbcc_checkallocContext + Dbcc_checkcatalog() IDbcc_checkcatalogContext + Dbcc_checkconstraints() IDbcc_checkconstraintsContext + Dbcc_checkdb() IDbcc_checkdbContext + Dbcc_checkfilegroup() IDbcc_checkfilegroupContext + Dbcc_checktable() IDbcc_checktableContext + Dbcc_cleantable() IDbcc_cleantableContext + Dbcc_clonedatabase() IDbcc_clonedatabaseContext + Dbcc_dbreindex() IDbcc_dbreindexContext + Dbcc_dll_free() IDbcc_dll_freeContext + Dbcc_dropcleanbuffers() IDbcc_dropcleanbuffersContext + Dbcc_pdw_showspaceused() IDbcc_pdw_showspaceusedContext + Dbcc_proccache() IDbcc_proccacheContext + Dbcc_showcontig() IDbcc_showcontigContext + Dbcc_shrinklog() IDbcc_shrinklogContext + + // IsDbcc_clauseContext differentiates from other interfaces. + IsDbcc_clauseContext() +} + +type Dbcc_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDbcc_clauseContext() *Dbcc_clauseContext { + var p = new(Dbcc_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_clause + return p +} + +func InitEmptyDbcc_clauseContext(p *Dbcc_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dbcc_clause +} + +func (*Dbcc_clauseContext) IsDbcc_clauseContext() {} + +func NewDbcc_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_clauseContext { + var p = new(Dbcc_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dbcc_clause + + return p +} + +func (s *Dbcc_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dbcc_clauseContext) DBCC() antlr.TerminalNode { + return s.GetToken(TSqlParserDBCC, 0) +} + +func (s *Dbcc_clauseContext) Dbcc_checkalloc() IDbcc_checkallocContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_checkallocContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_checkallocContext) +} + +func (s *Dbcc_clauseContext) Dbcc_checkcatalog() IDbcc_checkcatalogContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_checkcatalogContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_checkcatalogContext) +} + +func (s *Dbcc_clauseContext) Dbcc_checkconstraints() IDbcc_checkconstraintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_checkconstraintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_checkconstraintsContext) +} + +func (s *Dbcc_clauseContext) Dbcc_checkdb() IDbcc_checkdbContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_checkdbContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_checkdbContext) +} + +func (s *Dbcc_clauseContext) Dbcc_checkfilegroup() IDbcc_checkfilegroupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_checkfilegroupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_checkfilegroupContext) +} + +func (s *Dbcc_clauseContext) Dbcc_checktable() IDbcc_checktableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_checktableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_checktableContext) +} + +func (s *Dbcc_clauseContext) Dbcc_cleantable() IDbcc_cleantableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_cleantableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_cleantableContext) +} + +func (s *Dbcc_clauseContext) Dbcc_clonedatabase() IDbcc_clonedatabaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_clonedatabaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_clonedatabaseContext) +} + +func (s *Dbcc_clauseContext) Dbcc_dbreindex() IDbcc_dbreindexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_dbreindexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_dbreindexContext) +} + +func (s *Dbcc_clauseContext) Dbcc_dll_free() IDbcc_dll_freeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_dll_freeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_dll_freeContext) +} + +func (s *Dbcc_clauseContext) Dbcc_dropcleanbuffers() IDbcc_dropcleanbuffersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_dropcleanbuffersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_dropcleanbuffersContext) +} + +func (s *Dbcc_clauseContext) Dbcc_pdw_showspaceused() IDbcc_pdw_showspaceusedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_pdw_showspaceusedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_pdw_showspaceusedContext) +} + +func (s *Dbcc_clauseContext) Dbcc_proccache() IDbcc_proccacheContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_proccacheContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_proccacheContext) +} + +func (s *Dbcc_clauseContext) Dbcc_showcontig() IDbcc_showcontigContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_showcontigContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_showcontigContext) +} + +func (s *Dbcc_clauseContext) Dbcc_shrinklog() IDbcc_shrinklogContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDbcc_shrinklogContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDbcc_shrinklogContext) +} + +func (s *Dbcc_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dbcc_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dbcc_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDbcc_clause(s) + } +} + +func (s *Dbcc_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDbcc_clause(s) + } +} + +func (s *Dbcc_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDbcc_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dbcc_clause() (localctx IDbcc_clauseContext) { + localctx = NewDbcc_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 862, TSqlParserRULE_dbcc_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10522) + p.Match(TSqlParserDBCC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1414, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10523) + p.Dbcc_checkalloc() + } + + case 2: + { + p.SetState(10524) + p.Dbcc_checkcatalog() + } + + case 3: + { + p.SetState(10525) + p.Dbcc_checkconstraints() + } + + case 4: + { + p.SetState(10526) + p.Dbcc_checkdb() + } + + case 5: + { + p.SetState(10527) + p.Dbcc_checkfilegroup() + } + + case 6: + { + p.SetState(10528) + p.Dbcc_checktable() + } + + case 7: + { + p.SetState(10529) + p.Dbcc_cleantable() + } + + case 8: + { + p.SetState(10530) + p.Dbcc_clonedatabase() + } + + case 9: + { + p.SetState(10531) + p.Dbcc_dbreindex() + } + + case 10: + { + p.SetState(10532) + p.Dbcc_dll_free() + } + + case 11: + { + p.SetState(10533) + p.Dbcc_dropcleanbuffers() + } + + case 12: + { + p.SetState(10534) + p.Dbcc_pdw_showspaceused() + } + + case 13: + { + p.SetState(10535) + p.Dbcc_proccache() + } + + case 14: + { + p.SetState(10536) + p.Dbcc_showcontig() + } + + case 15: + { + p.SetState(10537) + p.Dbcc_shrinklog() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecute_clauseContext is an interface to support dynamic dispatch. +type IExecute_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetClause returns the clause token. + GetClause() antlr.Token + + // SetClause sets the clause token. + SetClause(antlr.Token) + + // Getter signatures + EXECUTE() antlr.TerminalNode + AS() antlr.TerminalNode + CALLER() antlr.TerminalNode + SELF() antlr.TerminalNode + OWNER() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsExecute_clauseContext differentiates from other interfaces. + IsExecute_clauseContext() +} + +type Execute_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + clause antlr.Token +} + +func NewEmptyExecute_clauseContext() *Execute_clauseContext { + var p = new(Execute_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_clause + return p +} + +func InitEmptyExecute_clauseContext(p *Execute_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_execute_clause +} + +func (*Execute_clauseContext) IsExecute_clauseContext() {} + +func NewExecute_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_clauseContext { + var p = new(Execute_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_execute_clause + + return p +} + +func (s *Execute_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_clauseContext) GetClause() antlr.Token { return s.clause } + +func (s *Execute_clauseContext) SetClause(v antlr.Token) { s.clause = v } + +func (s *Execute_clauseContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXECUTE, 0) +} + +func (s *Execute_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Execute_clauseContext) CALLER() antlr.TerminalNode { + return s.GetToken(TSqlParserCALLER, 0) +} + +func (s *Execute_clauseContext) SELF() antlr.TerminalNode { + return s.GetToken(TSqlParserSELF, 0) +} + +func (s *Execute_clauseContext) OWNER() antlr.TerminalNode { + return s.GetToken(TSqlParserOWNER, 0) +} + +func (s *Execute_clauseContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Execute_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExecute_clause(s) + } +} + +func (s *Execute_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExecute_clause(s) + } +} + +func (s *Execute_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExecute_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Execute_clause() (localctx IExecute_clauseContext) { + localctx = NewExecute_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 864, TSqlParserRULE_execute_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10540) + p.Match(TSqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10541) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10542) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Execute_clauseContext).clause = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCALLER || _la == TSqlParserOWNER || _la == TSqlParserSELF || _la == TSqlParserSTRING) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Execute_clauseContext).clause = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeclare_localContext is an interface to support dynamic dispatch. +type IDeclare_localContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL_ID() antlr.TerminalNode + Data_type() IData_typeContext + AS() antlr.TerminalNode + EQUAL() antlr.TerminalNode + Expression() IExpressionContext + + // IsDeclare_localContext differentiates from other interfaces. + IsDeclare_localContext() +} + +type Declare_localContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeclare_localContext() *Declare_localContext { + var p = new(Declare_localContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_declare_local + return p +} + +func InitEmptyDeclare_localContext(p *Declare_localContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_declare_local +} + +func (*Declare_localContext) IsDeclare_localContext() {} + +func NewDeclare_localContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Declare_localContext { + var p = new(Declare_localContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_declare_local + + return p +} + +func (s *Declare_localContext) GetParser() antlr.Parser { return s.parser } + +func (s *Declare_localContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Declare_localContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Declare_localContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Declare_localContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Declare_localContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Declare_localContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Declare_localContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Declare_localContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDeclare_local(s) + } +} + +func (s *Declare_localContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDeclare_local(s) + } +} + +func (s *Declare_localContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDeclare_local(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Declare_local() (localctx IDeclare_localContext) { + localctx = NewDeclare_localContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 866, TSqlParserRULE_declare_local) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10544) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(10545) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10548) + p.Data_type() + } + p.SetState(10551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserEQUAL { + { + p.SetState(10549) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10550) + p.expression(0) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_type_definitionContext is an interface to support dynamic dispatch. +type ITable_type_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Column_def_table_constraints() IColumn_def_table_constraintsContext + RR_BRACKET() antlr.TerminalNode + AllTable_type_indices() []ITable_type_indicesContext + Table_type_indices(i int) ITable_type_indicesContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTable_type_definitionContext differentiates from other interfaces. + IsTable_type_definitionContext() +} + +type Table_type_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_type_definitionContext() *Table_type_definitionContext { + var p = new(Table_type_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_type_definition + return p +} + +func InitEmptyTable_type_definitionContext(p *Table_type_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_type_definition +} + +func (*Table_type_definitionContext) IsTable_type_definitionContext() {} + +func NewTable_type_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_type_definitionContext { + var p = new(Table_type_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_table_type_definition + + return p +} + +func (s *Table_type_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_type_definitionContext) TABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLE, 0) +} + +func (s *Table_type_definitionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Table_type_definitionContext) Column_def_table_constraints() IColumn_def_table_constraintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_def_table_constraintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_def_table_constraintsContext) +} + +func (s *Table_type_definitionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Table_type_definitionContext) AllTable_type_indices() []ITable_type_indicesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_type_indicesContext); ok { + len++ + } + } + + tst := make([]ITable_type_indicesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_type_indicesContext); ok { + tst[i] = t.(ITable_type_indicesContext) + i++ + } + } + + return tst +} + +func (s *Table_type_definitionContext) Table_type_indices(i int) ITable_type_indicesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_type_indicesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_type_indicesContext) +} + +func (s *Table_type_definitionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Table_type_definitionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Table_type_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_type_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_type_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTable_type_definition(s) + } +} + +func (s *Table_type_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTable_type_definition(s) + } +} + +func (s *Table_type_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTable_type_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Table_type_definition() (localctx ITable_type_definitionContext) { + localctx = NewTable_type_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 868, TSqlParserRULE_table_type_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10553) + p.Match(TSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10554) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10555) + p.Column_def_table_constraints() + } + p.SetState(10562) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCHECK || _la == TSqlParserINDEX || _la == TSqlParserPRIMARY || _la == TSqlParserUNIQUE || _la == TSqlParserCOMMA { + p.SetState(10557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(10556) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10559) + p.Table_type_indices() + } + + p.SetState(10564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10565) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_type_indicesContext is an interface to support dynamic dispatch. +type ITable_type_indicesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + Column_name_list_with_order() IColumn_name_list_with_orderContext + RR_BRACKET() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + INDEX() antlr.TerminalNode + Id_() IId_Context + CLUSTERED() antlr.TerminalNode + NONCLUSTERED() antlr.TerminalNode + CHECK() antlr.TerminalNode + Search_condition() ISearch_conditionContext + + // IsTable_type_indicesContext differentiates from other interfaces. + IsTable_type_indicesContext() +} + +type Table_type_indicesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_type_indicesContext() *Table_type_indicesContext { + var p = new(Table_type_indicesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_type_indices + return p +} + +func InitEmptyTable_type_indicesContext(p *Table_type_indicesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_type_indices +} + +func (*Table_type_indicesContext) IsTable_type_indicesContext() {} + +func NewTable_type_indicesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_type_indicesContext { + var p = new(Table_type_indicesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_table_type_indices + + return p +} + +func (s *Table_type_indicesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_type_indicesContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Table_type_indicesContext) Column_name_list_with_order() IColumn_name_list_with_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_list_with_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_list_with_orderContext) +} + +func (s *Table_type_indicesContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Table_type_indicesContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(TSqlParserUNIQUE, 0) +} + +func (s *Table_type_indicesContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIMARY, 0) +} + +func (s *Table_type_indicesContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Table_type_indicesContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Table_type_indicesContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Table_type_indicesContext) CLUSTERED() antlr.TerminalNode { + return s.GetToken(TSqlParserCLUSTERED, 0) +} + +func (s *Table_type_indicesContext) NONCLUSTERED() antlr.TerminalNode { + return s.GetToken(TSqlParserNONCLUSTERED, 0) +} + +func (s *Table_type_indicesContext) CHECK() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECK, 0) +} + +func (s *Table_type_indicesContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Table_type_indicesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_type_indicesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_type_indicesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTable_type_indices(s) + } +} + +func (s *Table_type_indicesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTable_type_indices(s) + } +} + +func (s *Table_type_indicesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTable_type_indices(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Table_type_indices() (localctx ITable_type_indicesContext) { + localctx = NewTable_type_indicesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 870, TSqlParserRULE_table_type_indices) + var _la int + + p.SetState(10588) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserINDEX, TSqlParserPRIMARY, TSqlParserUNIQUE: + p.EnterOuterAlt(localctx, 1) + p.SetState(10577) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserINDEX, TSqlParserPRIMARY: + p.SetState(10571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPRIMARY: + { + p.SetState(10567) + p.Match(TSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10568) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserINDEX: + { + p.SetState(10569) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10570) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCLUSTERED || _la == TSqlParserNONCLUSTERED { + { + p.SetState(10573) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCLUSTERED || _la == TSqlParserNONCLUSTERED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case TSqlParserUNIQUE: + { + p.SetState(10576) + p.Match(TSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(10579) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10580) + p.Column_name_list_with_order() + } + { + p.SetState(10581) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCHECK: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10583) + p.Match(TSqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10584) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10585) + p.search_condition(0) + } + { + p.SetState(10586) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_type_definitionContext is an interface to support dynamic dispatch. +type IXml_type_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XML() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Xml_schema_collection() IXml_schema_collectionContext + RR_BRACKET() antlr.TerminalNode + CONTENT() antlr.TerminalNode + DOCUMENT() antlr.TerminalNode + + // IsXml_type_definitionContext differentiates from other interfaces. + IsXml_type_definitionContext() +} + +type Xml_type_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_type_definitionContext() *Xml_type_definitionContext { + var p = new(Xml_type_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_type_definition + return p +} + +func InitEmptyXml_type_definitionContext(p *Xml_type_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_type_definition +} + +func (*Xml_type_definitionContext) IsXml_type_definitionContext() {} + +func NewXml_type_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_type_definitionContext { + var p = new(Xml_type_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_xml_type_definition + + return p +} + +func (s *Xml_type_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_type_definitionContext) XML() antlr.TerminalNode { + return s.GetToken(TSqlParserXML, 0) +} + +func (s *Xml_type_definitionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Xml_type_definitionContext) Xml_schema_collection() IXml_schema_collectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_schema_collectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_schema_collectionContext) +} + +func (s *Xml_type_definitionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Xml_type_definitionContext) CONTENT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTENT, 0) +} + +func (s *Xml_type_definitionContext) DOCUMENT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOCUMENT, 0) +} + +func (s *Xml_type_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_type_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_type_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterXml_type_definition(s) + } +} + +func (s *Xml_type_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitXml_type_definition(s) + } +} + +func (s *Xml_type_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitXml_type_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Xml_type_definition() (localctx IXml_type_definitionContext) { + localctx = NewXml_type_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 872, TSqlParserRULE_xml_type_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10590) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10591) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCONTENT || _la == TSqlParserDOCUMENT { + { + p.SetState(10592) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCONTENT || _la == TSqlParserDOCUMENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(10595) + p.Xml_schema_collection() + } + { + p.SetState(10596) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_schema_collectionContext is an interface to support dynamic dispatch. +type IXml_schema_collectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllID() []antlr.TerminalNode + ID(i int) antlr.TerminalNode + DOT() antlr.TerminalNode + + // IsXml_schema_collectionContext differentiates from other interfaces. + IsXml_schema_collectionContext() +} + +type Xml_schema_collectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_schema_collectionContext() *Xml_schema_collectionContext { + var p = new(Xml_schema_collectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_schema_collection + return p +} + +func InitEmptyXml_schema_collectionContext(p *Xml_schema_collectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_schema_collection +} + +func (*Xml_schema_collectionContext) IsXml_schema_collectionContext() {} + +func NewXml_schema_collectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_schema_collectionContext { + var p = new(Xml_schema_collectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_xml_schema_collection + + return p +} + +func (s *Xml_schema_collectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_schema_collectionContext) AllID() []antlr.TerminalNode { + return s.GetTokens(TSqlParserID) +} + +func (s *Xml_schema_collectionContext) ID(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserID, i) +} + +func (s *Xml_schema_collectionContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Xml_schema_collectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_schema_collectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_schema_collectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterXml_schema_collection(s) + } +} + +func (s *Xml_schema_collectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitXml_schema_collection(s) + } +} + +func (s *Xml_schema_collectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitXml_schema_collection(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Xml_schema_collection() (localctx IXml_schema_collectionContext) { + localctx = NewXml_schema_collectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 874, TSqlParserRULE_xml_schema_collection) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10598) + p.Match(TSqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10599) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10600) + p.Match(TSqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_def_table_constraintsContext is an interface to support dynamic dispatch. +type IColumn_def_table_constraintsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn_def_table_constraint() []IColumn_def_table_constraintContext + Column_def_table_constraint(i int) IColumn_def_table_constraintContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_def_table_constraintsContext differentiates from other interfaces. + IsColumn_def_table_constraintsContext() +} + +type Column_def_table_constraintsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_def_table_constraintsContext() *Column_def_table_constraintsContext { + var p = new(Column_def_table_constraintsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_def_table_constraints + return p +} + +func InitEmptyColumn_def_table_constraintsContext(p *Column_def_table_constraintsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_def_table_constraints +} + +func (*Column_def_table_constraintsContext) IsColumn_def_table_constraintsContext() {} + +func NewColumn_def_table_constraintsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_def_table_constraintsContext { + var p = new(Column_def_table_constraintsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_column_def_table_constraints + + return p +} + +func (s *Column_def_table_constraintsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_def_table_constraintsContext) AllColumn_def_table_constraint() []IColumn_def_table_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_def_table_constraintContext); ok { + len++ + } + } + + tst := make([]IColumn_def_table_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_def_table_constraintContext); ok { + tst[i] = t.(IColumn_def_table_constraintContext) + i++ + } + } + + return tst +} + +func (s *Column_def_table_constraintsContext) Column_def_table_constraint(i int) IColumn_def_table_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_def_table_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_def_table_constraintContext) +} + +func (s *Column_def_table_constraintsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Column_def_table_constraintsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Column_def_table_constraintsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_def_table_constraintsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_def_table_constraintsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumn_def_table_constraints(s) + } +} + +func (s *Column_def_table_constraintsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumn_def_table_constraints(s) + } +} + +func (s *Column_def_table_constraintsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumn_def_table_constraints(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Column_def_table_constraints() (localctx IColumn_def_table_constraintsContext) { + localctx = NewColumn_def_table_constraintsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 876, TSqlParserRULE_column_def_table_constraints) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10602) + p.Column_def_table_constraint() + } + p.SetState(10609) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1425, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(10604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(10603) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10606) + p.Column_def_table_constraint() + } + + } + p.SetState(10611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1425, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_def_table_constraintContext is an interface to support dynamic dispatch. +type IColumn_def_table_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_definition() IColumn_definitionContext + Materialized_column_definition() IMaterialized_column_definitionContext + Table_constraint() ITable_constraintContext + + // IsColumn_def_table_constraintContext differentiates from other interfaces. + IsColumn_def_table_constraintContext() +} + +type Column_def_table_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_def_table_constraintContext() *Column_def_table_constraintContext { + var p = new(Column_def_table_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_def_table_constraint + return p +} + +func InitEmptyColumn_def_table_constraintContext(p *Column_def_table_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_def_table_constraint +} + +func (*Column_def_table_constraintContext) IsColumn_def_table_constraintContext() {} + +func NewColumn_def_table_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_def_table_constraintContext { + var p = new(Column_def_table_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_column_def_table_constraint + + return p +} + +func (s *Column_def_table_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_def_table_constraintContext) Column_definition() IColumn_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_definitionContext) +} + +func (s *Column_def_table_constraintContext) Materialized_column_definition() IMaterialized_column_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaterialized_column_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaterialized_column_definitionContext) +} + +func (s *Column_def_table_constraintContext) Table_constraint() ITable_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_constraintContext) +} + +func (s *Column_def_table_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_def_table_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_def_table_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumn_def_table_constraint(s) + } +} + +func (s *Column_def_table_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumn_def_table_constraint(s) + } +} + +func (s *Column_def_table_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumn_def_table_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Column_def_table_constraint() (localctx IColumn_def_table_constraintContext) { + localctx = NewColumn_def_table_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 878, TSqlParserRULE_column_def_table_constraint) + p.SetState(10615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1426, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10612) + p.Column_definition() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10613) + p.Materialized_column_definition() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10614) + p.Table_constraint() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_definitionContext is an interface to support dynamic dispatch. +type IColumn_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + Data_type() IData_typeContext + AS() antlr.TerminalNode + Expression() IExpressionContext + AllColumn_definition_element() []IColumn_definition_elementContext + Column_definition_element(i int) IColumn_definition_elementContext + Column_index() IColumn_indexContext + PERSISTED() antlr.TerminalNode + + // IsColumn_definitionContext differentiates from other interfaces. + IsColumn_definitionContext() +} + +type Column_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_definitionContext() *Column_definitionContext { + var p = new(Column_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_definition + return p +} + +func InitEmptyColumn_definitionContext(p *Column_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_definition +} + +func (*Column_definitionContext) IsColumn_definitionContext() {} + +func NewColumn_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_definitionContext { + var p = new(Column_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_column_definition + + return p +} + +func (s *Column_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_definitionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Column_definitionContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Column_definitionContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Column_definitionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Column_definitionContext) AllColumn_definition_element() []IColumn_definition_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_definition_elementContext); ok { + len++ + } + } + + tst := make([]IColumn_definition_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_definition_elementContext); ok { + tst[i] = t.(IColumn_definition_elementContext) + i++ + } + } + + return tst +} + +func (s *Column_definitionContext) Column_definition_element(i int) IColumn_definition_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_definition_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_definition_elementContext) +} + +func (s *Column_definitionContext) Column_index() IColumn_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_indexContext) +} + +func (s *Column_definitionContext) PERSISTED() antlr.TerminalNode { + return s.GetToken(TSqlParserPERSISTED, 0) +} + +func (s *Column_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumn_definition(s) + } +} + +func (s *Column_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumn_definition(s) + } +} + +func (s *Column_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumn_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Column_definition() (localctx IColumn_definitionContext) { + localctx = NewColumn_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 880, TSqlParserRULE_column_definition) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10617) + p.Id_() + } + p.SetState(10624) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDOUBLE, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGEOGRAPHY, TSqlParserGEOMETRY, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(10618) + p.Data_type() + } + + case TSqlParserAS: + { + p.SetState(10619) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10620) + p.expression(0) + } + p.SetState(10622) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1427, p.GetParserRuleContext()) == 1 { + { + p.SetState(10621) + p.Match(TSqlParserPERSISTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1429, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(10626) + p.Column_definition_element() + } + + } + p.SetState(10631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1429, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(10633) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1430, p.GetParserRuleContext()) == 1 { + { + p.SetState(10632) + p.Column_index() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_definition_elementContext is an interface to support dynamic dispatch. +type IColumn_definition_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMask_function returns the mask_function token. + GetMask_function() antlr.Token + + // GetSeed returns the seed token. + GetSeed() antlr.Token + + // GetIncrement returns the increment token. + GetIncrement() antlr.Token + + // GetKey_name returns the key_name token. + GetKey_name() antlr.Token + + // GetAlgo returns the algo token. + GetAlgo() antlr.Token + + // SetMask_function sets the mask_function token. + SetMask_function(antlr.Token) + + // SetSeed sets the seed token. + SetSeed(antlr.Token) + + // SetIncrement sets the increment token. + SetIncrement(antlr.Token) + + // SetKey_name sets the key_name token. + SetKey_name(antlr.Token) + + // SetAlgo sets the algo token. + SetAlgo(antlr.Token) + + // GetCollation_name returns the collation_name rule contexts. + GetCollation_name() IId_Context + + // GetConstraint returns the constraint rule contexts. + GetConstraint() IId_Context + + // GetConstant_expr returns the constant_expr rule contexts. + GetConstant_expr() IExpressionContext + + // SetCollation_name sets the collation_name rule contexts. + SetCollation_name(IId_Context) + + // SetConstraint sets the constraint rule contexts. + SetConstraint(IId_Context) + + // SetConstant_expr sets the constant_expr rule contexts. + SetConstant_expr(IExpressionContext) + + // Getter signatures + FILESTREAM() antlr.TerminalNode + COLLATE() antlr.TerminalNode + Id_() IId_Context + SPARSE() antlr.TerminalNode + MASKED() antlr.TerminalNode + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + DEFAULT() antlr.TerminalNode + Expression() IExpressionContext + CONSTRAINT() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + NOT() antlr.TerminalNode + FOR() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + GENERATED() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + AS() antlr.TerminalNode + ROW() antlr.TerminalNode + TRANSACTION_ID() antlr.TerminalNode + SEQUENCE_NUMBER() antlr.TerminalNode + START() antlr.TerminalNode + END() antlr.TerminalNode + HIDDEN_KEYWORD() antlr.TerminalNode + ROWGUIDCOL() antlr.TerminalNode + ENCRYPTED() antlr.TerminalNode + COLUMN_ENCRYPTION_KEY() antlr.TerminalNode + ENCRYPTION_TYPE() antlr.TerminalNode + ALGORITHM() antlr.TerminalNode + DETERMINISTIC() antlr.TerminalNode + RANDOMIZED() antlr.TerminalNode + Column_constraint() IColumn_constraintContext + + // IsColumn_definition_elementContext differentiates from other interfaces. + IsColumn_definition_elementContext() +} + +type Column_definition_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + collation_name IId_Context + mask_function antlr.Token + constraint IId_Context + constant_expr IExpressionContext + seed antlr.Token + increment antlr.Token + key_name antlr.Token + algo antlr.Token +} + +func NewEmptyColumn_definition_elementContext() *Column_definition_elementContext { + var p = new(Column_definition_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_definition_element + return p +} + +func InitEmptyColumn_definition_elementContext(p *Column_definition_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_definition_element +} + +func (*Column_definition_elementContext) IsColumn_definition_elementContext() {} + +func NewColumn_definition_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_definition_elementContext { + var p = new(Column_definition_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_column_definition_element + + return p +} + +func (s *Column_definition_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_definition_elementContext) GetMask_function() antlr.Token { return s.mask_function } + +func (s *Column_definition_elementContext) GetSeed() antlr.Token { return s.seed } + +func (s *Column_definition_elementContext) GetIncrement() antlr.Token { return s.increment } + +func (s *Column_definition_elementContext) GetKey_name() antlr.Token { return s.key_name } + +func (s *Column_definition_elementContext) GetAlgo() antlr.Token { return s.algo } + +func (s *Column_definition_elementContext) SetMask_function(v antlr.Token) { s.mask_function = v } + +func (s *Column_definition_elementContext) SetSeed(v antlr.Token) { s.seed = v } + +func (s *Column_definition_elementContext) SetIncrement(v antlr.Token) { s.increment = v } + +func (s *Column_definition_elementContext) SetKey_name(v antlr.Token) { s.key_name = v } + +func (s *Column_definition_elementContext) SetAlgo(v antlr.Token) { s.algo = v } + +func (s *Column_definition_elementContext) GetCollation_name() IId_Context { return s.collation_name } + +func (s *Column_definition_elementContext) GetConstraint() IId_Context { return s.constraint } + +func (s *Column_definition_elementContext) GetConstant_expr() IExpressionContext { + return s.constant_expr +} + +func (s *Column_definition_elementContext) SetCollation_name(v IId_Context) { s.collation_name = v } + +func (s *Column_definition_elementContext) SetConstraint(v IId_Context) { s.constraint = v } + +func (s *Column_definition_elementContext) SetConstant_expr(v IExpressionContext) { + s.constant_expr = v +} + +func (s *Column_definition_elementContext) FILESTREAM() antlr.TerminalNode { + return s.GetToken(TSqlParserFILESTREAM, 0) +} + +func (s *Column_definition_elementContext) COLLATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLATE, 0) +} + +func (s *Column_definition_elementContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Column_definition_elementContext) SPARSE() antlr.TerminalNode { + return s.GetToken(TSqlParserSPARSE, 0) +} + +func (s *Column_definition_elementContext) MASKED() antlr.TerminalNode { + return s.GetToken(TSqlParserMASKED, 0) +} + +func (s *Column_definition_elementContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Column_definition_elementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Column_definition_elementContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(TSqlParserFUNCTION, 0) +} + +func (s *Column_definition_elementContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Column_definition_elementContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Column_definition_elementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Column_definition_elementContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Column_definition_elementContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Column_definition_elementContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Column_definition_elementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Column_definition_elementContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONSTRAINT, 0) +} + +func (s *Column_definition_elementContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENTITY, 0) +} + +func (s *Column_definition_elementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Column_definition_elementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Column_definition_elementContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Column_definition_elementContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Column_definition_elementContext) NOT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, 0) +} + +func (s *Column_definition_elementContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Column_definition_elementContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLICATION, 0) +} + +func (s *Column_definition_elementContext) GENERATED() antlr.TerminalNode { + return s.GetToken(TSqlParserGENERATED, 0) +} + +func (s *Column_definition_elementContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(TSqlParserALWAYS, 0) +} + +func (s *Column_definition_elementContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Column_definition_elementContext) ROW() antlr.TerminalNode { + return s.GetToken(TSqlParserROW, 0) +} + +func (s *Column_definition_elementContext) TRANSACTION_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserTRANSACTION_ID, 0) +} + +func (s *Column_definition_elementContext) SEQUENCE_NUMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserSEQUENCE_NUMBER, 0) +} + +func (s *Column_definition_elementContext) START() antlr.TerminalNode { + return s.GetToken(TSqlParserSTART, 0) +} + +func (s *Column_definition_elementContext) END() antlr.TerminalNode { + return s.GetToken(TSqlParserEND, 0) +} + +func (s *Column_definition_elementContext) HIDDEN_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserHIDDEN_KEYWORD, 0) +} + +func (s *Column_definition_elementContext) ROWGUIDCOL() antlr.TerminalNode { + return s.GetToken(TSqlParserROWGUIDCOL, 0) +} + +func (s *Column_definition_elementContext) ENCRYPTED() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTED, 0) +} + +func (s *Column_definition_elementContext) COLUMN_ENCRYPTION_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMN_ENCRYPTION_KEY, 0) +} + +func (s *Column_definition_elementContext) ENCRYPTION_TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION_TYPE, 0) +} + +func (s *Column_definition_elementContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(TSqlParserALGORITHM, 0) +} + +func (s *Column_definition_elementContext) DETERMINISTIC() antlr.TerminalNode { + return s.GetToken(TSqlParserDETERMINISTIC, 0) +} + +func (s *Column_definition_elementContext) RANDOMIZED() antlr.TerminalNode { + return s.GetToken(TSqlParserRANDOMIZED, 0) +} + +func (s *Column_definition_elementContext) Column_constraint() IColumn_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_constraintContext) +} + +func (s *Column_definition_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_definition_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_definition_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumn_definition_element(s) + } +} + +func (s *Column_definition_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumn_definition_element(s) + } +} + +func (s *Column_definition_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumn_definition_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Column_definition_element() (localctx IColumn_definition_elementContext) { + localctx = NewColumn_definition_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 882, TSqlParserRULE_column_definition_element) + var _la int + + p.SetState(10688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1434, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10635) + p.Match(TSqlParserFILESTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10636) + p.Match(TSqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10637) + + var _x = p.Id_() + + localctx.(*Column_definition_elementContext).collation_name = _x + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10638) + p.Match(TSqlParserSPARSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10639) + p.Match(TSqlParserMASKED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10640) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10641) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10642) + p.Match(TSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10643) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10644) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Column_definition_elementContext).mask_function = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10645) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + p.SetState(10648) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCONSTRAINT { + { + p.SetState(10646) + p.Match(TSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10647) + + var _x = p.Id_() + + localctx.(*Column_definition_elementContext).constraint = _x + } + + } + { + p.SetState(10650) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10651) + + var _x = p.expression(0) + + localctx.(*Column_definition_elementContext).constant_expr = _x + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10652) + p.Match(TSqlParserIDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10658) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1432, p.GetParserRuleContext()) == 1 { + { + p.SetState(10653) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10654) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Column_definition_elementContext).seed = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10655) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10656) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Column_definition_elementContext).increment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10657) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(10660) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10661) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10662) + p.Match(TSqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(10663) + p.Match(TSqlParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10664) + p.Match(TSqlParserALWAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10665) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10666) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserROW || _la == TSqlParserSEQUENCE_NUMBER || _la == TSqlParserTRANSACTION_ID) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10667) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserEND || _la == TSqlParserSTART) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10669) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1433, p.GetParserRuleContext()) == 1 { + { + p.SetState(10668) + p.Match(TSqlParserHIDDEN_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(10671) + p.Match(TSqlParserROWGUIDCOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(10672) + p.Match(TSqlParserENCRYPTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10673) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10674) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10675) + p.Match(TSqlParserCOLUMN_ENCRYPTION_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10676) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10677) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Column_definition_elementContext).key_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10678) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10679) + p.Match(TSqlParserENCRYPTION_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10680) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10681) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDETERMINISTIC || _la == TSqlParserRANDOMIZED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10682) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10683) + p.Match(TSqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10684) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10685) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Column_definition_elementContext).algo = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10686) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(10687) + p.Column_constraint() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_modifierContext is an interface to support dynamic dispatch. +type IColumn_modifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + ROWGUIDCOL() antlr.TerminalNode + PERSISTED() antlr.TerminalNode + NOT() antlr.TerminalNode + FOR() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + SPARSE() antlr.TerminalNode + HIDDEN_KEYWORD() antlr.TerminalNode + MASKED() antlr.TerminalNode + WITH() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + EQUAL() antlr.TerminalNode + STRING() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + + // IsColumn_modifierContext differentiates from other interfaces. + IsColumn_modifierContext() +} + +type Column_modifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_modifierContext() *Column_modifierContext { + var p = new(Column_modifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_modifier + return p +} + +func InitEmptyColumn_modifierContext(p *Column_modifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_modifier +} + +func (*Column_modifierContext) IsColumn_modifierContext() {} + +func NewColumn_modifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_modifierContext { + var p = new(Column_modifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_column_modifier + + return p +} + +func (s *Column_modifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_modifierContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Column_modifierContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *Column_modifierContext) DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP, 0) +} + +func (s *Column_modifierContext) ROWGUIDCOL() antlr.TerminalNode { + return s.GetToken(TSqlParserROWGUIDCOL, 0) +} + +func (s *Column_modifierContext) PERSISTED() antlr.TerminalNode { + return s.GetToken(TSqlParserPERSISTED, 0) +} + +func (s *Column_modifierContext) NOT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, 0) +} + +func (s *Column_modifierContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Column_modifierContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLICATION, 0) +} + +func (s *Column_modifierContext) SPARSE() antlr.TerminalNode { + return s.GetToken(TSqlParserSPARSE, 0) +} + +func (s *Column_modifierContext) HIDDEN_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserHIDDEN_KEYWORD, 0) +} + +func (s *Column_modifierContext) MASKED() antlr.TerminalNode { + return s.GetToken(TSqlParserMASKED, 0) +} + +func (s *Column_modifierContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Column_modifierContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(TSqlParserFUNCTION, 0) +} + +func (s *Column_modifierContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Column_modifierContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Column_modifierContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Column_modifierContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Column_modifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_modifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_modifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumn_modifier(s) + } +} + +func (s *Column_modifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumn_modifier(s) + } +} + +func (s *Column_modifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumn_modifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Column_modifier() (localctx IColumn_modifierContext) { + localctx = NewColumn_modifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 884, TSqlParserRULE_column_modifier) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10690) + p.Id_() + } + { + p.SetState(10691) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserADD || _la == TSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10713) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserROWGUIDCOL: + { + p.SetState(10692) + p.Match(TSqlParserROWGUIDCOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPERSISTED: + { + p.SetState(10693) + p.Match(TSqlParserPERSISTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNOT: + { + p.SetState(10694) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10695) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10696) + p.Match(TSqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSPARSE: + { + p.SetState(10697) + p.Match(TSqlParserSPARSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserHIDDEN_KEYWORD: + { + p.SetState(10698) + p.Match(TSqlParserHIDDEN_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMASKED: + { + p.SetState(10699) + p.Match(TSqlParserMASKED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10711) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1436, p.GetParserRuleContext()) == 1 { + { + p.SetState(10700) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFUNCTION: + { + p.SetState(10701) + p.Match(TSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10702) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10703) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserLR_BRACKET: + { + p.SetState(10704) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10705) + p.Match(TSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10706) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10707) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10708) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaterialized_column_definitionContext is an interface to support dynamic dispatch. +type IMaterialized_column_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + Expression() IExpressionContext + COMPUTE() antlr.TerminalNode + AS() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsMaterialized_column_definitionContext differentiates from other interfaces. + IsMaterialized_column_definitionContext() +} + +type Materialized_column_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaterialized_column_definitionContext() *Materialized_column_definitionContext { + var p = new(Materialized_column_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_materialized_column_definition + return p +} + +func InitEmptyMaterialized_column_definitionContext(p *Materialized_column_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_materialized_column_definition +} + +func (*Materialized_column_definitionContext) IsMaterialized_column_definitionContext() {} + +func NewMaterialized_column_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Materialized_column_definitionContext { + var p = new(Materialized_column_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_materialized_column_definition + + return p +} + +func (s *Materialized_column_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Materialized_column_definitionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Materialized_column_definitionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Materialized_column_definitionContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPUTE, 0) +} + +func (s *Materialized_column_definitionContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Materialized_column_definitionContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(TSqlParserMATERIALIZED, 0) +} + +func (s *Materialized_column_definitionContext) NOT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, 0) +} + +func (s *Materialized_column_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Materialized_column_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Materialized_column_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMaterialized_column_definition(s) + } +} + +func (s *Materialized_column_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMaterialized_column_definition(s) + } +} + +func (s *Materialized_column_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMaterialized_column_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Materialized_column_definition() (localctx IMaterialized_column_definitionContext) { + localctx = NewMaterialized_column_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 886, TSqlParserRULE_materialized_column_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10715) + p.Id_() + } + { + p.SetState(10716) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAS || _la == TSqlParserCOMPUTE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10717) + p.expression(0) + } + p.SetState(10721) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1438, p.GetParserRuleContext()) == 1 { + { + p.SetState(10718) + p.Match(TSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1438, p.GetParserRuleContext()) == 2 { + { + p.SetState(10719) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10720) + p.Match(TSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_constraintContext is an interface to support dynamic dispatch. +type IColumn_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetConstraint returns the constraint rule contexts. + GetConstraint() IId_Context + + // SetConstraint sets the constraint rule contexts. + SetConstraint(IId_Context) + + // Getter signatures + Null_notnull() INull_notnullContext + Check_constraint() ICheck_constraintContext + CONSTRAINT() antlr.TerminalNode + Id_() IId_Context + Primary_key_options() IPrimary_key_optionsContext + Foreign_key_options() IForeign_key_optionsContext + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + Clustered() IClusteredContext + FOREIGN() antlr.TerminalNode + + // IsColumn_constraintContext differentiates from other interfaces. + IsColumn_constraintContext() +} + +type Column_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + constraint IId_Context +} + +func NewEmptyColumn_constraintContext() *Column_constraintContext { + var p = new(Column_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_constraint + return p +} + +func InitEmptyColumn_constraintContext(p *Column_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_constraint +} + +func (*Column_constraintContext) IsColumn_constraintContext() {} + +func NewColumn_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_constraintContext { + var p = new(Column_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_column_constraint + + return p +} + +func (s *Column_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_constraintContext) GetConstraint() IId_Context { return s.constraint } + +func (s *Column_constraintContext) SetConstraint(v IId_Context) { s.constraint = v } + +func (s *Column_constraintContext) Null_notnull() INull_notnullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_notnullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_notnullContext) +} + +func (s *Column_constraintContext) Check_constraint() ICheck_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICheck_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICheck_constraintContext) +} + +func (s *Column_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONSTRAINT, 0) +} + +func (s *Column_constraintContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Column_constraintContext) Primary_key_options() IPrimary_key_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_key_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_key_optionsContext) +} + +func (s *Column_constraintContext) Foreign_key_options() IForeign_key_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_optionsContext) +} + +func (s *Column_constraintContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIMARY, 0) +} + +func (s *Column_constraintContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Column_constraintContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(TSqlParserUNIQUE, 0) +} + +func (s *Column_constraintContext) Clustered() IClusteredContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClusteredContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClusteredContext) +} + +func (s *Column_constraintContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserFOREIGN, 0) +} + +func (s *Column_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumn_constraint(s) + } +} + +func (s *Column_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumn_constraint(s) + } +} + +func (s *Column_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumn_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Column_constraint() (localctx IColumn_constraintContext) { + localctx = NewColumn_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 888, TSqlParserRULE_column_constraint) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCONSTRAINT { + { + p.SetState(10723) + p.Match(TSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10724) + + var _x = p.Id_() + + localctx.(*Column_constraintContext).constraint = _x + } + + } + p.SetState(10743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserNOT, TSqlParserNULL_: + { + p.SetState(10727) + p.Null_notnull() + } + + case TSqlParserPRIMARY, TSqlParserUNIQUE: + p.SetState(10731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPRIMARY: + { + p.SetState(10728) + p.Match(TSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10729) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserUNIQUE: + { + p.SetState(10730) + p.Match(TSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10734) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCLUSTERED || _la == TSqlParserNONCLUSTERED { + { + p.SetState(10733) + p.Clustered() + } + + } + { + p.SetState(10736) + p.Primary_key_options() + } + + case TSqlParserFOREIGN, TSqlParserREFERENCES: + p.SetState(10739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOREIGN { + { + p.SetState(10737) + p.Match(TSqlParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10738) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10741) + p.Foreign_key_options() + } + + case TSqlParserCHECK: + { + p.SetState(10742) + p.Check_constraint() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_indexContext is an interface to support dynamic dispatch. +type IColumn_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIndex_name returns the index_name rule contexts. + GetIndex_name() IId_Context + + // GetFilestream_filegroup_or_partition_schema_name returns the filestream_filegroup_or_partition_schema_name rule contexts. + GetFilestream_filegroup_or_partition_schema_name() IId_Context + + // SetIndex_name sets the index_name rule contexts. + SetIndex_name(IId_Context) + + // SetFilestream_filegroup_or_partition_schema_name sets the filestream_filegroup_or_partition_schema_name rule contexts. + SetFilestream_filegroup_or_partition_schema_name(IId_Context) + + // Getter signatures + INDEX() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + Clustered() IClusteredContext + Create_table_index_options() ICreate_table_index_optionsContext + On_partition_or_filegroup() IOn_partition_or_filegroupContext + FILESTREAM_ON() antlr.TerminalNode + NULL_DOUBLE_QUOTE() antlr.TerminalNode + + // IsColumn_indexContext differentiates from other interfaces. + IsColumn_indexContext() +} + +type Column_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + index_name IId_Context + filestream_filegroup_or_partition_schema_name IId_Context +} + +func NewEmptyColumn_indexContext() *Column_indexContext { + var p = new(Column_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_index + return p +} + +func InitEmptyColumn_indexContext(p *Column_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_index +} + +func (*Column_indexContext) IsColumn_indexContext() {} + +func NewColumn_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_indexContext { + var p = new(Column_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_column_index + + return p +} + +func (s *Column_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_indexContext) GetIndex_name() IId_Context { return s.index_name } + +func (s *Column_indexContext) GetFilestream_filegroup_or_partition_schema_name() IId_Context { + return s.filestream_filegroup_or_partition_schema_name +} + +func (s *Column_indexContext) SetIndex_name(v IId_Context) { s.index_name = v } + +func (s *Column_indexContext) SetFilestream_filegroup_or_partition_schema_name(v IId_Context) { + s.filestream_filegroup_or_partition_schema_name = v +} + +func (s *Column_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Column_indexContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Column_indexContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Column_indexContext) Clustered() IClusteredContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClusteredContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClusteredContext) +} + +func (s *Column_indexContext) Create_table_index_options() ICreate_table_index_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_table_index_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_table_index_optionsContext) +} + +func (s *Column_indexContext) On_partition_or_filegroup() IOn_partition_or_filegroupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_partition_or_filegroupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_partition_or_filegroupContext) +} + +func (s *Column_indexContext) FILESTREAM_ON() antlr.TerminalNode { + return s.GetToken(TSqlParserFILESTREAM_ON, 0) +} + +func (s *Column_indexContext) NULL_DOUBLE_QUOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_DOUBLE_QUOTE, 0) +} + +func (s *Column_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumn_index(s) + } +} + +func (s *Column_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumn_index(s) + } +} + +func (s *Column_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumn_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Column_index() (localctx IColumn_indexContext) { + localctx = NewColumn_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 890, TSqlParserRULE_column_index) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10745) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10746) + + var _x = p.Id_() + + localctx.(*Column_indexContext).index_name = _x + } + p.SetState(10748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCLUSTERED || _la == TSqlParserNONCLUSTERED { + { + p.SetState(10747) + p.Clustered() + } + + } + p.SetState(10751) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1445, p.GetParserRuleContext()) == 1 { + { + p.SetState(10750) + p.Create_table_index_options() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(10753) + p.On_partition_or_filegroup() + } + + } + p.SetState(10761) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1448, p.GetParserRuleContext()) == 1 { + { + p.SetState(10756) + p.Match(TSqlParserFILESTREAM_ON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10759) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1447, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10757) + + var _x = p.Id_() + + localctx.(*Column_indexContext).filestream_filegroup_or_partition_schema_name = _x + } + + case 2: + { + p.SetState(10758) + p.Match(TSqlParserNULL_DOUBLE_QUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_partition_or_filegroupContext is an interface to support dynamic dispatch. +type IOn_partition_or_filegroupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPartition_scheme_name returns the partition_scheme_name rule contexts. + GetPartition_scheme_name() IId_Context + + // GetPartition_column_name returns the partition_column_name rule contexts. + GetPartition_column_name() IId_Context + + // GetFilegroup returns the filegroup rule contexts. + GetFilegroup() IId_Context + + // SetPartition_scheme_name sets the partition_scheme_name rule contexts. + SetPartition_scheme_name(IId_Context) + + // SetPartition_column_name sets the partition_column_name rule contexts. + SetPartition_column_name(IId_Context) + + // SetFilegroup sets the filegroup rule contexts. + SetFilegroup(IId_Context) + + // Getter signatures + ON() antlr.TerminalNode + DEFAULT_DOUBLE_QUOTE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + + // IsOn_partition_or_filegroupContext differentiates from other interfaces. + IsOn_partition_or_filegroupContext() +} + +type On_partition_or_filegroupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + partition_scheme_name IId_Context + partition_column_name IId_Context + filegroup IId_Context +} + +func NewEmptyOn_partition_or_filegroupContext() *On_partition_or_filegroupContext { + var p = new(On_partition_or_filegroupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_on_partition_or_filegroup + return p +} + +func InitEmptyOn_partition_or_filegroupContext(p *On_partition_or_filegroupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_on_partition_or_filegroup +} + +func (*On_partition_or_filegroupContext) IsOn_partition_or_filegroupContext() {} + +func NewOn_partition_or_filegroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_partition_or_filegroupContext { + var p = new(On_partition_or_filegroupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_on_partition_or_filegroup + + return p +} + +func (s *On_partition_or_filegroupContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_partition_or_filegroupContext) GetPartition_scheme_name() IId_Context { + return s.partition_scheme_name +} + +func (s *On_partition_or_filegroupContext) GetPartition_column_name() IId_Context { + return s.partition_column_name +} + +func (s *On_partition_or_filegroupContext) GetFilegroup() IId_Context { return s.filegroup } + +func (s *On_partition_or_filegroupContext) SetPartition_scheme_name(v IId_Context) { + s.partition_scheme_name = v +} + +func (s *On_partition_or_filegroupContext) SetPartition_column_name(v IId_Context) { + s.partition_column_name = v +} + +func (s *On_partition_or_filegroupContext) SetFilegroup(v IId_Context) { s.filegroup = v } + +func (s *On_partition_or_filegroupContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *On_partition_or_filegroupContext) DEFAULT_DOUBLE_QUOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_DOUBLE_QUOTE, 0) +} + +func (s *On_partition_or_filegroupContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *On_partition_or_filegroupContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *On_partition_or_filegroupContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *On_partition_or_filegroupContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *On_partition_or_filegroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_partition_or_filegroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_partition_or_filegroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOn_partition_or_filegroup(s) + } +} + +func (s *On_partition_or_filegroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOn_partition_or_filegroup(s) + } +} + +func (s *On_partition_or_filegroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOn_partition_or_filegroup(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) On_partition_or_filegroup() (localctx IOn_partition_or_filegroupContext) { + localctx = NewOn_partition_or_filegroupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 892, TSqlParserRULE_on_partition_or_filegroup) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10763) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10771) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1449, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10764) + + var _x = p.Id_() + + localctx.(*On_partition_or_filegroupContext).partition_scheme_name = _x + } + { + p.SetState(10765) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10766) + + var _x = p.Id_() + + localctx.(*On_partition_or_filegroupContext).partition_column_name = _x + } + { + p.SetState(10767) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(10769) + + var _x = p.Id_() + + localctx.(*On_partition_or_filegroupContext).filegroup = _x + } + + case 3: + { + p.SetState(10770) + p.Match(TSqlParserDEFAULT_DOUBLE_QUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_constraintContext is an interface to support dynamic dispatch. +type ITable_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetConstraint returns the constraint rule contexts. + GetConstraint() IId_Context + + // GetFk returns the fk rule contexts. + GetFk() IColumn_name_listContext + + // GetConstant_expr returns the constant_expr rule contexts. + GetConstant_expr() IExpressionContext + + // GetColumn returns the column rule contexts. + GetColumn() IId_Context + + // SetConstraint sets the constraint rule contexts. + SetConstraint(IId_Context) + + // SetFk sets the fk rule contexts. + SetFk(IColumn_name_listContext) + + // SetConstant_expr sets the constant_expr rule contexts. + SetConstant_expr(IExpressionContext) + + // SetColumn sets the column rule contexts. + SetColumn(IId_Context) + + // Getter signatures + Check_constraint() ICheck_constraintContext + CONSTRAINT() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + LR_BRACKET() antlr.TerminalNode + Column_name_list_with_order() IColumn_name_list_with_orderContext + RR_BRACKET() antlr.TerminalNode + Primary_key_options() IPrimary_key_optionsContext + FOREIGN() antlr.TerminalNode + KEY() antlr.TerminalNode + Foreign_key_options() IForeign_key_optionsContext + CONNECTION() antlr.TerminalNode + AllConnection_node() []IConnection_nodeContext + Connection_node(i int) IConnection_nodeContext + DEFAULT() antlr.TerminalNode + FOR() antlr.TerminalNode + Column_name_list() IColumn_name_listContext + Expression() IExpressionContext + PRIMARY() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + Clustered() IClusteredContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + VALUES() antlr.TerminalNode + + // IsTable_constraintContext differentiates from other interfaces. + IsTable_constraintContext() +} + +type Table_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + constraint IId_Context + fk IColumn_name_listContext + constant_expr IExpressionContext + column IId_Context +} + +func NewEmptyTable_constraintContext() *Table_constraintContext { + var p = new(Table_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_constraint + return p +} + +func InitEmptyTable_constraintContext(p *Table_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_constraint +} + +func (*Table_constraintContext) IsTable_constraintContext() {} + +func NewTable_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_constraintContext { + var p = new(Table_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_table_constraint + + return p +} + +func (s *Table_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_constraintContext) GetConstraint() IId_Context { return s.constraint } + +func (s *Table_constraintContext) GetFk() IColumn_name_listContext { return s.fk } + +func (s *Table_constraintContext) GetConstant_expr() IExpressionContext { return s.constant_expr } + +func (s *Table_constraintContext) GetColumn() IId_Context { return s.column } + +func (s *Table_constraintContext) SetConstraint(v IId_Context) { s.constraint = v } + +func (s *Table_constraintContext) SetFk(v IColumn_name_listContext) { s.fk = v } + +func (s *Table_constraintContext) SetConstant_expr(v IExpressionContext) { s.constant_expr = v } + +func (s *Table_constraintContext) SetColumn(v IId_Context) { s.column = v } + +func (s *Table_constraintContext) Check_constraint() ICheck_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICheck_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICheck_constraintContext) +} + +func (s *Table_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONSTRAINT, 0) +} + +func (s *Table_constraintContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Table_constraintContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Table_constraintContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Table_constraintContext) Column_name_list_with_order() IColumn_name_list_with_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_list_with_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_list_with_orderContext) +} + +func (s *Table_constraintContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Table_constraintContext) Primary_key_options() IPrimary_key_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_key_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_key_optionsContext) +} + +func (s *Table_constraintContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserFOREIGN, 0) +} + +func (s *Table_constraintContext) KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY, 0) +} + +func (s *Table_constraintContext) Foreign_key_options() IForeign_key_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_optionsContext) +} + +func (s *Table_constraintContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONNECTION, 0) +} + +func (s *Table_constraintContext) AllConnection_node() []IConnection_nodeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConnection_nodeContext); ok { + len++ + } + } + + tst := make([]IConnection_nodeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConnection_nodeContext); ok { + tst[i] = t.(IConnection_nodeContext) + i++ + } + } + + return tst +} + +func (s *Table_constraintContext) Connection_node(i int) IConnection_nodeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConnection_nodeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConnection_nodeContext) +} + +func (s *Table_constraintContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Table_constraintContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Table_constraintContext) Column_name_list() IColumn_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Table_constraintContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Table_constraintContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIMARY, 0) +} + +func (s *Table_constraintContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(TSqlParserUNIQUE, 0) +} + +func (s *Table_constraintContext) Clustered() IClusteredContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClusteredContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClusteredContext) +} + +func (s *Table_constraintContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Table_constraintContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Table_constraintContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Table_constraintContext) VALUES() antlr.TerminalNode { + return s.GetToken(TSqlParserVALUES, 0) +} + +func (s *Table_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTable_constraint(s) + } +} + +func (s *Table_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTable_constraint(s) + } +} + +func (s *Table_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTable_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Table_constraint() (localctx ITable_constraintContext) { + localctx = NewTable_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 894, TSqlParserRULE_table_constraint) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCONSTRAINT { + { + p.SetState(10773) + p.Match(TSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10774) + + var _x = p.Id_() + + localctx.(*Table_constraintContext).constraint = _x + } + + } + p.SetState(10818) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPRIMARY, TSqlParserUNIQUE: + p.SetState(10780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPRIMARY: + { + p.SetState(10777) + p.Match(TSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10778) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserUNIQUE: + { + p.SetState(10779) + p.Match(TSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10783) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCLUSTERED || _la == TSqlParserNONCLUSTERED { + { + p.SetState(10782) + p.Clustered() + } + + } + { + p.SetState(10785) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10786) + p.Column_name_list_with_order() + } + { + p.SetState(10787) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10788) + p.Primary_key_options() + } + + case TSqlParserFOREIGN: + { + p.SetState(10790) + p.Match(TSqlParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10791) + p.Match(TSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10792) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10793) + + var _x = p.Column_name_list() + + localctx.(*Table_constraintContext).fk = _x + } + { + p.SetState(10794) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10795) + p.Foreign_key_options() + } + + case TSqlParserCONNECTION: + { + p.SetState(10797) + p.Match(TSqlParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10798) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10799) + p.Connection_node() + } + p.SetState(10804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(10800) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10801) + p.Connection_node() + } + + p.SetState(10806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10807) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDEFAULT: + { + p.SetState(10809) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10810) + + var _x = p.expression(0) + + localctx.(*Table_constraintContext).constant_expr = _x + } + { + p.SetState(10811) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10812) + + var _x = p.Id_() + + localctx.(*Table_constraintContext).column = _x + } + p.SetState(10815) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1454, p.GetParserRuleContext()) == 1 { + { + p.SetState(10813) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10814) + p.Match(TSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserCHECK: + { + p.SetState(10817) + p.Check_constraint() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConnection_nodeContext is an interface to support dynamic dispatch. +type IConnection_nodeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFrom_node_table returns the from_node_table rule contexts. + GetFrom_node_table() IId_Context + + // GetTo_node_table returns the to_node_table rule contexts. + GetTo_node_table() IId_Context + + // SetFrom_node_table sets the from_node_table rule contexts. + SetFrom_node_table(IId_Context) + + // SetTo_node_table sets the to_node_table rule contexts. + SetTo_node_table(IId_Context) + + // Getter signatures + TO() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + + // IsConnection_nodeContext differentiates from other interfaces. + IsConnection_nodeContext() +} + +type Connection_nodeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + from_node_table IId_Context + to_node_table IId_Context +} + +func NewEmptyConnection_nodeContext() *Connection_nodeContext { + var p = new(Connection_nodeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_connection_node + return p +} + +func InitEmptyConnection_nodeContext(p *Connection_nodeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_connection_node +} + +func (*Connection_nodeContext) IsConnection_nodeContext() {} + +func NewConnection_nodeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Connection_nodeContext { + var p = new(Connection_nodeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_connection_node + + return p +} + +func (s *Connection_nodeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Connection_nodeContext) GetFrom_node_table() IId_Context { return s.from_node_table } + +func (s *Connection_nodeContext) GetTo_node_table() IId_Context { return s.to_node_table } + +func (s *Connection_nodeContext) SetFrom_node_table(v IId_Context) { s.from_node_table = v } + +func (s *Connection_nodeContext) SetTo_node_table(v IId_Context) { s.to_node_table = v } + +func (s *Connection_nodeContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Connection_nodeContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Connection_nodeContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Connection_nodeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Connection_nodeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Connection_nodeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterConnection_node(s) + } +} + +func (s *Connection_nodeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitConnection_node(s) + } +} + +func (s *Connection_nodeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitConnection_node(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Connection_node() (localctx IConnection_nodeContext) { + localctx = NewConnection_nodeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 896, TSqlParserRULE_connection_node) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10820) + + var _x = p.Id_() + + localctx.(*Connection_nodeContext).from_node_table = _x + } + { + p.SetState(10821) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10822) + + var _x = p.Id_() + + localctx.(*Connection_nodeContext).to_node_table = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimary_key_optionsContext is an interface to support dynamic dispatch. +type IPrimary_key_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + FILLFACTOR() antlr.TerminalNode + EQUAL() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + Alter_table_index_options() IAlter_table_index_optionsContext + On_partition_or_filegroup() IOn_partition_or_filegroupContext + + // IsPrimary_key_optionsContext differentiates from other interfaces. + IsPrimary_key_optionsContext() +} + +type Primary_key_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimary_key_optionsContext() *Primary_key_optionsContext { + var p = new(Primary_key_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_primary_key_options + return p +} + +func InitEmptyPrimary_key_optionsContext(p *Primary_key_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_primary_key_options +} + +func (*Primary_key_optionsContext) IsPrimary_key_optionsContext() {} + +func NewPrimary_key_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primary_key_optionsContext { + var p = new(Primary_key_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_primary_key_options + + return p +} + +func (s *Primary_key_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primary_key_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Primary_key_optionsContext) FILLFACTOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFILLFACTOR, 0) +} + +func (s *Primary_key_optionsContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Primary_key_optionsContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Primary_key_optionsContext) Alter_table_index_options() IAlter_table_index_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_table_index_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_table_index_optionsContext) +} + +func (s *Primary_key_optionsContext) On_partition_or_filegroup() IOn_partition_or_filegroupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_partition_or_filegroupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_partition_or_filegroupContext) +} + +func (s *Primary_key_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primary_key_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primary_key_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPrimary_key_options(s) + } +} + +func (s *Primary_key_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPrimary_key_options(s) + } +} + +func (s *Primary_key_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPrimary_key_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Primary_key_options() (localctx IPrimary_key_optionsContext) { + localctx = NewPrimary_key_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 898, TSqlParserRULE_primary_key_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10828) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1456, p.GetParserRuleContext()) == 1 { + { + p.SetState(10824) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10825) + p.Match(TSqlParserFILLFACTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10826) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10827) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10831) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1457, p.GetParserRuleContext()) == 1 { + { + p.SetState(10830) + p.Alter_table_index_options() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10834) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(10833) + p.On_partition_or_filegroup() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForeign_key_optionsContext is an interface to support dynamic dispatch. +type IForeign_key_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPk returns the pk rule contexts. + GetPk() IColumn_name_listContext + + // SetPk sets the pk rule contexts. + SetPk(IColumn_name_listContext) + + // Getter signatures + REFERENCES() antlr.TerminalNode + Table_name() ITable_nameContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Column_name_list() IColumn_name_listContext + AllOn_delete() []IOn_deleteContext + On_delete(i int) IOn_deleteContext + AllOn_update() []IOn_updateContext + On_update(i int) IOn_updateContext + NOT() antlr.TerminalNode + FOR() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + + // IsForeign_key_optionsContext differentiates from other interfaces. + IsForeign_key_optionsContext() +} + +type Foreign_key_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + pk IColumn_name_listContext +} + +func NewEmptyForeign_key_optionsContext() *Foreign_key_optionsContext { + var p = new(Foreign_key_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_foreign_key_options + return p +} + +func InitEmptyForeign_key_optionsContext(p *Foreign_key_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_foreign_key_options +} + +func (*Foreign_key_optionsContext) IsForeign_key_optionsContext() {} + +func NewForeign_key_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_key_optionsContext { + var p = new(Foreign_key_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_foreign_key_options + + return p +} + +func (s *Foreign_key_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Foreign_key_optionsContext) GetPk() IColumn_name_listContext { return s.pk } + +func (s *Foreign_key_optionsContext) SetPk(v IColumn_name_listContext) { s.pk = v } + +func (s *Foreign_key_optionsContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(TSqlParserREFERENCES, 0) +} + +func (s *Foreign_key_optionsContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Foreign_key_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Foreign_key_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Foreign_key_optionsContext) Column_name_list() IColumn_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Foreign_key_optionsContext) AllOn_delete() []IOn_deleteContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOn_deleteContext); ok { + len++ + } + } + + tst := make([]IOn_deleteContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOn_deleteContext); ok { + tst[i] = t.(IOn_deleteContext) + i++ + } + } + + return tst +} + +func (s *Foreign_key_optionsContext) On_delete(i int) IOn_deleteContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_deleteContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOn_deleteContext) +} + +func (s *Foreign_key_optionsContext) AllOn_update() []IOn_updateContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOn_updateContext); ok { + len++ + } + } + + tst := make([]IOn_updateContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOn_updateContext); ok { + tst[i] = t.(IOn_updateContext) + i++ + } + } + + return tst +} + +func (s *Foreign_key_optionsContext) On_update(i int) IOn_updateContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_updateContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOn_updateContext) +} + +func (s *Foreign_key_optionsContext) NOT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, 0) +} + +func (s *Foreign_key_optionsContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Foreign_key_optionsContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLICATION, 0) +} + +func (s *Foreign_key_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Foreign_key_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Foreign_key_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterForeign_key_options(s) + } +} + +func (s *Foreign_key_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitForeign_key_options(s) + } +} + +func (s *Foreign_key_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitForeign_key_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Foreign_key_options() (localctx IForeign_key_optionsContext) { + localctx = NewForeign_key_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 900, TSqlParserRULE_foreign_key_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10836) + p.Match(TSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10837) + p.Table_name() + } + { + p.SetState(10838) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10839) + + var _x = p.Column_name_list() + + localctx.(*Foreign_key_optionsContext).pk = _x + } + { + p.SetState(10840) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10845) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserON { + p.SetState(10843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1459, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10841) + p.On_delete() + } + + case 2: + { + p.SetState(10842) + p.On_update() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(10847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(10851) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1461, p.GetParserRuleContext()) == 1 { + { + p.SetState(10848) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10849) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10850) + p.Match(TSqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICheck_constraintContext is an interface to support dynamic dispatch. +type ICheck_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHECK() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Search_condition() ISearch_conditionContext + RR_BRACKET() antlr.TerminalNode + NOT() antlr.TerminalNode + FOR() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + + // IsCheck_constraintContext differentiates from other interfaces. + IsCheck_constraintContext() +} + +type Check_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCheck_constraintContext() *Check_constraintContext { + var p = new(Check_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_check_constraint + return p +} + +func InitEmptyCheck_constraintContext(p *Check_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_check_constraint +} + +func (*Check_constraintContext) IsCheck_constraintContext() {} + +func NewCheck_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Check_constraintContext { + var p = new(Check_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_check_constraint + + return p +} + +func (s *Check_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Check_constraintContext) CHECK() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECK, 0) +} + +func (s *Check_constraintContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Check_constraintContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Check_constraintContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Check_constraintContext) NOT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, 0) +} + +func (s *Check_constraintContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Check_constraintContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLICATION, 0) +} + +func (s *Check_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Check_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Check_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCheck_constraint(s) + } +} + +func (s *Check_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCheck_constraint(s) + } +} + +func (s *Check_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCheck_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Check_constraint() (localctx ICheck_constraintContext) { + localctx = NewCheck_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 902, TSqlParserRULE_check_constraint) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10853) + p.Match(TSqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10857) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserNOT { + { + p.SetState(10854) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10855) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10856) + p.Match(TSqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10859) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10860) + p.search_condition(0) + } + { + p.SetState(10861) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_deleteContext is an interface to support dynamic dispatch. +type IOn_deleteContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + DELETE() antlr.TerminalNode + NO() antlr.TerminalNode + ACTION() antlr.TerminalNode + CASCADE() antlr.TerminalNode + SET() antlr.TerminalNode + NULL_() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsOn_deleteContext differentiates from other interfaces. + IsOn_deleteContext() +} + +type On_deleteContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_deleteContext() *On_deleteContext { + var p = new(On_deleteContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_on_delete + return p +} + +func InitEmptyOn_deleteContext(p *On_deleteContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_on_delete +} + +func (*On_deleteContext) IsOn_deleteContext() {} + +func NewOn_deleteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_deleteContext { + var p = new(On_deleteContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_on_delete + + return p +} + +func (s *On_deleteContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_deleteContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *On_deleteContext) DELETE() antlr.TerminalNode { + return s.GetToken(TSqlParserDELETE, 0) +} + +func (s *On_deleteContext) NO() antlr.TerminalNode { + return s.GetToken(TSqlParserNO, 0) +} + +func (s *On_deleteContext) ACTION() antlr.TerminalNode { + return s.GetToken(TSqlParserACTION, 0) +} + +func (s *On_deleteContext) CASCADE() antlr.TerminalNode { + return s.GetToken(TSqlParserCASCADE, 0) +} + +func (s *On_deleteContext) SET() antlr.TerminalNode { + return s.GetToken(TSqlParserSET, 0) +} + +func (s *On_deleteContext) NULL_() antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_, 0) +} + +func (s *On_deleteContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *On_deleteContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_deleteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_deleteContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOn_delete(s) + } +} + +func (s *On_deleteContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOn_delete(s) + } +} + +func (s *On_deleteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOn_delete(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) On_delete() (localctx IOn_deleteContext) { + localctx = NewOn_deleteContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 904, TSqlParserRULE_on_delete) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10863) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10864) + p.Match(TSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1463, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10865) + p.Match(TSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10866) + p.Match(TSqlParserACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(10867) + p.Match(TSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(10868) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10869) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(10870) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10871) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_updateContext is an interface to support dynamic dispatch. +type IOn_updateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + UPDATE() antlr.TerminalNode + NO() antlr.TerminalNode + ACTION() antlr.TerminalNode + CASCADE() antlr.TerminalNode + SET() antlr.TerminalNode + NULL_() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsOn_updateContext differentiates from other interfaces. + IsOn_updateContext() +} + +type On_updateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_updateContext() *On_updateContext { + var p = new(On_updateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_on_update + return p +} + +func InitEmptyOn_updateContext(p *On_updateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_on_update +} + +func (*On_updateContext) IsOn_updateContext() {} + +func NewOn_updateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_updateContext { + var p = new(On_updateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_on_update + + return p +} + +func (s *On_updateContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_updateContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *On_updateContext) UPDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserUPDATE, 0) +} + +func (s *On_updateContext) NO() antlr.TerminalNode { + return s.GetToken(TSqlParserNO, 0) +} + +func (s *On_updateContext) ACTION() antlr.TerminalNode { + return s.GetToken(TSqlParserACTION, 0) +} + +func (s *On_updateContext) CASCADE() antlr.TerminalNode { + return s.GetToken(TSqlParserCASCADE, 0) +} + +func (s *On_updateContext) SET() antlr.TerminalNode { + return s.GetToken(TSqlParserSET, 0) +} + +func (s *On_updateContext) NULL_() antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_, 0) +} + +func (s *On_updateContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *On_updateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_updateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_updateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOn_update(s) + } +} + +func (s *On_updateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOn_update(s) + } +} + +func (s *On_updateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOn_update(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) On_update() (localctx IOn_updateContext) { + localctx = NewOn_updateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 906, TSqlParserRULE_on_update) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10874) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10875) + p.Match(TSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1464, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10876) + p.Match(TSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10877) + p.Match(TSqlParserACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(10878) + p.Match(TSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(10879) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10880) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(10881) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10882) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_table_index_optionsContext is an interface to support dynamic dispatch. +type IAlter_table_index_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllAlter_table_index_option() []IAlter_table_index_optionContext + Alter_table_index_option(i int) IAlter_table_index_optionContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_table_index_optionsContext differentiates from other interfaces. + IsAlter_table_index_optionsContext() +} + +type Alter_table_index_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_table_index_optionsContext() *Alter_table_index_optionsContext { + var p = new(Alter_table_index_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_table_index_options + return p +} + +func InitEmptyAlter_table_index_optionsContext(p *Alter_table_index_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_table_index_options +} + +func (*Alter_table_index_optionsContext) IsAlter_table_index_optionsContext() {} + +func NewAlter_table_index_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_index_optionsContext { + var p = new(Alter_table_index_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_table_index_options + + return p +} + +func (s *Alter_table_index_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_table_index_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Alter_table_index_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Alter_table_index_optionsContext) AllAlter_table_index_option() []IAlter_table_index_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_table_index_optionContext); ok { + len++ + } + } + + tst := make([]IAlter_table_index_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_table_index_optionContext); ok { + tst[i] = t.(IAlter_table_index_optionContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_index_optionsContext) Alter_table_index_option(i int) IAlter_table_index_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_table_index_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_table_index_optionContext) +} + +func (s *Alter_table_index_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Alter_table_index_optionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_table_index_optionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_table_index_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_table_index_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_table_index_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_table_index_options(s) + } +} + +func (s *Alter_table_index_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_table_index_options(s) + } +} + +func (s *Alter_table_index_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_table_index_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_table_index_options() (localctx IAlter_table_index_optionsContext) { + localctx = NewAlter_table_index_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 908, TSqlParserRULE_alter_table_index_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10885) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10886) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10887) + p.Alter_table_index_option() + } + p.SetState(10892) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(10888) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10889) + p.Alter_table_index_option() + } + + p.SetState(10894) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10895) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_table_index_optionContext is an interface to support dynamic dispatch. +type IAlter_table_index_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMax_degree_of_parallelism returns the max_degree_of_parallelism token. + GetMax_degree_of_parallelism() antlr.Token + + // GetTimes returns the times token. + GetTimes() antlr.Token + + // SetMax_degree_of_parallelism sets the max_degree_of_parallelism token. + SetMax_degree_of_parallelism(antlr.Token) + + // SetTimes sets the times token. + SetTimes(antlr.Token) + + // Getter signatures + PAD_INDEX() antlr.TerminalNode + EQUAL() antlr.TerminalNode + On_off() IOn_offContext + FILLFACTOR() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + IGNORE_DUP_KEY() antlr.TerminalNode + STATISTICS_NORECOMPUTE() antlr.TerminalNode + ALLOW_ROW_LOCKS() antlr.TerminalNode + ALLOW_PAGE_LOCKS() antlr.TerminalNode + OPTIMIZE_FOR_SEQUENTIAL_KEY() antlr.TerminalNode + SORT_IN_TEMPDB() antlr.TerminalNode + MAXDOP() antlr.TerminalNode + DATA_COMPRESSION() antlr.TerminalNode + NONE() antlr.TerminalNode + ROW() antlr.TerminalNode + PAGE() antlr.TerminalNode + COLUMNSTORE() antlr.TerminalNode + COLUMNSTORE_ARCHIVE() antlr.TerminalNode + On_partitions() IOn_partitionsContext + XML_COMPRESSION() antlr.TerminalNode + DISTRIBUTION() antlr.TerminalNode + HASH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RR_BRACKET() antlr.TerminalNode + CLUSTERED() antlr.TerminalNode + INDEX() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllASC() []antlr.TerminalNode + ASC(i int) antlr.TerminalNode + AllDESC() []antlr.TerminalNode + DESC(i int) antlr.TerminalNode + ONLINE() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + Low_priority_lock_wait() ILow_priority_lock_waitContext + RESUMABLE() antlr.TerminalNode + MAX_DURATION() antlr.TerminalNode + MINUTES() antlr.TerminalNode + + // IsAlter_table_index_optionContext differentiates from other interfaces. + IsAlter_table_index_optionContext() +} + +type Alter_table_index_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + max_degree_of_parallelism antlr.Token + times antlr.Token +} + +func NewEmptyAlter_table_index_optionContext() *Alter_table_index_optionContext { + var p = new(Alter_table_index_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_table_index_option + return p +} + +func InitEmptyAlter_table_index_optionContext(p *Alter_table_index_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_alter_table_index_option +} + +func (*Alter_table_index_optionContext) IsAlter_table_index_optionContext() {} + +func NewAlter_table_index_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_index_optionContext { + var p = new(Alter_table_index_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_alter_table_index_option + + return p +} + +func (s *Alter_table_index_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_table_index_optionContext) GetMax_degree_of_parallelism() antlr.Token { + return s.max_degree_of_parallelism +} + +func (s *Alter_table_index_optionContext) GetTimes() antlr.Token { return s.times } + +func (s *Alter_table_index_optionContext) SetMax_degree_of_parallelism(v antlr.Token) { + s.max_degree_of_parallelism = v +} + +func (s *Alter_table_index_optionContext) SetTimes(v antlr.Token) { s.times = v } + +func (s *Alter_table_index_optionContext) PAD_INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserPAD_INDEX, 0) +} + +func (s *Alter_table_index_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Alter_table_index_optionContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Alter_table_index_optionContext) FILLFACTOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFILLFACTOR, 0) +} + +func (s *Alter_table_index_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Alter_table_index_optionContext) IGNORE_DUP_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_DUP_KEY, 0) +} + +func (s *Alter_table_index_optionContext) STATISTICS_NORECOMPUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS_NORECOMPUTE, 0) +} + +func (s *Alter_table_index_optionContext) ALLOW_ROW_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_ROW_LOCKS, 0) +} + +func (s *Alter_table_index_optionContext) ALLOW_PAGE_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_PAGE_LOCKS, 0) +} + +func (s *Alter_table_index_optionContext) OPTIMIZE_FOR_SEQUENTIAL_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, 0) +} + +func (s *Alter_table_index_optionContext) SORT_IN_TEMPDB() antlr.TerminalNode { + return s.GetToken(TSqlParserSORT_IN_TEMPDB, 0) +} + +func (s *Alter_table_index_optionContext) MAXDOP() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXDOP, 0) +} + +func (s *Alter_table_index_optionContext) DATA_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA_COMPRESSION, 0) +} + +func (s *Alter_table_index_optionContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *Alter_table_index_optionContext) ROW() antlr.TerminalNode { + return s.GetToken(TSqlParserROW, 0) +} + +func (s *Alter_table_index_optionContext) PAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserPAGE, 0) +} + +func (s *Alter_table_index_optionContext) COLUMNSTORE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE, 0) +} + +func (s *Alter_table_index_optionContext) COLUMNSTORE_ARCHIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE_ARCHIVE, 0) +} + +func (s *Alter_table_index_optionContext) On_partitions() IOn_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_partitionsContext) +} + +func (s *Alter_table_index_optionContext) XML_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserXML_COMPRESSION, 0) +} + +func (s *Alter_table_index_optionContext) DISTRIBUTION() antlr.TerminalNode { + return s.GetToken(TSqlParserDISTRIBUTION, 0) +} + +func (s *Alter_table_index_optionContext) HASH() antlr.TerminalNode { + return s.GetToken(TSqlParserHASH, 0) +} + +func (s *Alter_table_index_optionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Alter_table_index_optionContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_table_index_optionContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_table_index_optionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Alter_table_index_optionContext) CLUSTERED() antlr.TerminalNode { + return s.GetToken(TSqlParserCLUSTERED, 0) +} + +func (s *Alter_table_index_optionContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Alter_table_index_optionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Alter_table_index_optionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Alter_table_index_optionContext) AllASC() []antlr.TerminalNode { + return s.GetTokens(TSqlParserASC) +} + +func (s *Alter_table_index_optionContext) ASC(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserASC, i) +} + +func (s *Alter_table_index_optionContext) AllDESC() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDESC) +} + +func (s *Alter_table_index_optionContext) DESC(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDESC, i) +} + +func (s *Alter_table_index_optionContext) ONLINE() antlr.TerminalNode { + return s.GetToken(TSqlParserONLINE, 0) +} + +func (s *Alter_table_index_optionContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Alter_table_index_optionContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Alter_table_index_optionContext) Low_priority_lock_wait() ILow_priority_lock_waitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILow_priority_lock_waitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILow_priority_lock_waitContext) +} + +func (s *Alter_table_index_optionContext) RESUMABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESUMABLE, 0) +} + +func (s *Alter_table_index_optionContext) MAX_DURATION() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_DURATION, 0) +} + +func (s *Alter_table_index_optionContext) MINUTES() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUTES, 0) +} + +func (s *Alter_table_index_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_table_index_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_table_index_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAlter_table_index_option(s) + } +} + +func (s *Alter_table_index_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAlter_table_index_option(s) + } +} + +func (s *Alter_table_index_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAlter_table_index_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Alter_table_index_option() (localctx IAlter_table_index_optionContext) { + localctx = NewAlter_table_index_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 910, TSqlParserRULE_alter_table_index_option) + var _la int + + p.SetState(10983) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPAD_INDEX: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10897) + p.Match(TSqlParserPAD_INDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10898) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10899) + p.On_off() + } + + case TSqlParserFILLFACTOR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10900) + p.Match(TSqlParserFILLFACTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10901) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10902) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserIGNORE_DUP_KEY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10903) + p.Match(TSqlParserIGNORE_DUP_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10904) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10905) + p.On_off() + } + + case TSqlParserSTATISTICS_NORECOMPUTE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10906) + p.Match(TSqlParserSTATISTICS_NORECOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10907) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10908) + p.On_off() + } + + case TSqlParserALLOW_ROW_LOCKS: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10909) + p.Match(TSqlParserALLOW_ROW_LOCKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10910) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10911) + p.On_off() + } + + case TSqlParserALLOW_PAGE_LOCKS: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10912) + p.Match(TSqlParserALLOW_PAGE_LOCKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10913) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10914) + p.On_off() + } + + case TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(10915) + p.Match(TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10916) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10917) + p.On_off() + } + + case TSqlParserSORT_IN_TEMPDB: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(10918) + p.Match(TSqlParserSORT_IN_TEMPDB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10919) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10920) + p.On_off() + } + + case TSqlParserMAXDOP: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(10921) + p.Match(TSqlParserMAXDOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10922) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10923) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_table_index_optionContext).max_degree_of_parallelism = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDATA_COMPRESSION: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(10924) + p.Match(TSqlParserDATA_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10925) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10926) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCOLUMNSTORE || _la == TSqlParserCOLUMNSTORE_ARCHIVE || _la == TSqlParserNONE || _la == TSqlParserPAGE || _la == TSqlParserROW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10928) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(10927) + p.On_partitions() + } + + } + + case TSqlParserXML_COMPRESSION: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(10930) + p.Match(TSqlParserXML_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10931) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10932) + p.On_off() + } + p.SetState(10934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserON { + { + p.SetState(10933) + p.On_partitions() + } + + } + + case TSqlParserDISTRIBUTION: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(10936) + p.Match(TSqlParserDISTRIBUTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10937) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10938) + p.Match(TSqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10939) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10940) + p.Id_() + } + { + p.SetState(10941) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCLUSTERED: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(10943) + p.Match(TSqlParserCLUSTERED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10944) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10945) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10946) + p.Id_() + } + p.SetState(10948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserASC || _la == TSqlParserDESC { + { + p.SetState(10947) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserASC || _la == TSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(10957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(10950) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10951) + p.Id_() + } + p.SetState(10953) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserASC || _la == TSqlParserDESC { + { + p.SetState(10952) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserASC || _la == TSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + p.SetState(10959) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10960) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserONLINE: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(10962) + p.Match(TSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10963) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserON: + { + p.SetState(10964) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLR_BRACKET { + { + p.SetState(10965) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10966) + p.Low_priority_lock_wait() + } + { + p.SetState(10967) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserOFF: + { + p.SetState(10971) + p.Match(TSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserRESUMABLE: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(10974) + p.Match(TSqlParserRESUMABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10975) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10976) + p.On_off() + } + + case TSqlParserMAX_DURATION: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(10977) + p.Match(TSqlParserMAX_DURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10978) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10979) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Alter_table_index_optionContext).times = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10981) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMINUTES { + { + p.SetState(10980) + p.Match(TSqlParserMINUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeclare_cursorContext is an interface to support dynamic dispatch. +type IDeclare_cursorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECLARE() antlr.TerminalNode + Cursor_name() ICursor_nameContext + CURSOR() antlr.TerminalNode + AllFOR() []antlr.TerminalNode + FOR(i int) antlr.TerminalNode + Select_statement_standalone() ISelect_statement_standaloneContext + SEMI() antlr.TerminalNode + Declare_set_cursor_common() IDeclare_set_cursor_commonContext + SCROLL() antlr.TerminalNode + SEMI_SENSITIVE() antlr.TerminalNode + INSENSITIVE() antlr.TerminalNode + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + UPDATE() antlr.TerminalNode + OF() antlr.TerminalNode + Column_name_list() IColumn_name_listContext + + // IsDeclare_cursorContext differentiates from other interfaces. + IsDeclare_cursorContext() +} + +type Declare_cursorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeclare_cursorContext() *Declare_cursorContext { + var p = new(Declare_cursorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_declare_cursor + return p +} + +func InitEmptyDeclare_cursorContext(p *Declare_cursorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_declare_cursor +} + +func (*Declare_cursorContext) IsDeclare_cursorContext() {} + +func NewDeclare_cursorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Declare_cursorContext { + var p = new(Declare_cursorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_declare_cursor + + return p +} + +func (s *Declare_cursorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Declare_cursorContext) DECLARE() antlr.TerminalNode { + return s.GetToken(TSqlParserDECLARE, 0) +} + +func (s *Declare_cursorContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Declare_cursorContext) CURSOR() antlr.TerminalNode { + return s.GetToken(TSqlParserCURSOR, 0) +} + +func (s *Declare_cursorContext) AllFOR() []antlr.TerminalNode { + return s.GetTokens(TSqlParserFOR) +} + +func (s *Declare_cursorContext) FOR(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, i) +} + +func (s *Declare_cursorContext) Select_statement_standalone() ISelect_statement_standaloneContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statement_standaloneContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statement_standaloneContext) +} + +func (s *Declare_cursorContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Declare_cursorContext) Declare_set_cursor_common() IDeclare_set_cursor_commonContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclare_set_cursor_commonContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeclare_set_cursor_commonContext) +} + +func (s *Declare_cursorContext) SCROLL() antlr.TerminalNode { + return s.GetToken(TSqlParserSCROLL, 0) +} + +func (s *Declare_cursorContext) SEMI_SENSITIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI_SENSITIVE, 0) +} + +func (s *Declare_cursorContext) INSENSITIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserINSENSITIVE, 0) +} + +func (s *Declare_cursorContext) READ() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD, 0) +} + +func (s *Declare_cursorContext) ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserONLY, 0) +} + +func (s *Declare_cursorContext) UPDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserUPDATE, 0) +} + +func (s *Declare_cursorContext) OF() antlr.TerminalNode { + return s.GetToken(TSqlParserOF, 0) +} + +func (s *Declare_cursorContext) Column_name_list() IColumn_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Declare_cursorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Declare_cursorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Declare_cursorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDeclare_cursor(s) + } +} + +func (s *Declare_cursorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDeclare_cursor(s) + } +} + +func (s *Declare_cursorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDeclare_cursor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Declare_cursor() (localctx IDeclare_cursorContext) { + localctx = NewDeclare_cursorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 912, TSqlParserRULE_declare_cursor) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10985) + p.Match(TSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10986) + p.Cursor_name() + } + p.SetState(11018) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1482, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10987) + p.Match(TSqlParserCURSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10997) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1477, p.GetParserRuleContext()) == 1 { + { + p.SetState(10988) + p.Declare_set_cursor_common() + } + p.SetState(10995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR { + { + p.SetState(10989) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10990) + p.Match(TSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOF { + { + p.SetState(10991) + p.Match(TSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10992) + p.Column_name_list() + } + + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.SetState(11000) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserINSENSITIVE || _la == TSqlParserSEMI_SENSITIVE { + { + p.SetState(10999) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserINSENSITIVE || _la == TSqlParserSEMI_SENSITIVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(11003) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSCROLL { + { + p.SetState(11002) + p.Match(TSqlParserSCROLL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11005) + p.Match(TSqlParserCURSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11006) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11007) + p.Select_statement_standalone() + } + p.SetState(11016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFOR { + { + p.SetState(11008) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserREAD: + { + p.SetState(11009) + p.Match(TSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11010) + p.Match(TSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserUPDATE: + { + p.SetState(11011) + p.Match(TSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserOF: + { + p.SetState(11012) + p.Match(TSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11013) + p.Column_name_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(11021) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1483, p.GetParserRuleContext()) == 1 { + { + p.SetState(11020) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeclare_set_cursor_commonContext is an interface to support dynamic dispatch. +type IDeclare_set_cursor_commonContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + Select_statement_standalone() ISelect_statement_standaloneContext + AllDeclare_set_cursor_common_partial() []IDeclare_set_cursor_common_partialContext + Declare_set_cursor_common_partial(i int) IDeclare_set_cursor_common_partialContext + + // IsDeclare_set_cursor_commonContext differentiates from other interfaces. + IsDeclare_set_cursor_commonContext() +} + +type Declare_set_cursor_commonContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeclare_set_cursor_commonContext() *Declare_set_cursor_commonContext { + var p = new(Declare_set_cursor_commonContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_declare_set_cursor_common + return p +} + +func InitEmptyDeclare_set_cursor_commonContext(p *Declare_set_cursor_commonContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_declare_set_cursor_common +} + +func (*Declare_set_cursor_commonContext) IsDeclare_set_cursor_commonContext() {} + +func NewDeclare_set_cursor_commonContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Declare_set_cursor_commonContext { + var p = new(Declare_set_cursor_commonContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_declare_set_cursor_common + + return p +} + +func (s *Declare_set_cursor_commonContext) GetParser() antlr.Parser { return s.parser } + +func (s *Declare_set_cursor_commonContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Declare_set_cursor_commonContext) Select_statement_standalone() ISelect_statement_standaloneContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statement_standaloneContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statement_standaloneContext) +} + +func (s *Declare_set_cursor_commonContext) AllDeclare_set_cursor_common_partial() []IDeclare_set_cursor_common_partialContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeclare_set_cursor_common_partialContext); ok { + len++ + } + } + + tst := make([]IDeclare_set_cursor_common_partialContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeclare_set_cursor_common_partialContext); ok { + tst[i] = t.(IDeclare_set_cursor_common_partialContext) + i++ + } + } + + return tst +} + +func (s *Declare_set_cursor_commonContext) Declare_set_cursor_common_partial(i int) IDeclare_set_cursor_common_partialContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclare_set_cursor_common_partialContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeclare_set_cursor_common_partialContext) +} + +func (s *Declare_set_cursor_commonContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Declare_set_cursor_commonContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Declare_set_cursor_commonContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDeclare_set_cursor_common(s) + } +} + +func (s *Declare_set_cursor_commonContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDeclare_set_cursor_common(s) + } +} + +func (s *Declare_set_cursor_commonContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDeclare_set_cursor_common(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Declare_set_cursor_common() (localctx IDeclare_set_cursor_commonContext) { + localctx = NewDeclare_set_cursor_commonContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 914, TSqlParserRULE_declare_set_cursor_common) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserDYNAMIC || _la == TSqlParserFAST_FORWARD || _la == TSqlParserFORWARD_ONLY || _la == TSqlParserGLOBAL || _la == TSqlParserKEYSET || _la == TSqlParserLOCAL || _la == TSqlParserOPTIMISTIC || _la == TSqlParserREAD_ONLY || _la == TSqlParserSCROLL || _la == TSqlParserSCROLL_LOCKS || _la == TSqlParserSTATIC || _la == TSqlParserTYPE_WARNING { + { + p.SetState(11023) + p.Declare_set_cursor_common_partial() + } + + p.SetState(11028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11029) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11030) + p.Select_statement_standalone() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeclare_set_cursor_common_partialContext is an interface to support dynamic dispatch. +type IDeclare_set_cursor_common_partialContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + FORWARD_ONLY() antlr.TerminalNode + SCROLL() antlr.TerminalNode + STATIC() antlr.TerminalNode + KEYSET() antlr.TerminalNode + DYNAMIC() antlr.TerminalNode + FAST_FORWARD() antlr.TerminalNode + READ_ONLY() antlr.TerminalNode + SCROLL_LOCKS() antlr.TerminalNode + OPTIMISTIC() antlr.TerminalNode + TYPE_WARNING() antlr.TerminalNode + + // IsDeclare_set_cursor_common_partialContext differentiates from other interfaces. + IsDeclare_set_cursor_common_partialContext() +} + +type Declare_set_cursor_common_partialContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeclare_set_cursor_common_partialContext() *Declare_set_cursor_common_partialContext { + var p = new(Declare_set_cursor_common_partialContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_declare_set_cursor_common_partial + return p +} + +func InitEmptyDeclare_set_cursor_common_partialContext(p *Declare_set_cursor_common_partialContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_declare_set_cursor_common_partial +} + +func (*Declare_set_cursor_common_partialContext) IsDeclare_set_cursor_common_partialContext() {} + +func NewDeclare_set_cursor_common_partialContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Declare_set_cursor_common_partialContext { + var p = new(Declare_set_cursor_common_partialContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_declare_set_cursor_common_partial + + return p +} + +func (s *Declare_set_cursor_common_partialContext) GetParser() antlr.Parser { return s.parser } + +func (s *Declare_set_cursor_common_partialContext) LOCAL() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL, 0) +} + +func (s *Declare_set_cursor_common_partialContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(TSqlParserGLOBAL, 0) +} + +func (s *Declare_set_cursor_common_partialContext) FORWARD_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserFORWARD_ONLY, 0) +} + +func (s *Declare_set_cursor_common_partialContext) SCROLL() antlr.TerminalNode { + return s.GetToken(TSqlParserSCROLL, 0) +} + +func (s *Declare_set_cursor_common_partialContext) STATIC() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATIC, 0) +} + +func (s *Declare_set_cursor_common_partialContext) KEYSET() antlr.TerminalNode { + return s.GetToken(TSqlParserKEYSET, 0) +} + +func (s *Declare_set_cursor_common_partialContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(TSqlParserDYNAMIC, 0) +} + +func (s *Declare_set_cursor_common_partialContext) FAST_FORWARD() antlr.TerminalNode { + return s.GetToken(TSqlParserFAST_FORWARD, 0) +} + +func (s *Declare_set_cursor_common_partialContext) READ_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_ONLY, 0) +} + +func (s *Declare_set_cursor_common_partialContext) SCROLL_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserSCROLL_LOCKS, 0) +} + +func (s *Declare_set_cursor_common_partialContext) OPTIMISTIC() antlr.TerminalNode { + return s.GetToken(TSqlParserOPTIMISTIC, 0) +} + +func (s *Declare_set_cursor_common_partialContext) TYPE_WARNING() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE_WARNING, 0) +} + +func (s *Declare_set_cursor_common_partialContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Declare_set_cursor_common_partialContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Declare_set_cursor_common_partialContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDeclare_set_cursor_common_partial(s) + } +} + +func (s *Declare_set_cursor_common_partialContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDeclare_set_cursor_common_partial(s) + } +} + +func (s *Declare_set_cursor_common_partialContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDeclare_set_cursor_common_partial(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Declare_set_cursor_common_partial() (localctx IDeclare_set_cursor_common_partialContext) { + localctx = NewDeclare_set_cursor_common_partialContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 916, TSqlParserRULE_declare_set_cursor_common_partial) + var _la int + + p.SetState(11037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserGLOBAL, TSqlParserLOCAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11032) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserGLOBAL || _la == TSqlParserLOCAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserFORWARD_ONLY, TSqlParserSCROLL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11033) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFORWARD_ONLY || _la == TSqlParserSCROLL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserDYNAMIC, TSqlParserFAST_FORWARD, TSqlParserKEYSET, TSqlParserSTATIC: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11034) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDYNAMIC || _la == TSqlParserFAST_FORWARD || _la == TSqlParserKEYSET || _la == TSqlParserSTATIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserOPTIMISTIC, TSqlParserREAD_ONLY, TSqlParserSCROLL_LOCKS: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11035) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOPTIMISTIC || _la == TSqlParserREAD_ONLY || _la == TSqlParserSCROLL_LOCKS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserTYPE_WARNING: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11036) + p.Match(TSqlParserTYPE_WARNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFetch_cursorContext is an interface to support dynamic dispatch. +type IFetch_cursorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FETCH() antlr.TerminalNode + Cursor_name() ICursor_nameContext + FROM() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + INTO() antlr.TerminalNode + AllLOCAL_ID() []antlr.TerminalNode + LOCAL_ID(i int) antlr.TerminalNode + SEMI() antlr.TerminalNode + NEXT() antlr.TerminalNode + PRIOR() antlr.TerminalNode + FIRST() antlr.TerminalNode + LAST() antlr.TerminalNode + Expression() IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ABSOLUTE() antlr.TerminalNode + RELATIVE() antlr.TerminalNode + + // IsFetch_cursorContext differentiates from other interfaces. + IsFetch_cursorContext() +} + +type Fetch_cursorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFetch_cursorContext() *Fetch_cursorContext { + var p = new(Fetch_cursorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_fetch_cursor + return p +} + +func InitEmptyFetch_cursorContext(p *Fetch_cursorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_fetch_cursor +} + +func (*Fetch_cursorContext) IsFetch_cursorContext() {} + +func NewFetch_cursorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fetch_cursorContext { + var p = new(Fetch_cursorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_fetch_cursor + + return p +} + +func (s *Fetch_cursorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Fetch_cursorContext) FETCH() antlr.TerminalNode { + return s.GetToken(TSqlParserFETCH, 0) +} + +func (s *Fetch_cursorContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Fetch_cursorContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Fetch_cursorContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(TSqlParserGLOBAL, 0) +} + +func (s *Fetch_cursorContext) INTO() antlr.TerminalNode { + return s.GetToken(TSqlParserINTO, 0) +} + +func (s *Fetch_cursorContext) AllLOCAL_ID() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOCAL_ID) +} + +func (s *Fetch_cursorContext) LOCAL_ID(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, i) +} + +func (s *Fetch_cursorContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Fetch_cursorContext) NEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserNEXT, 0) +} + +func (s *Fetch_cursorContext) PRIOR() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIOR, 0) +} + +func (s *Fetch_cursorContext) FIRST() antlr.TerminalNode { + return s.GetToken(TSqlParserFIRST, 0) +} + +func (s *Fetch_cursorContext) LAST() antlr.TerminalNode { + return s.GetToken(TSqlParserLAST, 0) +} + +func (s *Fetch_cursorContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Fetch_cursorContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Fetch_cursorContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Fetch_cursorContext) ABSOLUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserABSOLUTE, 0) +} + +func (s *Fetch_cursorContext) RELATIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserRELATIVE, 0) +} + +func (s *Fetch_cursorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Fetch_cursorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Fetch_cursorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFetch_cursor(s) + } +} + +func (s *Fetch_cursorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFetch_cursor(s) + } +} + +func (s *Fetch_cursorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFetch_cursor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Fetch_cursor() (localctx IFetch_cursorContext) { + localctx = NewFetch_cursorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 918, TSqlParserRULE_fetch_cursor) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11039) + p.Match(TSqlParserFETCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11049) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1487, p.GetParserRuleContext()) == 1 { + p.SetState(11046) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case TSqlParserNEXT: + { + p.SetState(11040) + p.Match(TSqlParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPRIOR: + { + p.SetState(11041) + p.Match(TSqlParserPRIOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserFIRST: + { + p.SetState(11042) + p.Match(TSqlParserFIRST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserLAST: + { + p.SetState(11043) + p.Match(TSqlParserLAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABSOLUTE, TSqlParserRELATIVE: + { + p.SetState(11044) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserABSOLUTE || _la == TSqlParserRELATIVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11045) + p.expression(0) + } + + case TSqlParserFROM: + + default: + } + { + p.SetState(11048) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11052) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1488, p.GetParserRuleContext()) == 1 { + { + p.SetState(11051) + p.Match(TSqlParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11054) + p.Cursor_name() + } + p.SetState(11064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserINTO { + { + p.SetState(11055) + p.Match(TSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11056) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11057) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11058) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(11063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(11067) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1491, p.GetParserRuleContext()) == 1 { + { + p.SetState(11066) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_specialContext is an interface to support dynamic dispatch. +type ISet_specialContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + Constant_LOCAL_ID() IConstant_LOCAL_IDContext + On_off() IOn_offContext + SEMI() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + IO() antlr.TerminalNode + TIME() antlr.TerminalNode + XML() antlr.TerminalNode + PROFILE() antlr.TerminalNode + ROWCOUNT() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + TEXTSIZE() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + ISOLATION() antlr.TerminalNode + LEVEL() antlr.TerminalNode + READ() antlr.TerminalNode + UNCOMMITTED() antlr.TerminalNode + COMMITTED() antlr.TerminalNode + REPEATABLE() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + IDENTITY_INSERT() antlr.TerminalNode + Table_name() ITable_nameContext + AllSpecial_list() []ISpecial_listContext + Special_list(i int) ISpecial_listContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Modify_method() IModify_methodContext + + // IsSet_specialContext differentiates from other interfaces. + IsSet_specialContext() +} + +type Set_specialContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_specialContext() *Set_specialContext { + var p = new(Set_specialContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_set_special + return p +} + +func InitEmptySet_specialContext(p *Set_specialContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_set_special +} + +func (*Set_specialContext) IsSet_specialContext() {} + +func NewSet_specialContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_specialContext { + var p = new(Set_specialContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_set_special + + return p +} + +func (s *Set_specialContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_specialContext) SET() antlr.TerminalNode { + return s.GetToken(TSqlParserSET, 0) +} + +func (s *Set_specialContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Set_specialContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Set_specialContext) Constant_LOCAL_ID() IConstant_LOCAL_IDContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstant_LOCAL_IDContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstant_LOCAL_IDContext) +} + +func (s *Set_specialContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Set_specialContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Set_specialContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS, 0) +} + +func (s *Set_specialContext) IO() antlr.TerminalNode { + return s.GetToken(TSqlParserIO, 0) +} + +func (s *Set_specialContext) TIME() antlr.TerminalNode { + return s.GetToken(TSqlParserTIME, 0) +} + +func (s *Set_specialContext) XML() antlr.TerminalNode { + return s.GetToken(TSqlParserXML, 0) +} + +func (s *Set_specialContext) PROFILE() antlr.TerminalNode { + return s.GetToken(TSqlParserPROFILE, 0) +} + +func (s *Set_specialContext) ROWCOUNT() antlr.TerminalNode { + return s.GetToken(TSqlParserROWCOUNT, 0) +} + +func (s *Set_specialContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Set_specialContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Set_specialContext) TEXTSIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserTEXTSIZE, 0) +} + +func (s *Set_specialContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(TSqlParserTRANSACTION, 0) +} + +func (s *Set_specialContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(TSqlParserISOLATION, 0) +} + +func (s *Set_specialContext) LEVEL() antlr.TerminalNode { + return s.GetToken(TSqlParserLEVEL, 0) +} + +func (s *Set_specialContext) READ() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD, 0) +} + +func (s *Set_specialContext) UNCOMMITTED() antlr.TerminalNode { + return s.GetToken(TSqlParserUNCOMMITTED, 0) +} + +func (s *Set_specialContext) COMMITTED() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMITTED, 0) +} + +func (s *Set_specialContext) REPEATABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserREPEATABLE, 0) +} + +func (s *Set_specialContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(TSqlParserSNAPSHOT, 0) +} + +func (s *Set_specialContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERIALIZABLE, 0) +} + +func (s *Set_specialContext) IDENTITY_INSERT() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENTITY_INSERT, 0) +} + +func (s *Set_specialContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Set_specialContext) AllSpecial_list() []ISpecial_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISpecial_listContext); ok { + len++ + } + } + + tst := make([]ISpecial_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISpecial_listContext); ok { + tst[i] = t.(ISpecial_listContext) + i++ + } + } + + return tst +} + +func (s *Set_specialContext) Special_list(i int) ISpecial_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpecial_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISpecial_listContext) +} + +func (s *Set_specialContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Set_specialContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Set_specialContext) Modify_method() IModify_methodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_methodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_methodContext) +} + +func (s *Set_specialContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_specialContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_specialContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSet_special(s) + } +} + +func (s *Set_specialContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSet_special(s) + } +} + +func (s *Set_specialContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSet_special(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Set_special() (localctx ISet_specialContext) { + localctx = NewSet_specialContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 920, TSqlParserRULE_set_special) + var _la int + + p.SetState(11136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1501, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11069) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11070) + p.Id_() + } + p.SetState(11074) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(11071) + p.Id_() + } + + case TSqlParserLOCAL_ID, TSqlParserDECIMAL, TSqlParserSTRING, TSqlParserBINARY, TSqlParserFLOAT, TSqlParserREAL, TSqlParserDOLLAR, TSqlParserMINUS, TSqlParserPLACEHOLDER: + { + p.SetState(11072) + p.Constant_LOCAL_ID() + } + + case TSqlParserOFF, TSqlParserON: + { + p.SetState(11073) + p.On_off() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(11077) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1493, p.GetParserRuleContext()) == 1 { + { + p.SetState(11076) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11079) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11080) + p.Match(TSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11081) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserIO || _la == TSqlParserPROFILE || _la == TSqlParserTIME || _la == TSqlParserXML) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11082) + p.On_off() + } + p.SetState(11084) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1494, p.GetParserRuleContext()) == 1 { + { + p.SetState(11083) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11086) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11087) + p.Match(TSqlParserROWCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11088) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOCAL_ID || _la == TSqlParserDECIMAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(11090) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1495, p.GetParserRuleContext()) == 1 { + { + p.SetState(11089) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11092) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11093) + p.Match(TSqlParserTEXTSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11094) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11096) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1496, p.GetParserRuleContext()) == 1 { + { + p.SetState(11095) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11098) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11099) + p.Match(TSqlParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11100) + p.Match(TSqlParserISOLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11101) + p.Match(TSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1497, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11102) + p.Match(TSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11103) + p.Match(TSqlParserUNCOMMITTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(11104) + p.Match(TSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11105) + p.Match(TSqlParserCOMMITTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(11106) + p.Match(TSqlParserREPEATABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11107) + p.Match(TSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(11108) + p.Match(TSqlParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(11109) + p.Match(TSqlParserSERIALIZABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(11110) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(11114) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1498, p.GetParserRuleContext()) == 1 { + { + p.SetState(11113) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11116) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11117) + p.Match(TSqlParserIDENTITY_INSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11118) + p.Table_name() + } + { + p.SetState(11119) + p.On_off() + } + p.SetState(11121) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1499, p.GetParserRuleContext()) == 1 { + { + p.SetState(11120) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(11123) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11124) + p.Special_list() + } + p.SetState(11129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11125) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11126) + p.Special_list() + } + + p.SetState(11131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11132) + p.On_off() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(11134) + p.Match(TSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11135) + p.Modify_method() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpecial_listContext is an interface to support dynamic dispatch. +type ISpecial_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ANSI_NULLS() antlr.TerminalNode + QUOTED_IDENTIFIER() antlr.TerminalNode + ANSI_PADDING() antlr.TerminalNode + ANSI_WARNINGS() antlr.TerminalNode + ANSI_DEFAULTS() antlr.TerminalNode + ANSI_NULL_DFLT_OFF() antlr.TerminalNode + ANSI_NULL_DFLT_ON() antlr.TerminalNode + ARITHABORT() antlr.TerminalNode + ARITHIGNORE() antlr.TerminalNode + CONCAT_NULL_YIELDS_NULL() antlr.TerminalNode + CURSOR_CLOSE_ON_COMMIT() antlr.TerminalNode + FMTONLY() antlr.TerminalNode + FORCEPLAN() antlr.TerminalNode + IMPLICIT_TRANSACTIONS() antlr.TerminalNode + NOCOUNT() antlr.TerminalNode + NOEXEC() antlr.TerminalNode + NUMERIC_ROUNDABORT() antlr.TerminalNode + PARSEONLY() antlr.TerminalNode + REMOTE_PROC_TRANSACTIONS() antlr.TerminalNode + SHOWPLAN_ALL() antlr.TerminalNode + SHOWPLAN_TEXT() antlr.TerminalNode + SHOWPLAN_XML() antlr.TerminalNode + XACT_ABORT() antlr.TerminalNode + + // IsSpecial_listContext differentiates from other interfaces. + IsSpecial_listContext() +} + +type Special_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpecial_listContext() *Special_listContext { + var p = new(Special_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_special_list + return p +} + +func InitEmptySpecial_listContext(p *Special_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_special_list +} + +func (*Special_listContext) IsSpecial_listContext() {} + +func NewSpecial_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Special_listContext { + var p = new(Special_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_special_list + + return p +} + +func (s *Special_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Special_listContext) ANSI_NULLS() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_NULLS, 0) +} + +func (s *Special_listContext) QUOTED_IDENTIFIER() antlr.TerminalNode { + return s.GetToken(TSqlParserQUOTED_IDENTIFIER, 0) +} + +func (s *Special_listContext) ANSI_PADDING() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_PADDING, 0) +} + +func (s *Special_listContext) ANSI_WARNINGS() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_WARNINGS, 0) +} + +func (s *Special_listContext) ANSI_DEFAULTS() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_DEFAULTS, 0) +} + +func (s *Special_listContext) ANSI_NULL_DFLT_OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_NULL_DFLT_OFF, 0) +} + +func (s *Special_listContext) ANSI_NULL_DFLT_ON() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_NULL_DFLT_ON, 0) +} + +func (s *Special_listContext) ARITHABORT() antlr.TerminalNode { + return s.GetToken(TSqlParserARITHABORT, 0) +} + +func (s *Special_listContext) ARITHIGNORE() antlr.TerminalNode { + return s.GetToken(TSqlParserARITHIGNORE, 0) +} + +func (s *Special_listContext) CONCAT_NULL_YIELDS_NULL() antlr.TerminalNode { + return s.GetToken(TSqlParserCONCAT_NULL_YIELDS_NULL, 0) +} + +func (s *Special_listContext) CURSOR_CLOSE_ON_COMMIT() antlr.TerminalNode { + return s.GetToken(TSqlParserCURSOR_CLOSE_ON_COMMIT, 0) +} + +func (s *Special_listContext) FMTONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserFMTONLY, 0) +} + +func (s *Special_listContext) FORCEPLAN() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCEPLAN, 0) +} + +func (s *Special_listContext) IMPLICIT_TRANSACTIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserIMPLICIT_TRANSACTIONS, 0) +} + +func (s *Special_listContext) NOCOUNT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOCOUNT, 0) +} + +func (s *Special_listContext) NOEXEC() antlr.TerminalNode { + return s.GetToken(TSqlParserNOEXEC, 0) +} + +func (s *Special_listContext) NUMERIC_ROUNDABORT() antlr.TerminalNode { + return s.GetToken(TSqlParserNUMERIC_ROUNDABORT, 0) +} + +func (s *Special_listContext) PARSEONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserPARSEONLY, 0) +} + +func (s *Special_listContext) REMOTE_PROC_TRANSACTIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOTE_PROC_TRANSACTIONS, 0) +} + +func (s *Special_listContext) SHOWPLAN_ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserSHOWPLAN_ALL, 0) +} + +func (s *Special_listContext) SHOWPLAN_TEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserSHOWPLAN_TEXT, 0) +} + +func (s *Special_listContext) SHOWPLAN_XML() antlr.TerminalNode { + return s.GetToken(TSqlParserSHOWPLAN_XML, 0) +} + +func (s *Special_listContext) XACT_ABORT() antlr.TerminalNode { + return s.GetToken(TSqlParserXACT_ABORT, 0) +} + +func (s *Special_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Special_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Special_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSpecial_list(s) + } +} + +func (s *Special_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSpecial_list(s) + } +} + +func (s *Special_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSpecial_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Special_list() (localctx ISpecial_listContext) { + localctx = NewSpecial_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 922, TSqlParserRULE_special_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11138) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&54110815493554176) != 0) || _la == TSqlParserCONCAT_NULL_YIELDS_NULL || _la == TSqlParserCURSOR_CLOSE_ON_COMMIT || _la == TSqlParserFMTONLY || _la == TSqlParserFORCEPLAN || _la == TSqlParserIMPLICIT_TRANSACTIONS || ((int64((_la-611)) & ^0x3f) == 0 && ((int64(1)<<(_la-611))&68719476741) != 0) || _la == TSqlParserPARSEONLY || _la == TSqlParserQUOTED_IDENTIFIER || _la == TSqlParserREMOTE_PROC_TRANSACTIONS || ((int64((_la-909)) & ^0x3f) == 0 && ((int64(1)<<(_la-909))&7) != 0) || _la == TSqlParserXACT_ABORT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstant_LOCAL_IDContext is an interface to support dynamic dispatch. +type IConstant_LOCAL_IDContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Constant() IConstantContext + LOCAL_ID() antlr.TerminalNode + + // IsConstant_LOCAL_IDContext differentiates from other interfaces. + IsConstant_LOCAL_IDContext() +} + +type Constant_LOCAL_IDContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstant_LOCAL_IDContext() *Constant_LOCAL_IDContext { + var p = new(Constant_LOCAL_IDContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_constant_LOCAL_ID + return p +} + +func InitEmptyConstant_LOCAL_IDContext(p *Constant_LOCAL_IDContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_constant_LOCAL_ID +} + +func (*Constant_LOCAL_IDContext) IsConstant_LOCAL_IDContext() {} + +func NewConstant_LOCAL_IDContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constant_LOCAL_IDContext { + var p = new(Constant_LOCAL_IDContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_constant_LOCAL_ID + + return p +} + +func (s *Constant_LOCAL_IDContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constant_LOCAL_IDContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *Constant_LOCAL_IDContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Constant_LOCAL_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constant_LOCAL_IDContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constant_LOCAL_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterConstant_LOCAL_ID(s) + } +} + +func (s *Constant_LOCAL_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitConstant_LOCAL_ID(s) + } +} + +func (s *Constant_LOCAL_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitConstant_LOCAL_ID(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Constant_LOCAL_ID() (localctx IConstant_LOCAL_IDContext) { + localctx = NewConstant_LOCAL_IDContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 924, TSqlParserRULE_constant_LOCAL_ID) + p.SetState(11142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL, TSqlParserSTRING, TSqlParserBINARY, TSqlParserFLOAT, TSqlParserREAL, TSqlParserDOLLAR, TSqlParserMINUS, TSqlParserPLACEHOLDER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11140) + p.Constant() + } + + case TSqlParserLOCAL_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11141) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionContext is an interface to support dynamic dispatch. +type IExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOp returns the op token. + GetOp() antlr.Token + + // SetOp sets the op token. + SetOp(antlr.Token) + + // Getter signatures + Primitive_expression() IPrimitive_expressionContext + Full_column_name() IFull_column_nameContext + Function_call() IFunction_callContext + Case_expression() ICase_expressionContext + Bracket_expression() IBracket_expressionContext + Unary_operator_expression() IUnary_operator_expressionContext + Over_clause() IOver_clauseContext + DOLLAR_ACTION() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + STAR() antlr.TerminalNode + DIVIDE() antlr.TerminalNode + MODULE() antlr.TerminalNode + PLUS() antlr.TerminalNode + MINUS() antlr.TerminalNode + BIT_AND() antlr.TerminalNode + BIT_XOR() antlr.TerminalNode + BIT_OR() antlr.TerminalNode + DOUBLE_BAR() antlr.TerminalNode + DOT() antlr.TerminalNode + Value_call() IValue_callContext + Query_call() IQuery_callContext + Exist_call() IExist_callContext + Modify_call() IModify_callContext + Hierarchyid_call() IHierarchyid_callContext + COLLATE() antlr.TerminalNode + Id_() IId_Context + Time_zone() ITime_zoneContext + + // IsExpressionContext differentiates from other interfaces. + IsExpressionContext() +} + +type ExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + op antlr.Token +} + +func NewEmptyExpressionContext() *ExpressionContext { + var p = new(ExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_expression + return p +} + +func InitEmptyExpressionContext(p *ExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_expression +} + +func (*ExpressionContext) IsExpressionContext() {} + +func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext { + var p = new(ExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_expression + + return p +} + +func (s *ExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionContext) GetOp() antlr.Token { return s.op } + +func (s *ExpressionContext) SetOp(v antlr.Token) { s.op = v } + +func (s *ExpressionContext) Primitive_expression() IPrimitive_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimitive_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimitive_expressionContext) +} + +func (s *ExpressionContext) Full_column_name() IFull_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *ExpressionContext) Function_call() IFunction_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_callContext) +} + +func (s *ExpressionContext) Case_expression() ICase_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_expressionContext) +} + +func (s *ExpressionContext) Bracket_expression() IBracket_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBracket_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBracket_expressionContext) +} + +func (s *ExpressionContext) Unary_operator_expression() IUnary_operator_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnary_operator_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnary_operator_expressionContext) +} + +func (s *ExpressionContext) Over_clause() IOver_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOver_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOver_clauseContext) +} + +func (s *ExpressionContext) DOLLAR_ACTION() antlr.TerminalNode { + return s.GetToken(TSqlParserDOLLAR_ACTION, 0) +} + +func (s *ExpressionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *ExpressionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ExpressionContext) STAR() antlr.TerminalNode { + return s.GetToken(TSqlParserSTAR, 0) +} + +func (s *ExpressionContext) DIVIDE() antlr.TerminalNode { + return s.GetToken(TSqlParserDIVIDE, 0) +} + +func (s *ExpressionContext) MODULE() antlr.TerminalNode { + return s.GetToken(TSqlParserMODULE, 0) +} + +func (s *ExpressionContext) PLUS() antlr.TerminalNode { + return s.GetToken(TSqlParserPLUS, 0) +} + +func (s *ExpressionContext) MINUS() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUS, 0) +} + +func (s *ExpressionContext) BIT_AND() antlr.TerminalNode { + return s.GetToken(TSqlParserBIT_AND, 0) +} + +func (s *ExpressionContext) BIT_XOR() antlr.TerminalNode { + return s.GetToken(TSqlParserBIT_XOR, 0) +} + +func (s *ExpressionContext) BIT_OR() antlr.TerminalNode { + return s.GetToken(TSqlParserBIT_OR, 0) +} + +func (s *ExpressionContext) DOUBLE_BAR() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_BAR, 0) +} + +func (s *ExpressionContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *ExpressionContext) Value_call() IValue_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValue_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValue_callContext) +} + +func (s *ExpressionContext) Query_call() IQuery_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_callContext) +} + +func (s *ExpressionContext) Exist_call() IExist_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExist_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExist_callContext) +} + +func (s *ExpressionContext) Modify_call() IModify_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_callContext) +} + +func (s *ExpressionContext) Hierarchyid_call() IHierarchyid_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHierarchyid_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHierarchyid_callContext) +} + +func (s *ExpressionContext) COLLATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLATE, 0) +} + +func (s *ExpressionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *ExpressionContext) Time_zone() ITime_zoneContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITime_zoneContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITime_zoneContext) +} + +func (s *ExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExpression(s) + } +} + +func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExpression(s) + } +} + +func (s *ExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExpression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Expression() (localctx IExpressionContext) { + return p.expression(0) +} + +func (p *TSqlParser) expression(_p int) (localctx IExpressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewExpressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IExpressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 926 + p.EnterRecursionRule(localctx, 926, TSqlParserRULE_expression, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1503, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11145) + p.Primitive_expression() + } + + case 2: + { + p.SetState(11146) + p.Full_column_name() + } + + case 3: + { + p.SetState(11147) + p.Function_call() + } + + case 4: + { + p.SetState(11148) + p.Case_expression() + } + + case 5: + { + p.SetState(11149) + p.Bracket_expression() + } + + case 6: + { + p.SetState(11150) + p.Unary_operator_expression() + } + + case 7: + { + p.SetState(11151) + p.Over_clause() + } + + case 8: + { + p.SetState(11152) + p.Match(TSqlParserDOLLAR_ACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(11179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1506, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(11177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1505, p.GetParserRuleContext()) { + case 1: + localctx = NewExpressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, TSqlParserRULE_expression) + p.SetState(11155) + + if !(p.Precpred(p.GetParserRuleContext(), 5)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", "")) + goto errorExit + } + { + p.SetState(11156) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ExpressionContext).op = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1212)) & ^0x3f) == 0 && ((int64(1)<<(_la-1212))&7) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ExpressionContext).op = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11157) + p.expression(6) + } + + case 2: + localctx = NewExpressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, TSqlParserRULE_expression) + p.SetState(11158) + + if !(p.Precpred(p.GetParserRuleContext(), 4)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) + goto errorExit + } + { + p.SetState(11159) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ExpressionContext).op = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1200)) & ^0x3f) == 0 && ((int64(1)<<(_la-1200))&1933313) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ExpressionContext).op = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11160) + p.expression(5) + } + + case 3: + localctx = NewExpressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, TSqlParserRULE_expression) + p.SetState(11161) + + if !(p.Precpred(p.GetParserRuleContext(), 11)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 11)", "")) + goto errorExit + } + { + p.SetState(11162) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET: + { + p.SetState(11163) + p.Value_call() + } + + case TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET: + { + p.SetState(11164) + p.Query_call() + } + + case TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET: + { + p.SetState(11165) + p.Exist_call() + } + + case TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET: + { + p.SetState(11166) + p.Modify_call() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 4: + localctx = NewExpressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, TSqlParserRULE_expression) + p.SetState(11169) + + if !(p.Precpred(p.GetParserRuleContext(), 10)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", "")) + goto errorExit + } + { + p.SetState(11170) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11171) + p.Hierarchyid_call() + } + + case 5: + localctx = NewExpressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, TSqlParserRULE_expression) + p.SetState(11172) + + if !(p.Precpred(p.GetParserRuleContext(), 9)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", "")) + goto errorExit + } + { + p.SetState(11173) + p.Match(TSqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11174) + p.Id_() + } + + case 6: + localctx = NewExpressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, TSqlParserRULE_expression) + p.SetState(11175) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + { + p.SetState(11176) + p.Time_zone() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(11181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1506, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParameterContext is an interface to support dynamic dispatch. +type IParameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PLACEHOLDER() antlr.TerminalNode + + // IsParameterContext differentiates from other interfaces. + IsParameterContext() +} + +type ParameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameterContext() *ParameterContext { + var p = new(ParameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_parameter + return p +} + +func InitEmptyParameterContext(p *ParameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_parameter +} + +func (*ParameterContext) IsParameterContext() {} + +func NewParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterContext { + var p = new(ParameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_parameter + + return p +} + +func (s *ParameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParameterContext) PLACEHOLDER() antlr.TerminalNode { + return s.GetToken(TSqlParserPLACEHOLDER, 0) +} + +func (s *ParameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterParameter(s) + } +} + +func (s *ParameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitParameter(s) + } +} + +func (s *ParameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitParameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Parameter() (localctx IParameterContext) { + localctx = NewParameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 928, TSqlParserRULE_parameter) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11182) + p.Match(TSqlParserPLACEHOLDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITime_zoneContext is an interface to support dynamic dispatch. +type ITime_zoneContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AT_KEYWORD() antlr.TerminalNode + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + Expression() IExpressionContext + + // IsTime_zoneContext differentiates from other interfaces. + IsTime_zoneContext() +} + +type Time_zoneContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTime_zoneContext() *Time_zoneContext { + var p = new(Time_zoneContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_time_zone + return p +} + +func InitEmptyTime_zoneContext(p *Time_zoneContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_time_zone +} + +func (*Time_zoneContext) IsTime_zoneContext() {} + +func NewTime_zoneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Time_zoneContext { + var p = new(Time_zoneContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_time_zone + + return p +} + +func (s *Time_zoneContext) GetParser() antlr.Parser { return s.parser } + +func (s *Time_zoneContext) AT_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserAT_KEYWORD, 0) +} + +func (s *Time_zoneContext) TIME() antlr.TerminalNode { + return s.GetToken(TSqlParserTIME, 0) +} + +func (s *Time_zoneContext) ZONE() antlr.TerminalNode { + return s.GetToken(TSqlParserZONE, 0) +} + +func (s *Time_zoneContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Time_zoneContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Time_zoneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Time_zoneContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTime_zone(s) + } +} + +func (s *Time_zoneContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTime_zone(s) + } +} + +func (s *Time_zoneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTime_zone(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Time_zone() (localctx ITime_zoneContext) { + localctx = NewTime_zoneContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 930, TSqlParserRULE_time_zone) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11184) + p.Match(TSqlParserAT_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11185) + p.Match(TSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11186) + p.Match(TSqlParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11187) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimitive_expressionContext is an interface to support dynamic dispatch. +type IPrimitive_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + NULL_() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + Primitive_constant() IPrimitive_constantContext + + // IsPrimitive_expressionContext differentiates from other interfaces. + IsPrimitive_expressionContext() +} + +type Primitive_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimitive_expressionContext() *Primitive_expressionContext { + var p = new(Primitive_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_primitive_expression + return p +} + +func InitEmptyPrimitive_expressionContext(p *Primitive_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_primitive_expression +} + +func (*Primitive_expressionContext) IsPrimitive_expressionContext() {} + +func NewPrimitive_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primitive_expressionContext { + var p = new(Primitive_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_primitive_expression + + return p +} + +func (s *Primitive_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primitive_expressionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *Primitive_expressionContext) NULL_() antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_, 0) +} + +func (s *Primitive_expressionContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Primitive_expressionContext) Primitive_constant() IPrimitive_constantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimitive_constantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimitive_constantContext) +} + +func (s *Primitive_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primitive_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primitive_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPrimitive_expression(s) + } +} + +func (s *Primitive_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPrimitive_expression(s) + } +} + +func (s *Primitive_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPrimitive_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Primitive_expression() (localctx IPrimitive_expressionContext) { + localctx = NewPrimitive_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 932, TSqlParserRULE_primitive_expression) + p.SetState(11193) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDEFAULT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11189) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNULL_: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11190) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserLOCAL_ID: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11191) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL, TSqlParserSTRING, TSqlParserBINARY, TSqlParserFLOAT, TSqlParserREAL, TSqlParserDOLLAR, TSqlParserPLACEHOLDER: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11192) + p.Primitive_constant() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_expressionContext is an interface to support dynamic dispatch. +type ICase_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCaseExpr returns the caseExpr rule contexts. + GetCaseExpr() IExpressionContext + + // GetElseExpr returns the elseExpr rule contexts. + GetElseExpr() IExpressionContext + + // SetCaseExpr sets the caseExpr rule contexts. + SetCaseExpr(IExpressionContext) + + // SetElseExpr sets the elseExpr rule contexts. + SetElseExpr(IExpressionContext) + + // Getter signatures + CASE() antlr.TerminalNode + END() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllSwitch_section() []ISwitch_sectionContext + Switch_section(i int) ISwitch_sectionContext + ELSE() antlr.TerminalNode + AllSwitch_search_condition_section() []ISwitch_search_condition_sectionContext + Switch_search_condition_section(i int) ISwitch_search_condition_sectionContext + + // IsCase_expressionContext differentiates from other interfaces. + IsCase_expressionContext() +} + +type Case_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + caseExpr IExpressionContext + elseExpr IExpressionContext +} + +func NewEmptyCase_expressionContext() *Case_expressionContext { + var p = new(Case_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_case_expression + return p +} + +func InitEmptyCase_expressionContext(p *Case_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_case_expression +} + +func (*Case_expressionContext) IsCase_expressionContext() {} + +func NewCase_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_expressionContext { + var p = new(Case_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_case_expression + + return p +} + +func (s *Case_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_expressionContext) GetCaseExpr() IExpressionContext { return s.caseExpr } + +func (s *Case_expressionContext) GetElseExpr() IExpressionContext { return s.elseExpr } + +func (s *Case_expressionContext) SetCaseExpr(v IExpressionContext) { s.caseExpr = v } + +func (s *Case_expressionContext) SetElseExpr(v IExpressionContext) { s.elseExpr = v } + +func (s *Case_expressionContext) CASE() antlr.TerminalNode { + return s.GetToken(TSqlParserCASE, 0) +} + +func (s *Case_expressionContext) END() antlr.TerminalNode { + return s.GetToken(TSqlParserEND, 0) +} + +func (s *Case_expressionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Case_expressionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Case_expressionContext) AllSwitch_section() []ISwitch_sectionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISwitch_sectionContext); ok { + len++ + } + } + + tst := make([]ISwitch_sectionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISwitch_sectionContext); ok { + tst[i] = t.(ISwitch_sectionContext) + i++ + } + } + + return tst +} + +func (s *Case_expressionContext) Switch_section(i int) ISwitch_sectionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISwitch_sectionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISwitch_sectionContext) +} + +func (s *Case_expressionContext) ELSE() antlr.TerminalNode { + return s.GetToken(TSqlParserELSE, 0) +} + +func (s *Case_expressionContext) AllSwitch_search_condition_section() []ISwitch_search_condition_sectionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISwitch_search_condition_sectionContext); ok { + len++ + } + } + + tst := make([]ISwitch_search_condition_sectionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISwitch_search_condition_sectionContext); ok { + tst[i] = t.(ISwitch_search_condition_sectionContext) + i++ + } + } + + return tst +} + +func (s *Case_expressionContext) Switch_search_condition_section(i int) ISwitch_search_condition_sectionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISwitch_search_condition_sectionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISwitch_search_condition_sectionContext) +} + +func (s *Case_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCase_expression(s) + } +} + +func (s *Case_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCase_expression(s) + } +} + +func (s *Case_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCase_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Case_expression() (localctx ICase_expressionContext) { + localctx = NewCase_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 934, TSqlParserRULE_case_expression) + var _la int + + p.SetState(11220) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1512, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11195) + p.Match(TSqlParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11196) + + var _x = p.expression(0) + + localctx.(*Case_expressionContext).caseExpr = _x + } + p.SetState(11198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserWHEN { + { + p.SetState(11197) + p.Switch_section() + } + + p.SetState(11200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(11204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserELSE { + { + p.SetState(11202) + p.Match(TSqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11203) + + var _x = p.expression(0) + + localctx.(*Case_expressionContext).elseExpr = _x + } + + } + { + p.SetState(11206) + p.Match(TSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11208) + p.Match(TSqlParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == TSqlParserWHEN { + { + p.SetState(11209) + p.Switch_search_condition_section() + } + + p.SetState(11212) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(11216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserELSE { + { + p.SetState(11214) + p.Match(TSqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11215) + + var _x = p.expression(0) + + localctx.(*Case_expressionContext).elseExpr = _x + } + + } + { + p.SetState(11218) + p.Match(TSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnary_operator_expressionContext is an interface to support dynamic dispatch. +type IUnary_operator_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOp returns the op token. + GetOp() antlr.Token + + // SetOp sets the op token. + SetOp(antlr.Token) + + // Getter signatures + BIT_NOT() antlr.TerminalNode + Expression() IExpressionContext + PLUS() antlr.TerminalNode + MINUS() antlr.TerminalNode + + // IsUnary_operator_expressionContext differentiates from other interfaces. + IsUnary_operator_expressionContext() +} + +type Unary_operator_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + op antlr.Token +} + +func NewEmptyUnary_operator_expressionContext() *Unary_operator_expressionContext { + var p = new(Unary_operator_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_unary_operator_expression + return p +} + +func InitEmptyUnary_operator_expressionContext(p *Unary_operator_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_unary_operator_expression +} + +func (*Unary_operator_expressionContext) IsUnary_operator_expressionContext() {} + +func NewUnary_operator_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_operator_expressionContext { + var p = new(Unary_operator_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_unary_operator_expression + + return p +} + +func (s *Unary_operator_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unary_operator_expressionContext) GetOp() antlr.Token { return s.op } + +func (s *Unary_operator_expressionContext) SetOp(v antlr.Token) { s.op = v } + +func (s *Unary_operator_expressionContext) BIT_NOT() antlr.TerminalNode { + return s.GetToken(TSqlParserBIT_NOT, 0) +} + +func (s *Unary_operator_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Unary_operator_expressionContext) PLUS() antlr.TerminalNode { + return s.GetToken(TSqlParserPLUS, 0) +} + +func (s *Unary_operator_expressionContext) MINUS() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUS, 0) +} + +func (s *Unary_operator_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unary_operator_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unary_operator_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUnary_operator_expression(s) + } +} + +func (s *Unary_operator_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUnary_operator_expression(s) + } +} + +func (s *Unary_operator_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUnary_operator_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Unary_operator_expression() (localctx IUnary_operator_expressionContext) { + localctx = NewUnary_operator_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 936, TSqlParserRULE_unary_operator_expression) + var _la int + + p.SetState(11226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserBIT_NOT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11222) + p.Match(TSqlParserBIT_NOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11223) + p.expression(0) + } + + case TSqlParserPLUS, TSqlParserMINUS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11224) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Unary_operator_expressionContext).op = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserPLUS || _la == TSqlParserMINUS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Unary_operator_expressionContext).op = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11225) + p.expression(0) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBracket_expressionContext is an interface to support dynamic dispatch. +type IBracket_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET() antlr.TerminalNode + Subquery() ISubqueryContext + + // IsBracket_expressionContext differentiates from other interfaces. + IsBracket_expressionContext() +} + +type Bracket_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBracket_expressionContext() *Bracket_expressionContext { + var p = new(Bracket_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_bracket_expression + return p +} + +func InitEmptyBracket_expressionContext(p *Bracket_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_bracket_expression +} + +func (*Bracket_expressionContext) IsBracket_expressionContext() {} + +func NewBracket_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bracket_expressionContext { + var p = new(Bracket_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_bracket_expression + + return p +} + +func (s *Bracket_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bracket_expressionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Bracket_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Bracket_expressionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Bracket_expressionContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Bracket_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bracket_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bracket_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBracket_expression(s) + } +} + +func (s *Bracket_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBracket_expression(s) + } +} + +func (s *Bracket_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBracket_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Bracket_expression() (localctx IBracket_expressionContext) { + localctx = NewBracket_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 938, TSqlParserRULE_bracket_expression) + p.SetState(11236) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1514, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11228) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11229) + p.expression(0) + } + { + p.SetState(11230) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11232) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11233) + p.Subquery() + } + { + p.SetState(11234) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubqueryContext is an interface to support dynamic dispatch. +type ISubqueryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_statement() ISelect_statementContext + + // IsSubqueryContext differentiates from other interfaces. + IsSubqueryContext() +} + +type SubqueryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubqueryContext() *SubqueryContext { + var p = new(SubqueryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_subquery + return p +} + +func InitEmptySubqueryContext(p *SubqueryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_subquery +} + +func (*SubqueryContext) IsSubqueryContext() {} + +func NewSubqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubqueryContext { + var p = new(SubqueryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_subquery + + return p +} + +func (s *SubqueryContext) GetParser() antlr.Parser { return s.parser } + +func (s *SubqueryContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *SubqueryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SubqueryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSubquery(s) + } +} + +func (s *SubqueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSubquery(s) + } +} + +func (s *SubqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSubquery(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Subquery() (localctx ISubqueryContext) { + localctx = NewSubqueryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 940, TSqlParserRULE_subquery) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11238) + p.Select_statement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_expressionContext is an interface to support dynamic dispatch. +type IWith_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_common_table_expression returns the _common_table_expression rule contexts. + Get_common_table_expression() ICommon_table_expressionContext + + // Set_common_table_expression sets the _common_table_expression rule contexts. + Set_common_table_expression(ICommon_table_expressionContext) + + // GetCtes returns the ctes rule context list. + GetCtes() []ICommon_table_expressionContext + + // SetCtes sets the ctes rule context list. + SetCtes([]ICommon_table_expressionContext) + + // Getter signatures + WITH() antlr.TerminalNode + AllCommon_table_expression() []ICommon_table_expressionContext + Common_table_expression(i int) ICommon_table_expressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsWith_expressionContext differentiates from other interfaces. + IsWith_expressionContext() +} + +type With_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _common_table_expression ICommon_table_expressionContext + ctes []ICommon_table_expressionContext +} + +func NewEmptyWith_expressionContext() *With_expressionContext { + var p = new(With_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_with_expression + return p +} + +func InitEmptyWith_expressionContext(p *With_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_with_expression +} + +func (*With_expressionContext) IsWith_expressionContext() {} + +func NewWith_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_expressionContext { + var p = new(With_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_with_expression + + return p +} + +func (s *With_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_expressionContext) Get_common_table_expression() ICommon_table_expressionContext { + return s._common_table_expression +} + +func (s *With_expressionContext) Set_common_table_expression(v ICommon_table_expressionContext) { + s._common_table_expression = v +} + +func (s *With_expressionContext) GetCtes() []ICommon_table_expressionContext { return s.ctes } + +func (s *With_expressionContext) SetCtes(v []ICommon_table_expressionContext) { s.ctes = v } + +func (s *With_expressionContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *With_expressionContext) AllCommon_table_expression() []ICommon_table_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICommon_table_expressionContext); ok { + len++ + } + } + + tst := make([]ICommon_table_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICommon_table_expressionContext); ok { + tst[i] = t.(ICommon_table_expressionContext) + i++ + } + } + + return tst +} + +func (s *With_expressionContext) Common_table_expression(i int) ICommon_table_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommon_table_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICommon_table_expressionContext) +} + +func (s *With_expressionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *With_expressionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *With_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterWith_expression(s) + } +} + +func (s *With_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitWith_expression(s) + } +} + +func (s *With_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitWith_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) With_expression() (localctx IWith_expressionContext) { + localctx = NewWith_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 942, TSqlParserRULE_with_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11240) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11241) + + var _x = p.Common_table_expression() + + localctx.(*With_expressionContext)._common_table_expression = _x + } + localctx.(*With_expressionContext).ctes = append(localctx.(*With_expressionContext).ctes, localctx.(*With_expressionContext)._common_table_expression) + p.SetState(11246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11242) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11243) + + var _x = p.Common_table_expression() + + localctx.(*With_expressionContext)._common_table_expression = _x + } + localctx.(*With_expressionContext).ctes = append(localctx.(*With_expressionContext).ctes, localctx.(*With_expressionContext)._common_table_expression) + + p.SetState(11248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICommon_table_expressionContext is an interface to support dynamic dispatch. +type ICommon_table_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetExpression_name returns the expression_name rule contexts. + GetExpression_name() IId_Context + + // GetColumns returns the columns rule contexts. + GetColumns() IColumn_name_listContext + + // GetCte_query returns the cte_query rule contexts. + GetCte_query() ISelect_statementContext + + // SetExpression_name sets the expression_name rule contexts. + SetExpression_name(IId_Context) + + // SetColumns sets the columns rule contexts. + SetColumns(IColumn_name_listContext) + + // SetCte_query sets the cte_query rule contexts. + SetCte_query(ISelect_statementContext) + + // Getter signatures + AS() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + Id_() IId_Context + Select_statement() ISelect_statementContext + Column_name_list() IColumn_name_listContext + + // IsCommon_table_expressionContext differentiates from other interfaces. + IsCommon_table_expressionContext() +} + +type Common_table_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + expression_name IId_Context + columns IColumn_name_listContext + cte_query ISelect_statementContext +} + +func NewEmptyCommon_table_expressionContext() *Common_table_expressionContext { + var p = new(Common_table_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_common_table_expression + return p +} + +func InitEmptyCommon_table_expressionContext(p *Common_table_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_common_table_expression +} + +func (*Common_table_expressionContext) IsCommon_table_expressionContext() {} + +func NewCommon_table_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_table_expressionContext { + var p = new(Common_table_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_common_table_expression + + return p +} + +func (s *Common_table_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Common_table_expressionContext) GetExpression_name() IId_Context { return s.expression_name } + +func (s *Common_table_expressionContext) GetColumns() IColumn_name_listContext { return s.columns } + +func (s *Common_table_expressionContext) GetCte_query() ISelect_statementContext { return s.cte_query } + +func (s *Common_table_expressionContext) SetExpression_name(v IId_Context) { s.expression_name = v } + +func (s *Common_table_expressionContext) SetColumns(v IColumn_name_listContext) { s.columns = v } + +func (s *Common_table_expressionContext) SetCte_query(v ISelect_statementContext) { s.cte_query = v } + +func (s *Common_table_expressionContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Common_table_expressionContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Common_table_expressionContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Common_table_expressionContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Common_table_expressionContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Common_table_expressionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Common_table_expressionContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Common_table_expressionContext) Column_name_list() IColumn_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Common_table_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Common_table_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Common_table_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCommon_table_expression(s) + } +} + +func (s *Common_table_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCommon_table_expression(s) + } +} + +func (s *Common_table_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCommon_table_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Common_table_expression() (localctx ICommon_table_expressionContext) { + localctx = NewCommon_table_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 944, TSqlParserRULE_common_table_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11249) + + var _x = p.Id_() + + localctx.(*Common_table_expressionContext).expression_name = _x + } + p.SetState(11254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLR_BRACKET { + { + p.SetState(11250) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11251) + + var _x = p.Column_name_list() + + localctx.(*Common_table_expressionContext).columns = _x + } + { + p.SetState(11252) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11256) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11257) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11258) + + var _x = p.Select_statement() + + localctx.(*Common_table_expressionContext).cte_query = _x + } + { + p.SetState(11259) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_elemContext is an interface to support dynamic dispatch. +type IUpdate_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUdt_column_name returns the udt_column_name rule contexts. + GetUdt_column_name() IId_Context + + // GetMethod_name returns the method_name rule contexts. + GetMethod_name() IId_Context + + // SetUdt_column_name sets the udt_column_name rule contexts. + SetUdt_column_name(IId_Context) + + // SetMethod_name sets the method_name rule contexts. + SetMethod_name(IId_Context) + + // Getter signatures + LOCAL_ID() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + Full_column_name() IFull_column_nameContext + Expression() IExpressionContext + Assignment_operator() IAssignment_operatorContext + DOT() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Expression_list_() IExpression_list_Context + RR_BRACKET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + + // IsUpdate_elemContext differentiates from other interfaces. + IsUpdate_elemContext() +} + +type Update_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + udt_column_name IId_Context + method_name IId_Context +} + +func NewEmptyUpdate_elemContext() *Update_elemContext { + var p = new(Update_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_update_elem + return p +} + +func InitEmptyUpdate_elemContext(p *Update_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_update_elem +} + +func (*Update_elemContext) IsUpdate_elemContext() {} + +func NewUpdate_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_elemContext { + var p = new(Update_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_update_elem + + return p +} + +func (s *Update_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_elemContext) GetUdt_column_name() IId_Context { return s.udt_column_name } + +func (s *Update_elemContext) GetMethod_name() IId_Context { return s.method_name } + +func (s *Update_elemContext) SetUdt_column_name(v IId_Context) { s.udt_column_name = v } + +func (s *Update_elemContext) SetMethod_name(v IId_Context) { s.method_name = v } + +func (s *Update_elemContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Update_elemContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Update_elemContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Update_elemContext) Full_column_name() IFull_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *Update_elemContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Update_elemContext) Assignment_operator() IAssignment_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignment_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignment_operatorContext) +} + +func (s *Update_elemContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Update_elemContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Update_elemContext) Expression_list_() IExpression_list_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_list_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_list_Context) +} + +func (s *Update_elemContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Update_elemContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Update_elemContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Update_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUpdate_elem(s) + } +} + +func (s *Update_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUpdate_elem(s) + } +} + +func (s *Update_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUpdate_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Update_elem() (localctx IUpdate_elemContext) { + localctx = NewUpdate_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 946, TSqlParserRULE_update_elem) + p.SetState(11286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1520, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11261) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11262) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11263) + p.Full_column_name() + } + p.SetState(11266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserEQUAL: + { + p.SetState(11264) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPLUS_ASSIGN, TSqlParserMINUS_ASSIGN, TSqlParserMULT_ASSIGN, TSqlParserDIV_ASSIGN, TSqlParserMOD_ASSIGN, TSqlParserAND_ASSIGN, TSqlParserXOR_ASSIGN, TSqlParserOR_ASSIGN: + { + p.SetState(11265) + p.Assignment_operator() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(11268) + p.expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(11272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserDOLLAR: + { + p.SetState(11270) + p.Full_column_name() + } + + case TSqlParserLOCAL_ID: + { + p.SetState(11271) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(11276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserEQUAL: + { + p.SetState(11274) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPLUS_ASSIGN, TSqlParserMINUS_ASSIGN, TSqlParserMULT_ASSIGN, TSqlParserDIV_ASSIGN, TSqlParserMOD_ASSIGN, TSqlParserAND_ASSIGN, TSqlParserXOR_ASSIGN, TSqlParserOR_ASSIGN: + { + p.SetState(11275) + p.Assignment_operator() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(11278) + p.expression(0) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11279) + + var _x = p.Id_() + + localctx.(*Update_elemContext).udt_column_name = _x + } + { + p.SetState(11280) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11281) + + var _x = p.Id_() + + localctx.(*Update_elemContext).method_name = _x + } + { + p.SetState(11282) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11283) + p.Expression_list_() + } + { + p.SetState(11284) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_elem_mergeContext is an interface to support dynamic dispatch. +type IUpdate_elem_mergeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUdt_column_name returns the udt_column_name rule contexts. + GetUdt_column_name() IId_Context + + // GetMethod_name returns the method_name rule contexts. + GetMethod_name() IId_Context + + // SetUdt_column_name sets the udt_column_name rule contexts. + SetUdt_column_name(IId_Context) + + // SetMethod_name sets the method_name rule contexts. + SetMethod_name(IId_Context) + + // Getter signatures + Expression() IExpressionContext + Full_column_name() IFull_column_nameContext + LOCAL_ID() antlr.TerminalNode + EQUAL() antlr.TerminalNode + Assignment_operator() IAssignment_operatorContext + DOT() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Expression_list_() IExpression_list_Context + RR_BRACKET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + + // IsUpdate_elem_mergeContext differentiates from other interfaces. + IsUpdate_elem_mergeContext() +} + +type Update_elem_mergeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + udt_column_name IId_Context + method_name IId_Context +} + +func NewEmptyUpdate_elem_mergeContext() *Update_elem_mergeContext { + var p = new(Update_elem_mergeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_update_elem_merge + return p +} + +func InitEmptyUpdate_elem_mergeContext(p *Update_elem_mergeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_update_elem_merge +} + +func (*Update_elem_mergeContext) IsUpdate_elem_mergeContext() {} + +func NewUpdate_elem_mergeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_elem_mergeContext { + var p = new(Update_elem_mergeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_update_elem_merge + + return p +} + +func (s *Update_elem_mergeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_elem_mergeContext) GetUdt_column_name() IId_Context { return s.udt_column_name } + +func (s *Update_elem_mergeContext) GetMethod_name() IId_Context { return s.method_name } + +func (s *Update_elem_mergeContext) SetUdt_column_name(v IId_Context) { s.udt_column_name = v } + +func (s *Update_elem_mergeContext) SetMethod_name(v IId_Context) { s.method_name = v } + +func (s *Update_elem_mergeContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Update_elem_mergeContext) Full_column_name() IFull_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *Update_elem_mergeContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Update_elem_mergeContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Update_elem_mergeContext) Assignment_operator() IAssignment_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignment_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignment_operatorContext) +} + +func (s *Update_elem_mergeContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Update_elem_mergeContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Update_elem_mergeContext) Expression_list_() IExpression_list_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_list_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_list_Context) +} + +func (s *Update_elem_mergeContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Update_elem_mergeContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Update_elem_mergeContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Update_elem_mergeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_elem_mergeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_elem_mergeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUpdate_elem_merge(s) + } +} + +func (s *Update_elem_mergeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUpdate_elem_merge(s) + } +} + +func (s *Update_elem_mergeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUpdate_elem_merge(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Update_elem_merge() (localctx IUpdate_elem_mergeContext) { + localctx = NewUpdate_elem_mergeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 948, TSqlParserRULE_update_elem_merge) + p.SetState(11304) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1523, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(11290) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserDOLLAR: + { + p.SetState(11288) + p.Full_column_name() + } + + case TSqlParserLOCAL_ID: + { + p.SetState(11289) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(11294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserEQUAL: + { + p.SetState(11292) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPLUS_ASSIGN, TSqlParserMINUS_ASSIGN, TSqlParserMULT_ASSIGN, TSqlParserDIV_ASSIGN, TSqlParserMOD_ASSIGN, TSqlParserAND_ASSIGN, TSqlParserXOR_ASSIGN, TSqlParserOR_ASSIGN: + { + p.SetState(11293) + p.Assignment_operator() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(11296) + p.expression(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11297) + + var _x = p.Id_() + + localctx.(*Update_elem_mergeContext).udt_column_name = _x + } + { + p.SetState(11298) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11299) + + var _x = p.Id_() + + localctx.(*Update_elem_mergeContext).method_name = _x + } + { + p.SetState(11300) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11301) + p.Expression_list_() + } + { + p.SetState(11302) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISearch_conditionContext is an interface to support dynamic dispatch. +type ISearch_conditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Predicate() IPredicateContext + LR_BRACKET() antlr.TerminalNode + AllSearch_condition() []ISearch_conditionContext + Search_condition(i int) ISearch_conditionContext + RR_BRACKET() antlr.TerminalNode + AllNOT() []antlr.TerminalNode + NOT(i int) antlr.TerminalNode + AND() antlr.TerminalNode + OR() antlr.TerminalNode + + // IsSearch_conditionContext differentiates from other interfaces. + IsSearch_conditionContext() +} + +type Search_conditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySearch_conditionContext() *Search_conditionContext { + var p = new(Search_conditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_search_condition + return p +} + +func InitEmptySearch_conditionContext(p *Search_conditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_search_condition +} + +func (*Search_conditionContext) IsSearch_conditionContext() {} + +func NewSearch_conditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Search_conditionContext { + var p = new(Search_conditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_search_condition + + return p +} + +func (s *Search_conditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Search_conditionContext) Predicate() IPredicateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *Search_conditionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Search_conditionContext) AllSearch_condition() []ISearch_conditionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISearch_conditionContext); ok { + len++ + } + } + + tst := make([]ISearch_conditionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISearch_conditionContext); ok { + tst[i] = t.(ISearch_conditionContext) + i++ + } + } + + return tst +} + +func (s *Search_conditionContext) Search_condition(i int) ISearch_conditionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Search_conditionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Search_conditionContext) AllNOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOT) +} + +func (s *Search_conditionContext) NOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, i) +} + +func (s *Search_conditionContext) AND() antlr.TerminalNode { + return s.GetToken(TSqlParserAND, 0) +} + +func (s *Search_conditionContext) OR() antlr.TerminalNode { + return s.GetToken(TSqlParserOR, 0) +} + +func (s *Search_conditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Search_conditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Search_conditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSearch_condition(s) + } +} + +func (s *Search_conditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSearch_condition(s) + } +} + +func (s *Search_conditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSearch_condition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Search_condition() (localctx ISearch_conditionContext) { + return p.search_condition(0) +} + +func (p *TSqlParser) search_condition(_p int) (localctx ISearch_conditionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewSearch_conditionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx ISearch_conditionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 950 + p.EnterRecursionRule(localctx, 950, TSqlParserRULE_search_condition, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11310) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserNOT { + { + p.SetState(11307) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(11312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(11318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1525, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11313) + p.Predicate() + } + + case 2: + { + p.SetState(11314) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11315) + p.search_condition(0) + } + { + p.SetState(11316) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(11328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1527, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(11326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1526, p.GetParserRuleContext()) { + case 1: + localctx = NewSearch_conditionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, TSqlParserRULE_search_condition) + p.SetState(11320) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(11321) + p.Match(TSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11322) + p.search_condition(3) + } + + case 2: + localctx = NewSearch_conditionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, TSqlParserRULE_search_condition) + p.SetState(11323) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(11324) + p.Match(TSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11325) + p.search_condition(2) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(11330) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1527, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPredicateContext is an interface to support dynamic dispatch. +type IPredicateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXISTS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Subquery() ISubqueryContext + RR_BRACKET() antlr.TerminalNode + Freetext_predicate() IFreetext_predicateContext + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + Comparison_operator() IComparison_operatorContext + MULT_ASSIGN() antlr.TerminalNode + ALL() antlr.TerminalNode + SOME() antlr.TerminalNode + ANY() antlr.TerminalNode + BETWEEN() antlr.TerminalNode + AND() antlr.TerminalNode + AllNOT() []antlr.TerminalNode + NOT(i int) antlr.TerminalNode + IN() antlr.TerminalNode + Expression_list_() IExpression_list_Context + LIKE() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + IS() antlr.TerminalNode + Null_notnull() INull_notnullContext + + // IsPredicateContext differentiates from other interfaces. + IsPredicateContext() +} + +type PredicateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPredicateContext() *PredicateContext { + var p = new(PredicateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_predicate + return p +} + +func InitEmptyPredicateContext(p *PredicateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_predicate +} + +func (*PredicateContext) IsPredicateContext() {} + +func NewPredicateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PredicateContext { + var p = new(PredicateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_predicate + + return p +} + +func (s *PredicateContext) GetParser() antlr.Parser { return s.parser } + +func (s *PredicateContext) EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXISTS, 0) +} + +func (s *PredicateContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *PredicateContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *PredicateContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *PredicateContext) Freetext_predicate() IFreetext_predicateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFreetext_predicateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFreetext_predicateContext) +} + +func (s *PredicateContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *PredicateContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PredicateContext) Comparison_operator() IComparison_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComparison_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComparison_operatorContext) +} + +func (s *PredicateContext) MULT_ASSIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserMULT_ASSIGN, 0) +} + +func (s *PredicateContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *PredicateContext) SOME() antlr.TerminalNode { + return s.GetToken(TSqlParserSOME, 0) +} + +func (s *PredicateContext) ANY() antlr.TerminalNode { + return s.GetToken(TSqlParserANY, 0) +} + +func (s *PredicateContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(TSqlParserBETWEEN, 0) +} + +func (s *PredicateContext) AND() antlr.TerminalNode { + return s.GetToken(TSqlParserAND, 0) +} + +func (s *PredicateContext) AllNOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNOT) +} + +func (s *PredicateContext) NOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, i) +} + +func (s *PredicateContext) IN() antlr.TerminalNode { + return s.GetToken(TSqlParserIN, 0) +} + +func (s *PredicateContext) Expression_list_() IExpression_list_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_list_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_list_Context) +} + +func (s *PredicateContext) LIKE() antlr.TerminalNode { + return s.GetToken(TSqlParserLIKE, 0) +} + +func (s *PredicateContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(TSqlParserESCAPE, 0) +} + +func (s *PredicateContext) IS() antlr.TerminalNode { + return s.GetToken(TSqlParserIS, 0) +} + +func (s *PredicateContext) Null_notnull() INull_notnullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_notnullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_notnullContext) +} + +func (s *PredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PredicateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PredicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPredicate(s) + } +} + +func (s *PredicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPredicate(s) + } +} + +func (s *PredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPredicate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Predicate() (localctx IPredicateContext) { + localctx = NewPredicateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 952, TSqlParserRULE_predicate) + var _la int + + p.SetState(11396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1533, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11331) + p.Match(TSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11332) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11333) + p.Subquery() + } + { + p.SetState(11334) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11336) + p.Freetext_predicate() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11337) + p.expression(0) + } + { + p.SetState(11338) + p.Comparison_operator() + } + { + p.SetState(11339) + p.expression(0) + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11341) + p.expression(0) + } + { + p.SetState(11342) + p.Match(TSqlParserMULT_ASSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11343) + p.expression(0) + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11345) + p.expression(0) + } + { + p.SetState(11346) + p.Comparison_operator() + } + { + p.SetState(11347) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALL || _la == TSqlParserANY || _la == TSqlParserSOME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11348) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11349) + p.Subquery() + } + { + p.SetState(11350) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11352) + p.expression(0) + } + p.SetState(11356) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserNOT { + { + p.SetState(11353) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(11358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11359) + p.Match(TSqlParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11360) + p.expression(0) + } + { + p.SetState(11361) + p.Match(TSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11362) + p.expression(0) + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(11364) + p.expression(0) + } + p.SetState(11368) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserNOT { + { + p.SetState(11365) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(11370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11371) + p.Match(TSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11372) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1530, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11373) + p.Subquery() + } + + case 2: + { + p.SetState(11374) + p.Expression_list_() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(11377) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(11379) + p.expression(0) + } + p.SetState(11383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserNOT { + { + p.SetState(11380) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(11385) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11386) + p.Match(TSqlParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11387) + p.expression(0) + } + p.SetState(11390) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1532, p.GetParserRuleContext()) == 1 { + { + p.SetState(11388) + p.Match(TSqlParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11389) + p.expression(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(11392) + p.expression(0) + } + { + p.SetState(11393) + p.Match(TSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11394) + p.Null_notnull() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_expressionContext is an interface to support dynamic dispatch. +type IQuery_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_sql_union returns the _sql_union rule contexts. + Get_sql_union() ISql_unionContext + + // Set_sql_union sets the _sql_union rule contexts. + Set_sql_union(ISql_unionContext) + + // GetUnions returns the unions rule context list. + GetUnions() []ISql_unionContext + + // SetUnions sets the unions rule context list. + SetUnions([]ISql_unionContext) + + // Getter signatures + Query_specification() IQuery_specificationContext + Select_order_by_clause() ISelect_order_by_clauseContext + AllSql_union() []ISql_unionContext + Sql_union(i int) ISql_unionContext + LR_BRACKET() antlr.TerminalNode + AllQuery_expression() []IQuery_expressionContext + Query_expression(i int) IQuery_expressionContext + RR_BRACKET() antlr.TerminalNode + UNION() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsQuery_expressionContext differentiates from other interfaces. + IsQuery_expressionContext() +} + +type Query_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _sql_union ISql_unionContext + unions []ISql_unionContext +} + +func NewEmptyQuery_expressionContext() *Query_expressionContext { + var p = new(Query_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_query_expression + return p +} + +func InitEmptyQuery_expressionContext(p *Query_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_query_expression +} + +func (*Query_expressionContext) IsQuery_expressionContext() {} + +func NewQuery_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_expressionContext { + var p = new(Query_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_query_expression + + return p +} + +func (s *Query_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_expressionContext) Get_sql_union() ISql_unionContext { return s._sql_union } + +func (s *Query_expressionContext) Set_sql_union(v ISql_unionContext) { s._sql_union = v } + +func (s *Query_expressionContext) GetUnions() []ISql_unionContext { return s.unions } + +func (s *Query_expressionContext) SetUnions(v []ISql_unionContext) { s.unions = v } + +func (s *Query_expressionContext) Query_specification() IQuery_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_specificationContext) +} + +func (s *Query_expressionContext) Select_order_by_clause() ISelect_order_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_order_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_order_by_clauseContext) +} + +func (s *Query_expressionContext) AllSql_union() []ISql_unionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_unionContext); ok { + len++ + } + } + + tst := make([]ISql_unionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_unionContext); ok { + tst[i] = t.(ISql_unionContext) + i++ + } + } + + return tst +} + +func (s *Query_expressionContext) Sql_union(i int) ISql_unionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_unionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_unionContext) +} + +func (s *Query_expressionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Query_expressionContext) AllQuery_expression() []IQuery_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuery_expressionContext); ok { + len++ + } + } + + tst := make([]IQuery_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuery_expressionContext); ok { + tst[i] = t.(IQuery_expressionContext) + i++ + } + } + + return tst +} + +func (s *Query_expressionContext) Query_expression(i int) IQuery_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuery_expressionContext) +} + +func (s *Query_expressionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Query_expressionContext) UNION() antlr.TerminalNode { + return s.GetToken(TSqlParserUNION, 0) +} + +func (s *Query_expressionContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Query_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterQuery_expression(s) + } +} + +func (s *Query_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitQuery_expression(s) + } +} + +func (s *Query_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitQuery_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Query_expression() (localctx IQuery_expressionContext) { + localctx = NewQuery_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 954, TSqlParserRULE_query_expression) + var _la int + + var _alt int + + p.SetState(11418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSELECT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11398) + p.Query_specification() + } + p.SetState(11400) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1534, p.GetParserRuleContext()) == 1 { + { + p.SetState(11399) + p.Select_order_by_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1535, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11402) + + var _x = p.Sql_union() + + localctx.(*Query_expressionContext)._sql_union = _x + } + localctx.(*Query_expressionContext).unions = append(localctx.(*Query_expressionContext).unions, localctx.(*Query_expressionContext)._sql_union) + + } + p.SetState(11407) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1535, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case TSqlParserLR_BRACKET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11408) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11409) + p.Query_expression() + } + { + p.SetState(11410) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11416) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1537, p.GetParserRuleContext()) == 1 { + { + p.SetState(11411) + p.Match(TSqlParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserALL { + { + p.SetState(11412) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11415) + p.Query_expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_unionContext is an interface to support dynamic dispatch. +type ISql_unionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSpec returns the spec rule contexts. + GetSpec() IQuery_specificationContext + + // GetOp returns the op rule contexts. + GetOp() IQuery_expressionContext + + // SetSpec sets the spec rule contexts. + SetSpec(IQuery_specificationContext) + + // SetOp sets the op rule contexts. + SetOp(IQuery_expressionContext) + + // Getter signatures + UNION() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + INTERSECT() antlr.TerminalNode + Query_specification() IQuery_specificationContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + ALL() antlr.TerminalNode + Query_expression() IQuery_expressionContext + + // IsSql_unionContext differentiates from other interfaces. + IsSql_unionContext() +} + +type Sql_unionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + spec IQuery_specificationContext + op IQuery_expressionContext +} + +func NewEmptySql_unionContext() *Sql_unionContext { + var p = new(Sql_unionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_sql_union + return p +} + +func InitEmptySql_unionContext(p *Sql_unionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_sql_union +} + +func (*Sql_unionContext) IsSql_unionContext() {} + +func NewSql_unionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_unionContext { + var p = new(Sql_unionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_sql_union + + return p +} + +func (s *Sql_unionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_unionContext) GetSpec() IQuery_specificationContext { return s.spec } + +func (s *Sql_unionContext) GetOp() IQuery_expressionContext { return s.op } + +func (s *Sql_unionContext) SetSpec(v IQuery_specificationContext) { s.spec = v } + +func (s *Sql_unionContext) SetOp(v IQuery_expressionContext) { s.op = v } + +func (s *Sql_unionContext) UNION() antlr.TerminalNode { + return s.GetToken(TSqlParserUNION, 0) +} + +func (s *Sql_unionContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(TSqlParserEXCEPT, 0) +} + +func (s *Sql_unionContext) INTERSECT() antlr.TerminalNode { + return s.GetToken(TSqlParserINTERSECT, 0) +} + +func (s *Sql_unionContext) Query_specification() IQuery_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_specificationContext) +} + +func (s *Sql_unionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Sql_unionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Sql_unionContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Sql_unionContext) Query_expression() IQuery_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_expressionContext) +} + +func (s *Sql_unionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_unionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_unionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSql_union(s) + } +} + +func (s *Sql_unionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSql_union(s) + } +} + +func (s *Sql_unionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSql_union(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Sql_union() (localctx ISql_unionContext) { + localctx = NewSql_unionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 956, TSqlParserRULE_sql_union) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserUNION: + { + p.SetState(11420) + p.Match(TSqlParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11422) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserALL { + { + p.SetState(11421) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserEXCEPT: + { + p.SetState(11424) + p.Match(TSqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserINTERSECT: + { + p.SetState(11425) + p.Match(TSqlParserINTERSECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(11433) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSELECT: + { + p.SetState(11428) + + var _x = p.Query_specification() + + localctx.(*Sql_unionContext).spec = _x + } + + case TSqlParserLR_BRACKET: + { + p.SetState(11429) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11430) + + var _x = p.Query_expression() + + localctx.(*Sql_unionContext).op = _x + } + { + p.SetState(11431) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_specificationContext is an interface to support dynamic dispatch. +type IQuery_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAllOrDistinct returns the allOrDistinct token. + GetAllOrDistinct() antlr.Token + + // SetAllOrDistinct sets the allOrDistinct token. + SetAllOrDistinct(antlr.Token) + + // GetTop returns the top rule contexts. + GetTop() ITop_clauseContext + + // GetColumns returns the columns rule contexts. + GetColumns() ISelect_listContext + + // GetInto returns the into rule contexts. + GetInto() ITable_nameContext + + // GetWhere returns the where rule contexts. + GetWhere() ISearch_conditionContext + + // SetTop sets the top rule contexts. + SetTop(ITop_clauseContext) + + // SetColumns sets the columns rule contexts. + SetColumns(ISelect_listContext) + + // SetInto sets the into rule contexts. + SetInto(ITable_nameContext) + + // SetWhere sets the where rule contexts. + SetWhere(ISearch_conditionContext) + + // Getter signatures + SELECT() antlr.TerminalNode + Select_list() ISelect_listContext + INTO() antlr.TerminalNode + From_table_sources() IFrom_table_sourcesContext + WHERE() antlr.TerminalNode + Group_by_clause() IGroup_by_clauseContext + Having_clause() IHaving_clauseContext + Top_clause() ITop_clauseContext + Table_name() ITable_nameContext + Search_condition() ISearch_conditionContext + ALL() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + + // IsQuery_specificationContext differentiates from other interfaces. + IsQuery_specificationContext() +} + +type Query_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + allOrDistinct antlr.Token + top ITop_clauseContext + columns ISelect_listContext + into ITable_nameContext + where ISearch_conditionContext +} + +func NewEmptyQuery_specificationContext() *Query_specificationContext { + var p = new(Query_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_query_specification + return p +} + +func InitEmptyQuery_specificationContext(p *Query_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_query_specification +} + +func (*Query_specificationContext) IsQuery_specificationContext() {} + +func NewQuery_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_specificationContext { + var p = new(Query_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_query_specification + + return p +} + +func (s *Query_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_specificationContext) GetAllOrDistinct() antlr.Token { return s.allOrDistinct } + +func (s *Query_specificationContext) SetAllOrDistinct(v antlr.Token) { s.allOrDistinct = v } + +func (s *Query_specificationContext) GetTop() ITop_clauseContext { return s.top } + +func (s *Query_specificationContext) GetColumns() ISelect_listContext { return s.columns } + +func (s *Query_specificationContext) GetInto() ITable_nameContext { return s.into } + +func (s *Query_specificationContext) GetWhere() ISearch_conditionContext { return s.where } + +func (s *Query_specificationContext) SetTop(v ITop_clauseContext) { s.top = v } + +func (s *Query_specificationContext) SetColumns(v ISelect_listContext) { s.columns = v } + +func (s *Query_specificationContext) SetInto(v ITable_nameContext) { s.into = v } + +func (s *Query_specificationContext) SetWhere(v ISearch_conditionContext) { s.where = v } + +func (s *Query_specificationContext) SELECT() antlr.TerminalNode { + return s.GetToken(TSqlParserSELECT, 0) +} + +func (s *Query_specificationContext) Select_list() ISelect_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_listContext) +} + +func (s *Query_specificationContext) INTO() antlr.TerminalNode { + return s.GetToken(TSqlParserINTO, 0) +} + +func (s *Query_specificationContext) From_table_sources() IFrom_table_sourcesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_table_sourcesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_table_sourcesContext) +} + +func (s *Query_specificationContext) WHERE() antlr.TerminalNode { + return s.GetToken(TSqlParserWHERE, 0) +} + +func (s *Query_specificationContext) Group_by_clause() IGroup_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_clauseContext) +} + +func (s *Query_specificationContext) Having_clause() IHaving_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHaving_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHaving_clauseContext) +} + +func (s *Query_specificationContext) Top_clause() ITop_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITop_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITop_clauseContext) +} + +func (s *Query_specificationContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Query_specificationContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Query_specificationContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Query_specificationContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(TSqlParserDISTINCT, 0) +} + +func (s *Query_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterQuery_specification(s) + } +} + +func (s *Query_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitQuery_specification(s) + } +} + +func (s *Query_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitQuery_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Query_specification() (localctx IQuery_specificationContext) { + localctx = NewQuery_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 958, TSqlParserRULE_query_specification) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11435) + p.Match(TSqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11437) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserALL || _la == TSqlParserDISTINCT { + { + p.SetState(11436) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Query_specificationContext).allOrDistinct = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALL || _la == TSqlParserDISTINCT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Query_specificationContext).allOrDistinct = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(11440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserTOP { + { + p.SetState(11439) + + var _x = p.Top_clause() + + localctx.(*Query_specificationContext).top = _x + } + + } + { + p.SetState(11442) + + var _x = p.Select_list() + + localctx.(*Query_specificationContext).columns = _x + } + p.SetState(11445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserINTO { + { + p.SetState(11443) + p.Match(TSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11444) + + var _x = p.Table_name() + + localctx.(*Query_specificationContext).into = _x + } + + } + p.SetState(11448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFROM { + { + p.SetState(11447) + p.From_table_sources() + } + + } + p.SetState(11452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWHERE { + { + p.SetState(11450) + p.Match(TSqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11451) + + var _x = p.search_condition(0) + + localctx.(*Query_specificationContext).where = _x + } + + } + p.SetState(11455) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserGROUP { + { + p.SetState(11454) + p.Group_by_clause() + } + + } + p.SetState(11458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserHAVING { + { + p.SetState(11457) + p.Having_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroup_by_clauseContext is an interface to support dynamic dispatch. +type IGroup_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetGroupByAll returns the groupByAll token. + GetGroupByAll() antlr.Token + + // SetGroupByAll sets the groupByAll token. + SetGroupByAll(antlr.Token) + + // Get_group_by_item returns the _group_by_item rule contexts. + Get_group_by_item() IGroup_by_itemContext + + // Get_grouping_sets_item returns the _grouping_sets_item rule contexts. + Get_grouping_sets_item() IGrouping_sets_itemContext + + // Set_group_by_item sets the _group_by_item rule contexts. + Set_group_by_item(IGroup_by_itemContext) + + // Set_grouping_sets_item sets the _grouping_sets_item rule contexts. + Set_grouping_sets_item(IGrouping_sets_itemContext) + + // GetGroupBys returns the groupBys rule context list. + GetGroupBys() []IGroup_by_itemContext + + // GetGroupSets returns the groupSets rule context list. + GetGroupSets() []IGrouping_sets_itemContext + + // SetGroupBys sets the groupBys rule context list. + SetGroupBys([]IGroup_by_itemContext) + + // SetGroupSets sets the groupSets rule context list. + SetGroupSets([]IGrouping_sets_itemContext) + + // Getter signatures + GROUP() antlr.TerminalNode + BY() antlr.TerminalNode + GROUPING() antlr.TerminalNode + SETS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllGrouping_sets_item() []IGrouping_sets_itemContext + Grouping_sets_item(i int) IGrouping_sets_itemContext + AllGroup_by_item() []IGroup_by_itemContext + Group_by_item(i int) IGroup_by_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsGroup_by_clauseContext differentiates from other interfaces. + IsGroup_by_clauseContext() +} + +type Group_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + groupByAll antlr.Token + _group_by_item IGroup_by_itemContext + groupBys []IGroup_by_itemContext + _grouping_sets_item IGrouping_sets_itemContext + groupSets []IGrouping_sets_itemContext +} + +func NewEmptyGroup_by_clauseContext() *Group_by_clauseContext { + var p = new(Group_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_group_by_clause + return p +} + +func InitEmptyGroup_by_clauseContext(p *Group_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_group_by_clause +} + +func (*Group_by_clauseContext) IsGroup_by_clauseContext() {} + +func NewGroup_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_clauseContext { + var p = new(Group_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_group_by_clause + + return p +} + +func (s *Group_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_by_clauseContext) GetGroupByAll() antlr.Token { return s.groupByAll } + +func (s *Group_by_clauseContext) SetGroupByAll(v antlr.Token) { s.groupByAll = v } + +func (s *Group_by_clauseContext) Get_group_by_item() IGroup_by_itemContext { return s._group_by_item } + +func (s *Group_by_clauseContext) Get_grouping_sets_item() IGrouping_sets_itemContext { + return s._grouping_sets_item +} + +func (s *Group_by_clauseContext) Set_group_by_item(v IGroup_by_itemContext) { s._group_by_item = v } + +func (s *Group_by_clauseContext) Set_grouping_sets_item(v IGrouping_sets_itemContext) { + s._grouping_sets_item = v +} + +func (s *Group_by_clauseContext) GetGroupBys() []IGroup_by_itemContext { return s.groupBys } + +func (s *Group_by_clauseContext) GetGroupSets() []IGrouping_sets_itemContext { return s.groupSets } + +func (s *Group_by_clauseContext) SetGroupBys(v []IGroup_by_itemContext) { s.groupBys = v } + +func (s *Group_by_clauseContext) SetGroupSets(v []IGrouping_sets_itemContext) { s.groupSets = v } + +func (s *Group_by_clauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *Group_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Group_by_clauseContext) GROUPING() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUPING, 0) +} + +func (s *Group_by_clauseContext) SETS() antlr.TerminalNode { + return s.GetToken(TSqlParserSETS, 0) +} + +func (s *Group_by_clauseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Group_by_clauseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Group_by_clauseContext) AllGrouping_sets_item() []IGrouping_sets_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGrouping_sets_itemContext); ok { + len++ + } + } + + tst := make([]IGrouping_sets_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGrouping_sets_itemContext); ok { + tst[i] = t.(IGrouping_sets_itemContext) + i++ + } + } + + return tst +} + +func (s *Group_by_clauseContext) Grouping_sets_item(i int) IGrouping_sets_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrouping_sets_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGrouping_sets_itemContext) +} + +func (s *Group_by_clauseContext) AllGroup_by_item() []IGroup_by_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGroup_by_itemContext); ok { + len++ + } + } + + tst := make([]IGroup_by_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGroup_by_itemContext); ok { + tst[i] = t.(IGroup_by_itemContext) + i++ + } + } + + return tst +} + +func (s *Group_by_clauseContext) Group_by_item(i int) IGroup_by_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_itemContext) +} + +func (s *Group_by_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Group_by_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Group_by_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *Group_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterGroup_by_clause(s) + } +} + +func (s *Group_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitGroup_by_clause(s) + } +} + +func (s *Group_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitGroup_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Group_by_clause() (localctx IGroup_by_clauseContext) { + localctx = NewGroup_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 960, TSqlParserRULE_group_by_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11460) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11461) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1552, p.GetParserRuleContext()) { + case 1: + p.SetState(11463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserALL { + { + p.SetState(11462) + + var _m = p.Match(TSqlParserALL) + + localctx.(*Group_by_clauseContext).groupByAll = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11465) + + var _x = p.Group_by_item() + + localctx.(*Group_by_clauseContext)._group_by_item = _x + } + localctx.(*Group_by_clauseContext).groupBys = append(localctx.(*Group_by_clauseContext).groupBys, localctx.(*Group_by_clauseContext)._group_by_item) + p.SetState(11470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11466) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11467) + + var _x = p.Group_by_item() + + localctx.(*Group_by_clauseContext)._group_by_item = _x + } + localctx.(*Group_by_clauseContext).groupBys = append(localctx.(*Group_by_clauseContext).groupBys, localctx.(*Group_by_clauseContext)._group_by_item) + + p.SetState(11472) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(11473) + p.Match(TSqlParserGROUPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11474) + p.Match(TSqlParserSETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11475) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11476) + + var _x = p.Grouping_sets_item() + + localctx.(*Group_by_clauseContext)._grouping_sets_item = _x + } + localctx.(*Group_by_clauseContext).groupSets = append(localctx.(*Group_by_clauseContext).groupSets, localctx.(*Group_by_clauseContext)._grouping_sets_item) + p.SetState(11481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11477) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11478) + + var _x = p.Grouping_sets_item() + + localctx.(*Group_by_clauseContext)._grouping_sets_item = _x + } + localctx.(*Group_by_clauseContext).groupSets = append(localctx.(*Group_by_clauseContext).groupSets, localctx.(*Group_by_clauseContext)._grouping_sets_item) + + p.SetState(11483) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11484) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHaving_clauseContext is an interface to support dynamic dispatch. +type IHaving_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetHaving returns the having rule contexts. + GetHaving() ISearch_conditionContext + + // SetHaving sets the having rule contexts. + SetHaving(ISearch_conditionContext) + + // Getter signatures + HAVING() antlr.TerminalNode + Search_condition() ISearch_conditionContext + + // IsHaving_clauseContext differentiates from other interfaces. + IsHaving_clauseContext() +} + +type Having_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + having ISearch_conditionContext +} + +func NewEmptyHaving_clauseContext() *Having_clauseContext { + var p = new(Having_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_having_clause + return p +} + +func InitEmptyHaving_clauseContext(p *Having_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_having_clause +} + +func (*Having_clauseContext) IsHaving_clauseContext() {} + +func NewHaving_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Having_clauseContext { + var p = new(Having_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_having_clause + + return p +} + +func (s *Having_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Having_clauseContext) GetHaving() ISearch_conditionContext { return s.having } + +func (s *Having_clauseContext) SetHaving(v ISearch_conditionContext) { s.having = v } + +func (s *Having_clauseContext) HAVING() antlr.TerminalNode { + return s.GetToken(TSqlParserHAVING, 0) +} + +func (s *Having_clauseContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Having_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Having_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Having_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterHaving_clause(s) + } +} + +func (s *Having_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitHaving_clause(s) + } +} + +func (s *Having_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitHaving_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Having_clause() (localctx IHaving_clauseContext) { + localctx = NewHaving_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 962, TSqlParserRULE_having_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11488) + p.Match(TSqlParserHAVING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11489) + + var _x = p.search_condition(0) + + localctx.(*Having_clauseContext).having = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrom_table_sourcesContext is an interface to support dynamic dispatch. +type IFrom_table_sourcesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFrom returns the from rule contexts. + GetFrom() ITable_sourcesContext + + // SetFrom sets the from rule contexts. + SetFrom(ITable_sourcesContext) + + // Getter signatures + FROM() antlr.TerminalNode + Table_sources() ITable_sourcesContext + + // IsFrom_table_sourcesContext differentiates from other interfaces. + IsFrom_table_sourcesContext() +} + +type From_table_sourcesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + from ITable_sourcesContext +} + +func NewEmptyFrom_table_sourcesContext() *From_table_sourcesContext { + var p = new(From_table_sourcesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_from_table_sources + return p +} + +func InitEmptyFrom_table_sourcesContext(p *From_table_sourcesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_from_table_sources +} + +func (*From_table_sourcesContext) IsFrom_table_sourcesContext() {} + +func NewFrom_table_sourcesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_table_sourcesContext { + var p = new(From_table_sourcesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_from_table_sources + + return p +} + +func (s *From_table_sourcesContext) GetParser() antlr.Parser { return s.parser } + +func (s *From_table_sourcesContext) GetFrom() ITable_sourcesContext { return s.from } + +func (s *From_table_sourcesContext) SetFrom(v ITable_sourcesContext) { s.from = v } + +func (s *From_table_sourcesContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *From_table_sourcesContext) Table_sources() ITable_sourcesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_sourcesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_sourcesContext) +} + +func (s *From_table_sourcesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *From_table_sourcesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *From_table_sourcesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFrom_table_sources(s) + } +} + +func (s *From_table_sourcesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFrom_table_sources(s) + } +} + +func (s *From_table_sourcesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFrom_table_sources(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) From_table_sources() (localctx IFrom_table_sourcesContext) { + localctx = NewFrom_table_sourcesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 964, TSqlParserRULE_from_table_sources) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11491) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11492) + + var _x = p.Table_sources() + + localctx.(*From_table_sourcesContext).from = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITop_clauseContext is an interface to support dynamic dispatch. +type ITop_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TOP() antlr.TerminalNode + Top_percent() ITop_percentContext + Top_count() ITop_countContext + WITH() antlr.TerminalNode + TIES() antlr.TerminalNode + + // IsTop_clauseContext differentiates from other interfaces. + IsTop_clauseContext() +} + +type Top_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTop_clauseContext() *Top_clauseContext { + var p = new(Top_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_top_clause + return p +} + +func InitEmptyTop_clauseContext(p *Top_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_top_clause +} + +func (*Top_clauseContext) IsTop_clauseContext() {} + +func NewTop_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Top_clauseContext { + var p = new(Top_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_top_clause + + return p +} + +func (s *Top_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Top_clauseContext) TOP() antlr.TerminalNode { + return s.GetToken(TSqlParserTOP, 0) +} + +func (s *Top_clauseContext) Top_percent() ITop_percentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITop_percentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITop_percentContext) +} + +func (s *Top_clauseContext) Top_count() ITop_countContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITop_countContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITop_countContext) +} + +func (s *Top_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Top_clauseContext) TIES() antlr.TerminalNode { + return s.GetToken(TSqlParserTIES, 0) +} + +func (s *Top_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Top_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Top_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTop_clause(s) + } +} + +func (s *Top_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTop_clause(s) + } +} + +func (s *Top_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTop_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Top_clause() (localctx ITop_clauseContext) { + localctx = NewTop_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 966, TSqlParserRULE_top_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11494) + p.Match(TSqlParserTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11497) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1553, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11495) + p.Top_percent() + } + + case 2: + { + p.SetState(11496) + p.Top_count() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(11501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWITH { + { + p.SetState(11499) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11500) + p.Match(TSqlParserTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITop_percentContext is an interface to support dynamic dispatch. +type ITop_percentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPercent_constant returns the percent_constant token. + GetPercent_constant() antlr.Token + + // SetPercent_constant sets the percent_constant token. + SetPercent_constant(antlr.Token) + + // GetTopper_expression returns the topper_expression rule contexts. + GetTopper_expression() IExpressionContext + + // SetTopper_expression sets the topper_expression rule contexts. + SetTopper_expression(IExpressionContext) + + // Getter signatures + PERCENT() antlr.TerminalNode + REAL() antlr.TerminalNode + FLOAT() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Expression() IExpressionContext + + // IsTop_percentContext differentiates from other interfaces. + IsTop_percentContext() +} + +type Top_percentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + percent_constant antlr.Token + topper_expression IExpressionContext +} + +func NewEmptyTop_percentContext() *Top_percentContext { + var p = new(Top_percentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_top_percent + return p +} + +func InitEmptyTop_percentContext(p *Top_percentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_top_percent +} + +func (*Top_percentContext) IsTop_percentContext() {} + +func NewTop_percentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Top_percentContext { + var p = new(Top_percentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_top_percent + + return p +} + +func (s *Top_percentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Top_percentContext) GetPercent_constant() antlr.Token { return s.percent_constant } + +func (s *Top_percentContext) SetPercent_constant(v antlr.Token) { s.percent_constant = v } + +func (s *Top_percentContext) GetTopper_expression() IExpressionContext { return s.topper_expression } + +func (s *Top_percentContext) SetTopper_expression(v IExpressionContext) { s.topper_expression = v } + +func (s *Top_percentContext) PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserPERCENT, 0) +} + +func (s *Top_percentContext) REAL() antlr.TerminalNode { + return s.GetToken(TSqlParserREAL, 0) +} + +func (s *Top_percentContext) FLOAT() antlr.TerminalNode { + return s.GetToken(TSqlParserFLOAT, 0) +} + +func (s *Top_percentContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Top_percentContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Top_percentContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Top_percentContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Top_percentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Top_percentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Top_percentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTop_percent(s) + } +} + +func (s *Top_percentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTop_percent(s) + } +} + +func (s *Top_percentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTop_percent(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Top_percent() (localctx ITop_percentContext) { + localctx = NewTop_percentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 968, TSqlParserRULE_top_percent) + var _la int + + p.SetState(11510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL, TSqlParserFLOAT, TSqlParserREAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11503) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Top_percentContext).percent_constant = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1182)) & ^0x3f) == 0 && ((int64(1)<<(_la-1182))&49) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Top_percentContext).percent_constant = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11504) + p.Match(TSqlParserPERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserLR_BRACKET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11505) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11506) + + var _x = p.expression(0) + + localctx.(*Top_percentContext).topper_expression = _x + } + { + p.SetState(11507) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11508) + p.Match(TSqlParserPERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITop_countContext is an interface to support dynamic dispatch. +type ITop_countContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCount_constant returns the count_constant token. + GetCount_constant() antlr.Token + + // SetCount_constant sets the count_constant token. + SetCount_constant(antlr.Token) + + // GetTopcount_expression returns the topcount_expression rule contexts. + GetTopcount_expression() IExpressionContext + + // SetTopcount_expression sets the topcount_expression rule contexts. + SetTopcount_expression(IExpressionContext) + + // Getter signatures + DECIMAL() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Expression() IExpressionContext + + // IsTop_countContext differentiates from other interfaces. + IsTop_countContext() +} + +type Top_countContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + count_constant antlr.Token + topcount_expression IExpressionContext +} + +func NewEmptyTop_countContext() *Top_countContext { + var p = new(Top_countContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_top_count + return p +} + +func InitEmptyTop_countContext(p *Top_countContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_top_count +} + +func (*Top_countContext) IsTop_countContext() {} + +func NewTop_countContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Top_countContext { + var p = new(Top_countContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_top_count + + return p +} + +func (s *Top_countContext) GetParser() antlr.Parser { return s.parser } + +func (s *Top_countContext) GetCount_constant() antlr.Token { return s.count_constant } + +func (s *Top_countContext) SetCount_constant(v antlr.Token) { s.count_constant = v } + +func (s *Top_countContext) GetTopcount_expression() IExpressionContext { return s.topcount_expression } + +func (s *Top_countContext) SetTopcount_expression(v IExpressionContext) { s.topcount_expression = v } + +func (s *Top_countContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Top_countContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Top_countContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Top_countContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Top_countContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Top_countContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Top_countContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTop_count(s) + } +} + +func (s *Top_countContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTop_count(s) + } +} + +func (s *Top_countContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTop_count(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Top_count() (localctx ITop_countContext) { + localctx = NewTop_countContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 970, TSqlParserRULE_top_count) + p.SetState(11517) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11512) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Top_countContext).count_constant = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserLR_BRACKET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11513) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11514) + + var _x = p.expression(0) + + localctx.(*Top_countContext).topcount_expression = _x + } + { + p.SetState(11515) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrder_by_clauseContext is an interface to support dynamic dispatch. +type IOrder_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_order_by_expression returns the _order_by_expression rule contexts. + Get_order_by_expression() IOrder_by_expressionContext + + // Set_order_by_expression sets the _order_by_expression rule contexts. + Set_order_by_expression(IOrder_by_expressionContext) + + // GetOrder_bys returns the order_bys rule context list. + GetOrder_bys() []IOrder_by_expressionContext + + // SetOrder_bys sets the order_bys rule context list. + SetOrder_bys([]IOrder_by_expressionContext) + + // Getter signatures + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + AllOrder_by_expression() []IOrder_by_expressionContext + Order_by_expression(i int) IOrder_by_expressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOrder_by_clauseContext differentiates from other interfaces. + IsOrder_by_clauseContext() +} + +type Order_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _order_by_expression IOrder_by_expressionContext + order_bys []IOrder_by_expressionContext +} + +func NewEmptyOrder_by_clauseContext() *Order_by_clauseContext { + var p = new(Order_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_order_by_clause + return p +} + +func InitEmptyOrder_by_clauseContext(p *Order_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_order_by_clause +} + +func (*Order_by_clauseContext) IsOrder_by_clauseContext() {} + +func NewOrder_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_clauseContext { + var p = new(Order_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_order_by_clause + + return p +} + +func (s *Order_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Order_by_clauseContext) Get_order_by_expression() IOrder_by_expressionContext { + return s._order_by_expression +} + +func (s *Order_by_clauseContext) Set_order_by_expression(v IOrder_by_expressionContext) { + s._order_by_expression = v +} + +func (s *Order_by_clauseContext) GetOrder_bys() []IOrder_by_expressionContext { return s.order_bys } + +func (s *Order_by_clauseContext) SetOrder_bys(v []IOrder_by_expressionContext) { s.order_bys = v } + +func (s *Order_by_clauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(TSqlParserORDER, 0) +} + +func (s *Order_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Order_by_clauseContext) AllOrder_by_expression() []IOrder_by_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOrder_by_expressionContext); ok { + len++ + } + } + + tst := make([]IOrder_by_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOrder_by_expressionContext); ok { + tst[i] = t.(IOrder_by_expressionContext) + i++ + } + } + + return tst +} + +func (s *Order_by_clauseContext) Order_by_expression(i int) IOrder_by_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_expressionContext) +} + +func (s *Order_by_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Order_by_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Order_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Order_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Order_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOrder_by_clause(s) + } +} + +func (s *Order_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOrder_by_clause(s) + } +} + +func (s *Order_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOrder_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Order_by_clause() (localctx IOrder_by_clauseContext) { + localctx = NewOrder_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 972, TSqlParserRULE_order_by_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11519) + p.Match(TSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11520) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11521) + + var _x = p.Order_by_expression() + + localctx.(*Order_by_clauseContext)._order_by_expression = _x + } + localctx.(*Order_by_clauseContext).order_bys = append(localctx.(*Order_by_clauseContext).order_bys, localctx.(*Order_by_clauseContext)._order_by_expression) + p.SetState(11526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11522) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11523) + + var _x = p.Order_by_expression() + + localctx.(*Order_by_clauseContext)._order_by_expression = _x + } + localctx.(*Order_by_clauseContext).order_bys = append(localctx.(*Order_by_clauseContext).order_bys, localctx.(*Order_by_clauseContext)._order_by_expression) + + p.SetState(11528) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_order_by_clauseContext is an interface to support dynamic dispatch. +type ISelect_order_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOffset_rows returns the offset_rows token. + GetOffset_rows() antlr.Token + + // GetFetch_offset returns the fetch_offset token. + GetFetch_offset() antlr.Token + + // GetFetch_rows returns the fetch_rows token. + GetFetch_rows() antlr.Token + + // SetOffset_rows sets the offset_rows token. + SetOffset_rows(antlr.Token) + + // SetFetch_offset sets the fetch_offset token. + SetFetch_offset(antlr.Token) + + // SetFetch_rows sets the fetch_rows token. + SetFetch_rows(antlr.Token) + + // GetOffset_exp returns the offset_exp rule contexts. + GetOffset_exp() IExpressionContext + + // GetFetch_exp returns the fetch_exp rule contexts. + GetFetch_exp() IExpressionContext + + // SetOffset_exp sets the offset_exp rule contexts. + SetOffset_exp(IExpressionContext) + + // SetFetch_exp sets the fetch_exp rule contexts. + SetFetch_exp(IExpressionContext) + + // Getter signatures + Order_by_clause() IOrder_by_clauseContext + OFFSET() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllROW() []antlr.TerminalNode + ROW(i int) antlr.TerminalNode + AllROWS() []antlr.TerminalNode + ROWS(i int) antlr.TerminalNode + FETCH() antlr.TerminalNode + ONLY() antlr.TerminalNode + FIRST() antlr.TerminalNode + NEXT() antlr.TerminalNode + + // IsSelect_order_by_clauseContext differentiates from other interfaces. + IsSelect_order_by_clauseContext() +} + +type Select_order_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + offset_exp IExpressionContext + offset_rows antlr.Token + fetch_offset antlr.Token + fetch_exp IExpressionContext + fetch_rows antlr.Token +} + +func NewEmptySelect_order_by_clauseContext() *Select_order_by_clauseContext { + var p = new(Select_order_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_select_order_by_clause + return p +} + +func InitEmptySelect_order_by_clauseContext(p *Select_order_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_select_order_by_clause +} + +func (*Select_order_by_clauseContext) IsSelect_order_by_clauseContext() {} + +func NewSelect_order_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_order_by_clauseContext { + var p = new(Select_order_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_select_order_by_clause + + return p +} + +func (s *Select_order_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_order_by_clauseContext) GetOffset_rows() antlr.Token { return s.offset_rows } + +func (s *Select_order_by_clauseContext) GetFetch_offset() antlr.Token { return s.fetch_offset } + +func (s *Select_order_by_clauseContext) GetFetch_rows() antlr.Token { return s.fetch_rows } + +func (s *Select_order_by_clauseContext) SetOffset_rows(v antlr.Token) { s.offset_rows = v } + +func (s *Select_order_by_clauseContext) SetFetch_offset(v antlr.Token) { s.fetch_offset = v } + +func (s *Select_order_by_clauseContext) SetFetch_rows(v antlr.Token) { s.fetch_rows = v } + +func (s *Select_order_by_clauseContext) GetOffset_exp() IExpressionContext { return s.offset_exp } + +func (s *Select_order_by_clauseContext) GetFetch_exp() IExpressionContext { return s.fetch_exp } + +func (s *Select_order_by_clauseContext) SetOffset_exp(v IExpressionContext) { s.offset_exp = v } + +func (s *Select_order_by_clauseContext) SetFetch_exp(v IExpressionContext) { s.fetch_exp = v } + +func (s *Select_order_by_clauseContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Select_order_by_clauseContext) OFFSET() antlr.TerminalNode { + return s.GetToken(TSqlParserOFFSET, 0) +} + +func (s *Select_order_by_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Select_order_by_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Select_order_by_clauseContext) AllROW() []antlr.TerminalNode { + return s.GetTokens(TSqlParserROW) +} + +func (s *Select_order_by_clauseContext) ROW(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserROW, i) +} + +func (s *Select_order_by_clauseContext) AllROWS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserROWS) +} + +func (s *Select_order_by_clauseContext) ROWS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserROWS, i) +} + +func (s *Select_order_by_clauseContext) FETCH() antlr.TerminalNode { + return s.GetToken(TSqlParserFETCH, 0) +} + +func (s *Select_order_by_clauseContext) ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserONLY, 0) +} + +func (s *Select_order_by_clauseContext) FIRST() antlr.TerminalNode { + return s.GetToken(TSqlParserFIRST, 0) +} + +func (s *Select_order_by_clauseContext) NEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserNEXT, 0) +} + +func (s *Select_order_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_order_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_order_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSelect_order_by_clause(s) + } +} + +func (s *Select_order_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSelect_order_by_clause(s) + } +} + +func (s *Select_order_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSelect_order_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Select_order_by_clause() (localctx ISelect_order_by_clauseContext) { + localctx = NewSelect_order_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 974, TSqlParserRULE_select_order_by_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11529) + p.Order_by_clause() + } + p.SetState(11541) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1559, p.GetParserRuleContext()) == 1 { + { + p.SetState(11530) + p.Match(TSqlParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11531) + + var _x = p.expression(0) + + localctx.(*Select_order_by_clauseContext).offset_exp = _x + } + { + p.SetState(11532) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Select_order_by_clauseContext).offset_rows = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserROW || _la == TSqlParserROWS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Select_order_by_clauseContext).offset_rows = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(11539) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1558, p.GetParserRuleContext()) == 1 { + { + p.SetState(11533) + p.Match(TSqlParserFETCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11534) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Select_order_by_clauseContext).fetch_offset = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFIRST || _la == TSqlParserNEXT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Select_order_by_clauseContext).fetch_offset = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11535) + + var _x = p.expression(0) + + localctx.(*Select_order_by_clauseContext).fetch_exp = _x + } + { + p.SetState(11536) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Select_order_by_clauseContext).fetch_rows = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserROW || _la == TSqlParserROWS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Select_order_by_clauseContext).fetch_rows = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11537) + p.Match(TSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFor_clauseContext is an interface to support dynamic dispatch. +type IFor_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + BROWSE() antlr.TerminalNode + XML() antlr.TerminalNode + RAW() antlr.TerminalNode + AUTO() antlr.TerminalNode + AllXml_common_directives() []IXml_common_directivesContext + Xml_common_directives(i int) IXml_common_directivesContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ELEMENTS() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + XMLDATA() antlr.TerminalNode + XMLSCHEMA() antlr.TerminalNode + XSINIL() antlr.TerminalNode + ABSENT() antlr.TerminalNode + EXPLICIT() antlr.TerminalNode + PATH() antlr.TerminalNode + JSON() antlr.TerminalNode + AllROOT() []antlr.TerminalNode + ROOT(i int) antlr.TerminalNode + AllINCLUDE_NULL_VALUES() []antlr.TerminalNode + INCLUDE_NULL_VALUES(i int) antlr.TerminalNode + AllWITHOUT_ARRAY_WRAPPER() []antlr.TerminalNode + WITHOUT_ARRAY_WRAPPER(i int) antlr.TerminalNode + + // IsFor_clauseContext differentiates from other interfaces. + IsFor_clauseContext() +} + +type For_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_clauseContext() *For_clauseContext { + var p = new(For_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_for_clause + return p +} + +func InitEmptyFor_clauseContext(p *For_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_for_clause +} + +func (*For_clauseContext) IsFor_clauseContext() {} + +func NewFor_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_clauseContext { + var p = new(For_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_for_clause + + return p +} + +func (s *For_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *For_clauseContext) BROWSE() antlr.TerminalNode { + return s.GetToken(TSqlParserBROWSE, 0) +} + +func (s *For_clauseContext) XML() antlr.TerminalNode { + return s.GetToken(TSqlParserXML, 0) +} + +func (s *For_clauseContext) RAW() antlr.TerminalNode { + return s.GetToken(TSqlParserRAW, 0) +} + +func (s *For_clauseContext) AUTO() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO, 0) +} + +func (s *For_clauseContext) AllXml_common_directives() []IXml_common_directivesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_common_directivesContext); ok { + len++ + } + } + + tst := make([]IXml_common_directivesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_common_directivesContext); ok { + tst[i] = t.(IXml_common_directivesContext) + i++ + } + } + + return tst +} + +func (s *For_clauseContext) Xml_common_directives(i int) IXml_common_directivesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_common_directivesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_common_directivesContext) +} + +func (s *For_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *For_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *For_clauseContext) ELEMENTS() antlr.TerminalNode { + return s.GetToken(TSqlParserELEMENTS, 0) +} + +func (s *For_clauseContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *For_clauseContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *For_clauseContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *For_clauseContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *For_clauseContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *For_clauseContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *For_clauseContext) XMLDATA() antlr.TerminalNode { + return s.GetToken(TSqlParserXMLDATA, 0) +} + +func (s *For_clauseContext) XMLSCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserXMLSCHEMA, 0) +} + +func (s *For_clauseContext) XSINIL() antlr.TerminalNode { + return s.GetToken(TSqlParserXSINIL, 0) +} + +func (s *For_clauseContext) ABSENT() antlr.TerminalNode { + return s.GetToken(TSqlParserABSENT, 0) +} + +func (s *For_clauseContext) EXPLICIT() antlr.TerminalNode { + return s.GetToken(TSqlParserEXPLICIT, 0) +} + +func (s *For_clauseContext) PATH() antlr.TerminalNode { + return s.GetToken(TSqlParserPATH, 0) +} + +func (s *For_clauseContext) JSON() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON, 0) +} + +func (s *For_clauseContext) AllROOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserROOT) +} + +func (s *For_clauseContext) ROOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserROOT, i) +} + +func (s *For_clauseContext) AllINCLUDE_NULL_VALUES() []antlr.TerminalNode { + return s.GetTokens(TSqlParserINCLUDE_NULL_VALUES) +} + +func (s *For_clauseContext) INCLUDE_NULL_VALUES(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserINCLUDE_NULL_VALUES, i) +} + +func (s *For_clauseContext) AllWITHOUT_ARRAY_WRAPPER() []antlr.TerminalNode { + return s.GetTokens(TSqlParserWITHOUT_ARRAY_WRAPPER) +} + +func (s *For_clauseContext) WITHOUT_ARRAY_WRAPPER(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserWITHOUT_ARRAY_WRAPPER, i) +} + +func (s *For_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFor_clause(s) + } +} + +func (s *For_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFor_clause(s) + } +} + +func (s *For_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFor_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) For_clause() (localctx IFor_clauseContext) { + localctx = NewFor_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 976, TSqlParserRULE_for_clause) + var _la int + + var _alt int + + p.SetState(11632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1576, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11543) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11544) + p.Match(TSqlParserBROWSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11545) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11546) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserRAW: + { + p.SetState(11547) + p.Match(TSqlParserRAW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11551) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1560, p.GetParserRuleContext()) == 1 { + { + p.SetState(11548) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11549) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11550) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserAUTO: + { + p.SetState(11553) + p.Match(TSqlParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(11559) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1562, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11556) + p.Xml_common_directives() + } + + } + p.SetState(11561) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1562, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(11572) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1565, p.GetParserRuleContext()) == 1 { + { + p.SetState(11562) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11570) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserXMLDATA: + { + p.SetState(11563) + p.Match(TSqlParserXMLDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserXMLSCHEMA: + { + p.SetState(11564) + p.Match(TSqlParserXMLSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11568) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1563, p.GetParserRuleContext()) == 1 { + { + p.SetState(11565) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11566) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11567) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11579) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(11574) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11575) + p.Match(TSqlParserELEMENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11577) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1566, p.GetParserRuleContext()) == 1 { + { + p.SetState(11576) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserABSENT || _la == TSqlParserXSINIL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11581) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11582) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11583) + p.Match(TSqlParserEXPLICIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1568, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11584) + p.Xml_common_directives() + } + + } + p.SetState(11589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1568, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(11592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(11590) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11591) + p.Match(TSqlParserXMLDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11594) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11595) + p.Match(TSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11596) + p.Match(TSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11600) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1570, p.GetParserRuleContext()) == 1 { + { + p.SetState(11597) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11598) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11599) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1571, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11602) + p.Xml_common_directives() + } + + } + p.SetState(11607) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1571, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(11613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(11608) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11609) + p.Match(TSqlParserELEMENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11611) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1572, p.GetParserRuleContext()) == 1 { + { + p.SetState(11610) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserABSENT || _la == TSqlParserXSINIL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11615) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11616) + p.Match(TSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11617) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAUTO || _la == TSqlParserPATH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(11629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11618) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserROOT: + { + p.SetState(11619) + p.Match(TSqlParserROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(11620) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11621) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11622) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserINCLUDE_NULL_VALUES: + { + p.SetState(11623) + p.Match(TSqlParserINCLUDE_NULL_VALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserWITHOUT_ARRAY_WRAPPER: + { + p.SetState(11624) + p.Match(TSqlParserWITHOUT_ARRAY_WRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(11631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_common_directivesContext is an interface to support dynamic dispatch. +type IXml_common_directivesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMA() antlr.TerminalNode + BINARY_KEYWORD() antlr.TerminalNode + BASE64() antlr.TerminalNode + TYPE() antlr.TerminalNode + ROOT() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + STRING() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + + // IsXml_common_directivesContext differentiates from other interfaces. + IsXml_common_directivesContext() +} + +type Xml_common_directivesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_common_directivesContext() *Xml_common_directivesContext { + var p = new(Xml_common_directivesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_common_directives + return p +} + +func InitEmptyXml_common_directivesContext(p *Xml_common_directivesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_common_directives +} + +func (*Xml_common_directivesContext) IsXml_common_directivesContext() {} + +func NewXml_common_directivesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_common_directivesContext { + var p = new(Xml_common_directivesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_xml_common_directives + + return p +} + +func (s *Xml_common_directivesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_common_directivesContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Xml_common_directivesContext) BINARY_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY_KEYWORD, 0) +} + +func (s *Xml_common_directivesContext) BASE64() antlr.TerminalNode { + return s.GetToken(TSqlParserBASE64, 0) +} + +func (s *Xml_common_directivesContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *Xml_common_directivesContext) ROOT() antlr.TerminalNode { + return s.GetToken(TSqlParserROOT, 0) +} + +func (s *Xml_common_directivesContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Xml_common_directivesContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Xml_common_directivesContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Xml_common_directivesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_common_directivesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_common_directivesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterXml_common_directives(s) + } +} + +func (s *Xml_common_directivesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitXml_common_directives(s) + } +} + +func (s *Xml_common_directivesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitXml_common_directives(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Xml_common_directives() (localctx IXml_common_directivesContext) { + localctx = NewXml_common_directivesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 978, TSqlParserRULE_xml_common_directives) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11634) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserBINARY_KEYWORD: + { + p.SetState(11635) + p.Match(TSqlParserBINARY_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11636) + p.Match(TSqlParserBASE64) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTYPE: + { + p.SetState(11637) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserROOT: + { + p.SetState(11638) + p.Match(TSqlParserROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11642) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1577, p.GetParserRuleContext()) == 1 { + { + p.SetState(11639) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11640) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11641) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrder_by_expressionContext is an interface to support dynamic dispatch. +type IOrder_by_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAscending returns the ascending token. + GetAscending() antlr.Token + + // GetDescending returns the descending token. + GetDescending() antlr.Token + + // SetAscending sets the ascending token. + SetAscending(antlr.Token) + + // SetDescending sets the descending token. + SetDescending(antlr.Token) + + // GetOrder_by returns the order_by rule contexts. + GetOrder_by() IExpressionContext + + // SetOrder_by sets the order_by rule contexts. + SetOrder_by(IExpressionContext) + + // Getter signatures + Expression() IExpressionContext + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + + // IsOrder_by_expressionContext differentiates from other interfaces. + IsOrder_by_expressionContext() +} + +type Order_by_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + order_by IExpressionContext + ascending antlr.Token + descending antlr.Token +} + +func NewEmptyOrder_by_expressionContext() *Order_by_expressionContext { + var p = new(Order_by_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_order_by_expression + return p +} + +func InitEmptyOrder_by_expressionContext(p *Order_by_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_order_by_expression +} + +func (*Order_by_expressionContext) IsOrder_by_expressionContext() {} + +func NewOrder_by_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_expressionContext { + var p = new(Order_by_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_order_by_expression + + return p +} + +func (s *Order_by_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Order_by_expressionContext) GetAscending() antlr.Token { return s.ascending } + +func (s *Order_by_expressionContext) GetDescending() antlr.Token { return s.descending } + +func (s *Order_by_expressionContext) SetAscending(v antlr.Token) { s.ascending = v } + +func (s *Order_by_expressionContext) SetDescending(v antlr.Token) { s.descending = v } + +func (s *Order_by_expressionContext) GetOrder_by() IExpressionContext { return s.order_by } + +func (s *Order_by_expressionContext) SetOrder_by(v IExpressionContext) { s.order_by = v } + +func (s *Order_by_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Order_by_expressionContext) ASC() antlr.TerminalNode { + return s.GetToken(TSqlParserASC, 0) +} + +func (s *Order_by_expressionContext) DESC() antlr.TerminalNode { + return s.GetToken(TSqlParserDESC, 0) +} + +func (s *Order_by_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Order_by_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Order_by_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOrder_by_expression(s) + } +} + +func (s *Order_by_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOrder_by_expression(s) + } +} + +func (s *Order_by_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOrder_by_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Order_by_expression() (localctx IOrder_by_expressionContext) { + localctx = NewOrder_by_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 980, TSqlParserRULE_order_by_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11646) + + var _x = p.expression(0) + + localctx.(*Order_by_expressionContext).order_by = _x + } + p.SetState(11649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case TSqlParserASC: + { + p.SetState(11647) + + var _m = p.Match(TSqlParserASC) + + localctx.(*Order_by_expressionContext).ascending = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDESC: + { + p.SetState(11648) + + var _m = p.Match(TSqlParserDESC) + + localctx.(*Order_by_expressionContext).descending = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEOF, TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALTER, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBREAK, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKPOINT, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLOSE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMIT, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDEALLOCATE, TSqlParserDECLARE, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETE, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDENY, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROP, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserELSE, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserEND, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCEPT, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXECUTE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFETCH, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFOR, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOTO, TSqlParserGOVERNOR, TSqlParserGRANT, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIF, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERT, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserINTERSECT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserKILL, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMERGE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPEN, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserOPTION, TSqlParserORDER, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRINT, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRAISERROR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECONFIGURE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURN, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREVERT, TSqlParserREVOKE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROLLBACK, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSAVE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELECT, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSET, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSETUSER, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSHUTDOWN, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUNCATE, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNION, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDATE, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSE, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAITFOR, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWHILE, TSqlParserWINDOWS, TSqlParserWITH, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserLR_BRACKET, TSqlParserRR_BRACKET, TSqlParserCOMMA, TSqlParserSEMI: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrouping_sets_itemContext is an interface to support dynamic dispatch. +type IGrouping_sets_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_group_by_item returns the _group_by_item rule contexts. + Get_group_by_item() IGroup_by_itemContext + + // Set_group_by_item sets the _group_by_item rule contexts. + Set_group_by_item(IGroup_by_itemContext) + + // GetGroupSetItems returns the groupSetItems rule context list. + GetGroupSetItems() []IGroup_by_itemContext + + // SetGroupSetItems sets the groupSetItems rule context list. + SetGroupSetItems([]IGroup_by_itemContext) + + // Getter signatures + AllGroup_by_item() []IGroup_by_itemContext + Group_by_item(i int) IGroup_by_itemContext + LR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + + // IsGrouping_sets_itemContext differentiates from other interfaces. + IsGrouping_sets_itemContext() +} + +type Grouping_sets_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _group_by_item IGroup_by_itemContext + groupSetItems []IGroup_by_itemContext +} + +func NewEmptyGrouping_sets_itemContext() *Grouping_sets_itemContext { + var p = new(Grouping_sets_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_grouping_sets_item + return p +} + +func InitEmptyGrouping_sets_itemContext(p *Grouping_sets_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_grouping_sets_item +} + +func (*Grouping_sets_itemContext) IsGrouping_sets_itemContext() {} + +func NewGrouping_sets_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grouping_sets_itemContext { + var p = new(Grouping_sets_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_grouping_sets_item + + return p +} + +func (s *Grouping_sets_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grouping_sets_itemContext) Get_group_by_item() IGroup_by_itemContext { + return s._group_by_item +} + +func (s *Grouping_sets_itemContext) Set_group_by_item(v IGroup_by_itemContext) { s._group_by_item = v } + +func (s *Grouping_sets_itemContext) GetGroupSetItems() []IGroup_by_itemContext { + return s.groupSetItems +} + +func (s *Grouping_sets_itemContext) SetGroupSetItems(v []IGroup_by_itemContext) { s.groupSetItems = v } + +func (s *Grouping_sets_itemContext) AllGroup_by_item() []IGroup_by_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGroup_by_itemContext); ok { + len++ + } + } + + tst := make([]IGroup_by_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGroup_by_itemContext); ok { + tst[i] = t.(IGroup_by_itemContext) + i++ + } + } + + return tst +} + +func (s *Grouping_sets_itemContext) Group_by_item(i int) IGroup_by_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_itemContext) +} + +func (s *Grouping_sets_itemContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Grouping_sets_itemContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Grouping_sets_itemContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Grouping_sets_itemContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Grouping_sets_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grouping_sets_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grouping_sets_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterGrouping_sets_item(s) + } +} + +func (s *Grouping_sets_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitGrouping_sets_item(s) + } +} + +func (s *Grouping_sets_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitGrouping_sets_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Grouping_sets_item() (localctx IGrouping_sets_itemContext) { + localctx = NewGrouping_sets_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 982, TSqlParserRULE_grouping_sets_item) + var _alt int + + p.SetState(11667) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1583, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(11652) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1580, p.GetParserRuleContext()) == 1 { + { + p.SetState(11651) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11654) + + var _x = p.Group_by_item() + + localctx.(*Grouping_sets_itemContext)._group_by_item = _x + } + localctx.(*Grouping_sets_itemContext).groupSetItems = append(localctx.(*Grouping_sets_itemContext).groupSetItems, localctx.(*Grouping_sets_itemContext)._group_by_item) + p.SetState(11659) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1581, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11655) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11656) + + var _x = p.Group_by_item() + + localctx.(*Grouping_sets_itemContext)._group_by_item = _x + } + localctx.(*Grouping_sets_itemContext).groupSetItems = append(localctx.(*Grouping_sets_itemContext).groupSetItems, localctx.(*Grouping_sets_itemContext)._group_by_item) + + } + p.SetState(11661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1581, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(11663) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1582, p.GetParserRuleContext()) == 1 { + { + p.SetState(11662) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11665) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11666) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroup_by_itemContext is an interface to support dynamic dispatch. +type IGroup_by_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + + // IsGroup_by_itemContext differentiates from other interfaces. + IsGroup_by_itemContext() +} + +type Group_by_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_by_itemContext() *Group_by_itemContext { + var p = new(Group_by_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_group_by_item + return p +} + +func InitEmptyGroup_by_itemContext(p *Group_by_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_group_by_item +} + +func (*Group_by_itemContext) IsGroup_by_itemContext() {} + +func NewGroup_by_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_itemContext { + var p = new(Group_by_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_group_by_item + + return p +} + +func (s *Group_by_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_by_itemContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Group_by_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_by_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_by_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterGroup_by_item(s) + } +} + +func (s *Group_by_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitGroup_by_item(s) + } +} + +func (s *Group_by_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitGroup_by_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Group_by_item() (localctx IGroup_by_itemContext) { + localctx = NewGroup_by_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 984, TSqlParserRULE_group_by_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11669) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOption_clauseContext is an interface to support dynamic dispatch. +type IOption_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_option returns the _option rule contexts. + Get_option() IOptionContext + + // Set_option sets the _option rule contexts. + Set_option(IOptionContext) + + // GetOptions returns the options rule context list. + GetOptions() []IOptionContext + + // SetOptions sets the options rule context list. + SetOptions([]IOptionContext) + + // Getter signatures + OPTION() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllOption() []IOptionContext + Option(i int) IOptionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOption_clauseContext differentiates from other interfaces. + IsOption_clauseContext() +} + +type Option_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _option IOptionContext + options []IOptionContext +} + +func NewEmptyOption_clauseContext() *Option_clauseContext { + var p = new(Option_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_option_clause + return p +} + +func InitEmptyOption_clauseContext(p *Option_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_option_clause +} + +func (*Option_clauseContext) IsOption_clauseContext() {} + +func NewOption_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Option_clauseContext { + var p = new(Option_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_option_clause + + return p +} + +func (s *Option_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Option_clauseContext) Get_option() IOptionContext { return s._option } + +func (s *Option_clauseContext) Set_option(v IOptionContext) { s._option = v } + +func (s *Option_clauseContext) GetOptions() []IOptionContext { return s.options } + +func (s *Option_clauseContext) SetOptions(v []IOptionContext) { s.options = v } + +func (s *Option_clauseContext) OPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserOPTION, 0) +} + +func (s *Option_clauseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Option_clauseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Option_clauseContext) AllOption() []IOptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOptionContext); ok { + len++ + } + } + + tst := make([]IOptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOptionContext); ok { + tst[i] = t.(IOptionContext) + i++ + } + } + + return tst +} + +func (s *Option_clauseContext) Option(i int) IOptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOptionContext) +} + +func (s *Option_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Option_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Option_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Option_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Option_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOption_clause(s) + } +} + +func (s *Option_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOption_clause(s) + } +} + +func (s *Option_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOption_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Option_clause() (localctx IOption_clauseContext) { + localctx = NewOption_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 986, TSqlParserRULE_option_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11671) + p.Match(TSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11672) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11673) + + var _x = p.Option() + + localctx.(*Option_clauseContext)._option = _x + } + localctx.(*Option_clauseContext).options = append(localctx.(*Option_clauseContext).options, localctx.(*Option_clauseContext)._option) + p.SetState(11678) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11674) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11675) + + var _x = p.Option() + + localctx.(*Option_clauseContext)._option = _x + } + localctx.(*Option_clauseContext).options = append(localctx.(*Option_clauseContext).options, localctx.(*Option_clauseContext)._option) + + p.SetState(11680) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11681) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptionContext is an interface to support dynamic dispatch. +type IOptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNumber_rows returns the number_rows token. + GetNumber_rows() antlr.Token + + // GetNumber_of_processors returns the number_of_processors token. + GetNumber_of_processors() antlr.Token + + // GetNumber_recursion returns the number_recursion token. + GetNumber_recursion() antlr.Token + + // SetNumber_rows sets the number_rows token. + SetNumber_rows(antlr.Token) + + // SetNumber_of_processors sets the number_of_processors token. + SetNumber_of_processors(antlr.Token) + + // SetNumber_recursion sets the number_recursion token. + SetNumber_recursion(antlr.Token) + + // Getter signatures + FAST() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + GROUP() antlr.TerminalNode + HASH() antlr.TerminalNode + ORDER() antlr.TerminalNode + UNION() antlr.TerminalNode + MERGE() antlr.TerminalNode + CONCAT() antlr.TerminalNode + JOIN() antlr.TerminalNode + LOOP() antlr.TerminalNode + EXPAND() antlr.TerminalNode + VIEWS() antlr.TerminalNode + FORCE() antlr.TerminalNode + IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX() antlr.TerminalNode + KEEP() antlr.TerminalNode + PLAN() antlr.TerminalNode + KEEPFIXED() antlr.TerminalNode + MAXDOP() antlr.TerminalNode + MAXRECURSION() antlr.TerminalNode + OPTIMIZE() antlr.TerminalNode + FOR() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllOptimize_for_arg() []IOptimize_for_argContext + Optimize_for_arg(i int) IOptimize_for_argContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + UNKNOWN() antlr.TerminalNode + PARAMETERIZATION() antlr.TerminalNode + SIMPLE() antlr.TerminalNode + FORCED() antlr.TerminalNode + RECOMPILE() antlr.TerminalNode + ROBUST() antlr.TerminalNode + USE() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsOptionContext differentiates from other interfaces. + IsOptionContext() +} + +type OptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + number_rows antlr.Token + number_of_processors antlr.Token + number_recursion antlr.Token +} + +func NewEmptyOptionContext() *OptionContext { + var p = new(OptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_option + return p +} + +func InitEmptyOptionContext(p *OptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_option +} + +func (*OptionContext) IsOptionContext() {} + +func NewOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionContext { + var p = new(OptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_option + + return p +} + +func (s *OptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptionContext) GetNumber_rows() antlr.Token { return s.number_rows } + +func (s *OptionContext) GetNumber_of_processors() antlr.Token { return s.number_of_processors } + +func (s *OptionContext) GetNumber_recursion() antlr.Token { return s.number_recursion } + +func (s *OptionContext) SetNumber_rows(v antlr.Token) { s.number_rows = v } + +func (s *OptionContext) SetNumber_of_processors(v antlr.Token) { s.number_of_processors = v } + +func (s *OptionContext) SetNumber_recursion(v antlr.Token) { s.number_recursion = v } + +func (s *OptionContext) FAST() antlr.TerminalNode { + return s.GetToken(TSqlParserFAST, 0) +} + +func (s *OptionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *OptionContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *OptionContext) HASH() antlr.TerminalNode { + return s.GetToken(TSqlParserHASH, 0) +} + +func (s *OptionContext) ORDER() antlr.TerminalNode { + return s.GetToken(TSqlParserORDER, 0) +} + +func (s *OptionContext) UNION() antlr.TerminalNode { + return s.GetToken(TSqlParserUNION, 0) +} + +func (s *OptionContext) MERGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMERGE, 0) +} + +func (s *OptionContext) CONCAT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONCAT, 0) +} + +func (s *OptionContext) JOIN() antlr.TerminalNode { + return s.GetToken(TSqlParserJOIN, 0) +} + +func (s *OptionContext) LOOP() antlr.TerminalNode { + return s.GetToken(TSqlParserLOOP, 0) +} + +func (s *OptionContext) EXPAND() antlr.TerminalNode { + return s.GetToken(TSqlParserEXPAND, 0) +} + +func (s *OptionContext) VIEWS() antlr.TerminalNode { + return s.GetToken(TSqlParserVIEWS, 0) +} + +func (s *OptionContext) FORCE() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCE, 0) +} + +func (s *OptionContext) IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, 0) +} + +func (s *OptionContext) KEEP() antlr.TerminalNode { + return s.GetToken(TSqlParserKEEP, 0) +} + +func (s *OptionContext) PLAN() antlr.TerminalNode { + return s.GetToken(TSqlParserPLAN, 0) +} + +func (s *OptionContext) KEEPFIXED() antlr.TerminalNode { + return s.GetToken(TSqlParserKEEPFIXED, 0) +} + +func (s *OptionContext) MAXDOP() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXDOP, 0) +} + +func (s *OptionContext) MAXRECURSION() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXRECURSION, 0) +} + +func (s *OptionContext) OPTIMIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserOPTIMIZE, 0) +} + +func (s *OptionContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *OptionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *OptionContext) AllOptimize_for_arg() []IOptimize_for_argContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOptimize_for_argContext); ok { + len++ + } + } + + tst := make([]IOptimize_for_argContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOptimize_for_argContext); ok { + tst[i] = t.(IOptimize_for_argContext) + i++ + } + } + + return tst +} + +func (s *OptionContext) Optimize_for_arg(i int) IOptimize_for_argContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptimize_for_argContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOptimize_for_argContext) +} + +func (s *OptionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *OptionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *OptionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *OptionContext) UNKNOWN() antlr.TerminalNode { + return s.GetToken(TSqlParserUNKNOWN, 0) +} + +func (s *OptionContext) PARAMETERIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARAMETERIZATION, 0) +} + +func (s *OptionContext) SIMPLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSIMPLE, 0) +} + +func (s *OptionContext) FORCED() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCED, 0) +} + +func (s *OptionContext) RECOMPILE() antlr.TerminalNode { + return s.GetToken(TSqlParserRECOMPILE, 0) +} + +func (s *OptionContext) ROBUST() antlr.TerminalNode { + return s.GetToken(TSqlParserROBUST, 0) +} + +func (s *OptionContext) USE() antlr.TerminalNode { + return s.GetToken(TSqlParserUSE, 0) +} + +func (s *OptionContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *OptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOption(s) + } +} + +func (s *OptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOption(s) + } +} + +func (s *OptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Option() (localctx IOptionContext) { + localctx = NewOptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 988, TSqlParserRULE_option) + var _la int + + p.SetState(11728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1586, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11683) + p.Match(TSqlParserFAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11684) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*OptionContext).number_rows = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11685) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserHASH || _la == TSqlParserORDER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11686) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11687) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCONCAT || _la == TSqlParserHASH || _la == TSqlParserMERGE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11688) + p.Match(TSqlParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11689) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserHASH || _la == TSqlParserLOOP || _la == TSqlParserMERGE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11690) + p.Match(TSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11691) + p.Match(TSqlParserEXPAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11692) + p.Match(TSqlParserVIEWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11693) + p.Match(TSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11694) + p.Match(TSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(11695) + p.Match(TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(11696) + p.Match(TSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11697) + p.Match(TSqlParserPLAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(11698) + p.Match(TSqlParserKEEPFIXED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11699) + p.Match(TSqlParserPLAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(11700) + p.Match(TSqlParserMAXDOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11701) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*OptionContext).number_of_processors = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(11702) + p.Match(TSqlParserMAXRECURSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11703) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*OptionContext).number_recursion = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(11704) + p.Match(TSqlParserOPTIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11705) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11706) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11707) + p.Optimize_for_arg() + } + p.SetState(11712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11708) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11709) + p.Optimize_for_arg() + } + + p.SetState(11714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11715) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(11717) + p.Match(TSqlParserOPTIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11718) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11719) + p.Match(TSqlParserUNKNOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(11720) + p.Match(TSqlParserPARAMETERIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11721) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFORCED || _la == TSqlParserSIMPLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(11722) + p.Match(TSqlParserRECOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(11723) + p.Match(TSqlParserROBUST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11724) + p.Match(TSqlParserPLAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(11725) + p.Match(TSqlParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11726) + p.Match(TSqlParserPLAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11727) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptimize_for_argContext is an interface to support dynamic dispatch. +type IOptimize_for_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL_ID() antlr.TerminalNode + UNKNOWN() antlr.TerminalNode + EQUAL() antlr.TerminalNode + Constant() IConstantContext + NULL_() antlr.TerminalNode + + // IsOptimize_for_argContext differentiates from other interfaces. + IsOptimize_for_argContext() +} + +type Optimize_for_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptimize_for_argContext() *Optimize_for_argContext { + var p = new(Optimize_for_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_optimize_for_arg + return p +} + +func InitEmptyOptimize_for_argContext(p *Optimize_for_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_optimize_for_arg +} + +func (*Optimize_for_argContext) IsOptimize_for_argContext() {} + +func NewOptimize_for_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Optimize_for_argContext { + var p = new(Optimize_for_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_optimize_for_arg + + return p +} + +func (s *Optimize_for_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Optimize_for_argContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Optimize_for_argContext) UNKNOWN() antlr.TerminalNode { + return s.GetToken(TSqlParserUNKNOWN, 0) +} + +func (s *Optimize_for_argContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Optimize_for_argContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *Optimize_for_argContext) NULL_() antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_, 0) +} + +func (s *Optimize_for_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Optimize_for_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Optimize_for_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOptimize_for_arg(s) + } +} + +func (s *Optimize_for_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOptimize_for_arg(s) + } +} + +func (s *Optimize_for_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOptimize_for_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Optimize_for_arg() (localctx IOptimize_for_argContext) { + localctx = NewOptimize_for_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 990, TSqlParserRULE_optimize_for_arg) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11730) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserUNKNOWN: + { + p.SetState(11731) + p.Match(TSqlParserUNKNOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserEQUAL: + { + p.SetState(11732) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL, TSqlParserSTRING, TSqlParserBINARY, TSqlParserFLOAT, TSqlParserREAL, TSqlParserDOLLAR, TSqlParserMINUS, TSqlParserPLACEHOLDER: + { + p.SetState(11733) + p.Constant() + } + + case TSqlParserNULL_: + { + p.SetState(11734) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_listContext is an interface to support dynamic dispatch. +type ISelect_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_select_list_elem returns the _select_list_elem rule contexts. + Get_select_list_elem() ISelect_list_elemContext + + // Set_select_list_elem sets the _select_list_elem rule contexts. + Set_select_list_elem(ISelect_list_elemContext) + + // GetSelectElement returns the selectElement rule context list. + GetSelectElement() []ISelect_list_elemContext + + // SetSelectElement sets the selectElement rule context list. + SetSelectElement([]ISelect_list_elemContext) + + // Getter signatures + AllSelect_list_elem() []ISelect_list_elemContext + Select_list_elem(i int) ISelect_list_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSelect_listContext differentiates from other interfaces. + IsSelect_listContext() +} + +type Select_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _select_list_elem ISelect_list_elemContext + selectElement []ISelect_list_elemContext +} + +func NewEmptySelect_listContext() *Select_listContext { + var p = new(Select_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_select_list + return p +} + +func InitEmptySelect_listContext(p *Select_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_select_list +} + +func (*Select_listContext) IsSelect_listContext() {} + +func NewSelect_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_listContext { + var p = new(Select_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_select_list + + return p +} + +func (s *Select_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_listContext) Get_select_list_elem() ISelect_list_elemContext { + return s._select_list_elem +} + +func (s *Select_listContext) Set_select_list_elem(v ISelect_list_elemContext) { + s._select_list_elem = v +} + +func (s *Select_listContext) GetSelectElement() []ISelect_list_elemContext { return s.selectElement } + +func (s *Select_listContext) SetSelectElement(v []ISelect_list_elemContext) { s.selectElement = v } + +func (s *Select_listContext) AllSelect_list_elem() []ISelect_list_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelect_list_elemContext); ok { + len++ + } + } + + tst := make([]ISelect_list_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelect_list_elemContext); ok { + tst[i] = t.(ISelect_list_elemContext) + i++ + } + } + + return tst +} + +func (s *Select_listContext) Select_list_elem(i int) ISelect_list_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_list_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelect_list_elemContext) +} + +func (s *Select_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Select_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Select_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSelect_list(s) + } +} + +func (s *Select_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSelect_list(s) + } +} + +func (s *Select_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSelect_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Select_list() (localctx ISelect_listContext) { + localctx = NewSelect_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 992, TSqlParserRULE_select_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11739) + + var _x = p.Select_list_elem() + + localctx.(*Select_listContext)._select_list_elem = _x + } + localctx.(*Select_listContext).selectElement = append(localctx.(*Select_listContext).selectElement, localctx.(*Select_listContext)._select_list_elem) + p.SetState(11744) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11740) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11741) + + var _x = p.Select_list_elem() + + localctx.(*Select_listContext)._select_list_elem = _x + } + localctx.(*Select_listContext).selectElement = append(localctx.(*Select_listContext).selectElement, localctx.(*Select_listContext)._select_list_elem) + + p.SetState(11746) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUdt_method_argumentsContext is an interface to support dynamic dispatch. +type IUdt_method_argumentsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_execute_var_string returns the _execute_var_string rule contexts. + Get_execute_var_string() IExecute_var_stringContext + + // Set_execute_var_string sets the _execute_var_string rule contexts. + Set_execute_var_string(IExecute_var_stringContext) + + // GetArgument returns the argument rule context list. + GetArgument() []IExecute_var_stringContext + + // SetArgument sets the argument rule context list. + SetArgument([]IExecute_var_stringContext) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllExecute_var_string() []IExecute_var_stringContext + Execute_var_string(i int) IExecute_var_stringContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUdt_method_argumentsContext differentiates from other interfaces. + IsUdt_method_argumentsContext() +} + +type Udt_method_argumentsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _execute_var_string IExecute_var_stringContext + argument []IExecute_var_stringContext +} + +func NewEmptyUdt_method_argumentsContext() *Udt_method_argumentsContext { + var p = new(Udt_method_argumentsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_udt_method_arguments + return p +} + +func InitEmptyUdt_method_argumentsContext(p *Udt_method_argumentsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_udt_method_arguments +} + +func (*Udt_method_argumentsContext) IsUdt_method_argumentsContext() {} + +func NewUdt_method_argumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Udt_method_argumentsContext { + var p = new(Udt_method_argumentsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_udt_method_arguments + + return p +} + +func (s *Udt_method_argumentsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Udt_method_argumentsContext) Get_execute_var_string() IExecute_var_stringContext { + return s._execute_var_string +} + +func (s *Udt_method_argumentsContext) Set_execute_var_string(v IExecute_var_stringContext) { + s._execute_var_string = v +} + +func (s *Udt_method_argumentsContext) GetArgument() []IExecute_var_stringContext { return s.argument } + +func (s *Udt_method_argumentsContext) SetArgument(v []IExecute_var_stringContext) { s.argument = v } + +func (s *Udt_method_argumentsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Udt_method_argumentsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Udt_method_argumentsContext) AllExecute_var_string() []IExecute_var_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExecute_var_stringContext); ok { + len++ + } + } + + tst := make([]IExecute_var_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExecute_var_stringContext); ok { + tst[i] = t.(IExecute_var_stringContext) + i++ + } + } + + return tst +} + +func (s *Udt_method_argumentsContext) Execute_var_string(i int) IExecute_var_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_var_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExecute_var_stringContext) +} + +func (s *Udt_method_argumentsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Udt_method_argumentsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Udt_method_argumentsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Udt_method_argumentsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Udt_method_argumentsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUdt_method_arguments(s) + } +} + +func (s *Udt_method_argumentsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUdt_method_arguments(s) + } +} + +func (s *Udt_method_argumentsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUdt_method_arguments(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Udt_method_arguments() (localctx IUdt_method_argumentsContext) { + localctx = NewUdt_method_argumentsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 994, TSqlParserRULE_udt_method_arguments) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11747) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11748) + + var _x = p.Execute_var_string() + + localctx.(*Udt_method_argumentsContext)._execute_var_string = _x + } + localctx.(*Udt_method_argumentsContext).argument = append(localctx.(*Udt_method_argumentsContext).argument, localctx.(*Udt_method_argumentsContext)._execute_var_string) + p.SetState(11753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11749) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11750) + + var _x = p.Execute_var_string() + + localctx.(*Udt_method_argumentsContext)._execute_var_string = _x + } + localctx.(*Udt_method_argumentsContext).argument = append(localctx.(*Udt_method_argumentsContext).argument, localctx.(*Udt_method_argumentsContext)._execute_var_string) + + p.SetState(11755) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11756) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAsteriskContext is an interface to support dynamic dispatch. +type IAsteriskContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STAR() antlr.TerminalNode + Table_name() ITable_nameContext + DOT() antlr.TerminalNode + INSERTED() antlr.TerminalNode + DELETED() antlr.TerminalNode + + // IsAsteriskContext differentiates from other interfaces. + IsAsteriskContext() +} + +type AsteriskContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAsteriskContext() *AsteriskContext { + var p = new(AsteriskContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_asterisk + return p +} + +func InitEmptyAsteriskContext(p *AsteriskContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_asterisk +} + +func (*AsteriskContext) IsAsteriskContext() {} + +func NewAsteriskContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AsteriskContext { + var p = new(AsteriskContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_asterisk + + return p +} + +func (s *AsteriskContext) GetParser() antlr.Parser { return s.parser } + +func (s *AsteriskContext) STAR() antlr.TerminalNode { + return s.GetToken(TSqlParserSTAR, 0) +} + +func (s *AsteriskContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *AsteriskContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *AsteriskContext) INSERTED() antlr.TerminalNode { + return s.GetToken(TSqlParserINSERTED, 0) +} + +func (s *AsteriskContext) DELETED() antlr.TerminalNode { + return s.GetToken(TSqlParserDELETED, 0) +} + +func (s *AsteriskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AsteriskContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AsteriskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAsterisk(s) + } +} + +func (s *AsteriskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAsterisk(s) + } +} + +func (s *AsteriskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAsterisk(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Asterisk() (localctx IAsteriskContext) { + localctx = NewAsteriskContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 996, TSqlParserRULE_asterisk) + var _la int + + p.SetState(11767) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1592, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(11761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&22413823) != 0) { + { + p.SetState(11758) + p.Table_name() + } + { + p.SetState(11759) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11763) + p.Match(TSqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11764) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDELETED || _la == TSqlParserINSERTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11765) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11766) + p.Match(TSqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUdt_elemContext is an interface to support dynamic dispatch. +type IUdt_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUdt_column_name returns the udt_column_name rule contexts. + GetUdt_column_name() IId_Context + + // GetNon_static_attr returns the non_static_attr rule contexts. + GetNon_static_attr() IId_Context + + // GetStatic_attr returns the static_attr rule contexts. + GetStatic_attr() IId_Context + + // SetUdt_column_name sets the udt_column_name rule contexts. + SetUdt_column_name(IId_Context) + + // SetNon_static_attr sets the non_static_attr rule contexts. + SetNon_static_attr(IId_Context) + + // SetStatic_attr sets the static_attr rule contexts. + SetStatic_attr(IId_Context) + + // Getter signatures + DOT() antlr.TerminalNode + Udt_method_arguments() IUdt_method_argumentsContext + AllId_() []IId_Context + Id_(i int) IId_Context + As_column_alias() IAs_column_aliasContext + DOUBLE_COLON() antlr.TerminalNode + + // IsUdt_elemContext differentiates from other interfaces. + IsUdt_elemContext() +} + +type Udt_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + udt_column_name IId_Context + non_static_attr IId_Context + static_attr IId_Context +} + +func NewEmptyUdt_elemContext() *Udt_elemContext { + var p = new(Udt_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_udt_elem + return p +} + +func InitEmptyUdt_elemContext(p *Udt_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_udt_elem +} + +func (*Udt_elemContext) IsUdt_elemContext() {} + +func NewUdt_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Udt_elemContext { + var p = new(Udt_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_udt_elem + + return p +} + +func (s *Udt_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Udt_elemContext) GetUdt_column_name() IId_Context { return s.udt_column_name } + +func (s *Udt_elemContext) GetNon_static_attr() IId_Context { return s.non_static_attr } + +func (s *Udt_elemContext) GetStatic_attr() IId_Context { return s.static_attr } + +func (s *Udt_elemContext) SetUdt_column_name(v IId_Context) { s.udt_column_name = v } + +func (s *Udt_elemContext) SetNon_static_attr(v IId_Context) { s.non_static_attr = v } + +func (s *Udt_elemContext) SetStatic_attr(v IId_Context) { s.static_attr = v } + +func (s *Udt_elemContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Udt_elemContext) Udt_method_arguments() IUdt_method_argumentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUdt_method_argumentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUdt_method_argumentsContext) +} + +func (s *Udt_elemContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Udt_elemContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Udt_elemContext) As_column_alias() IAs_column_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_column_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_column_aliasContext) +} + +func (s *Udt_elemContext) DOUBLE_COLON() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_COLON, 0) +} + +func (s *Udt_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Udt_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Udt_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUdt_elem(s) + } +} + +func (s *Udt_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUdt_elem(s) + } +} + +func (s *Udt_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUdt_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Udt_elem() (localctx IUdt_elemContext) { + localctx = NewUdt_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 998, TSqlParserRULE_udt_elem) + p.SetState(11785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1596, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11769) + + var _x = p.Id_() + + localctx.(*Udt_elemContext).udt_column_name = _x + } + { + p.SetState(11770) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11771) + + var _x = p.Id_() + + localctx.(*Udt_elemContext).non_static_attr = _x + } + { + p.SetState(11772) + p.Udt_method_arguments() + } + p.SetState(11774) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1593, p.GetParserRuleContext()) == 1 { + { + p.SetState(11773) + p.As_column_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11776) + + var _x = p.Id_() + + localctx.(*Udt_elemContext).udt_column_name = _x + } + { + p.SetState(11777) + p.Match(TSqlParserDOUBLE_COLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11778) + + var _x = p.Id_() + + localctx.(*Udt_elemContext).static_attr = _x + } + p.SetState(11780) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1594, p.GetParserRuleContext()) == 1 { + { + p.SetState(11779) + p.Udt_method_arguments() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11783) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1595, p.GetParserRuleContext()) == 1 { + { + p.SetState(11782) + p.As_column_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpression_elemContext is an interface to support dynamic dispatch. +type IExpression_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEq returns the eq token. + GetEq() antlr.Token + + // SetEq sets the eq token. + SetEq(antlr.Token) + + // GetLeftAlias returns the leftAlias rule contexts. + GetLeftAlias() IColumn_aliasContext + + // GetLeftAssignment returns the leftAssignment rule contexts. + GetLeftAssignment() IExpressionContext + + // GetExpressionAs returns the expressionAs rule contexts. + GetExpressionAs() IExpressionContext + + // SetLeftAlias sets the leftAlias rule contexts. + SetLeftAlias(IColumn_aliasContext) + + // SetLeftAssignment sets the leftAssignment rule contexts. + SetLeftAssignment(IExpressionContext) + + // SetExpressionAs sets the expressionAs rule contexts. + SetExpressionAs(IExpressionContext) + + // Getter signatures + Column_alias() IColumn_aliasContext + EQUAL() antlr.TerminalNode + Expression() IExpressionContext + As_column_alias() IAs_column_aliasContext + + // IsExpression_elemContext differentiates from other interfaces. + IsExpression_elemContext() +} + +type Expression_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + leftAlias IColumn_aliasContext + eq antlr.Token + leftAssignment IExpressionContext + expressionAs IExpressionContext +} + +func NewEmptyExpression_elemContext() *Expression_elemContext { + var p = new(Expression_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_expression_elem + return p +} + +func InitEmptyExpression_elemContext(p *Expression_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_expression_elem +} + +func (*Expression_elemContext) IsExpression_elemContext() {} + +func NewExpression_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expression_elemContext { + var p = new(Expression_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_expression_elem + + return p +} + +func (s *Expression_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expression_elemContext) GetEq() antlr.Token { return s.eq } + +func (s *Expression_elemContext) SetEq(v antlr.Token) { s.eq = v } + +func (s *Expression_elemContext) GetLeftAlias() IColumn_aliasContext { return s.leftAlias } + +func (s *Expression_elemContext) GetLeftAssignment() IExpressionContext { return s.leftAssignment } + +func (s *Expression_elemContext) GetExpressionAs() IExpressionContext { return s.expressionAs } + +func (s *Expression_elemContext) SetLeftAlias(v IColumn_aliasContext) { s.leftAlias = v } + +func (s *Expression_elemContext) SetLeftAssignment(v IExpressionContext) { s.leftAssignment = v } + +func (s *Expression_elemContext) SetExpressionAs(v IExpressionContext) { s.expressionAs = v } + +func (s *Expression_elemContext) Column_alias() IColumn_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Expression_elemContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Expression_elemContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Expression_elemContext) As_column_alias() IAs_column_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_column_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_column_aliasContext) +} + +func (s *Expression_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expression_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expression_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExpression_elem(s) + } +} + +func (s *Expression_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExpression_elem(s) + } +} + +func (s *Expression_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExpression_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Expression_elem() (localctx IExpression_elemContext) { + localctx = NewExpression_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1000, TSqlParserRULE_expression_elem) + p.SetState(11795) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1598, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11787) + + var _x = p.Column_alias() + + localctx.(*Expression_elemContext).leftAlias = _x + } + { + p.SetState(11788) + + var _m = p.Match(TSqlParserEQUAL) + + localctx.(*Expression_elemContext).eq = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11789) + + var _x = p.expression(0) + + localctx.(*Expression_elemContext).leftAssignment = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11791) + + var _x = p.expression(0) + + localctx.(*Expression_elemContext).expressionAs = _x + } + p.SetState(11793) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1597, p.GetParserRuleContext()) == 1 { + { + p.SetState(11792) + p.As_column_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_list_elemContext is an interface to support dynamic dispatch. +type ISelect_list_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Asterisk() IAsteriskContext + Udt_elem() IUdt_elemContext + LOCAL_ID() antlr.TerminalNode + Expression() IExpressionContext + Assignment_operator() IAssignment_operatorContext + EQUAL() antlr.TerminalNode + Expression_elem() IExpression_elemContext + + // IsSelect_list_elemContext differentiates from other interfaces. + IsSelect_list_elemContext() +} + +type Select_list_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_list_elemContext() *Select_list_elemContext { + var p = new(Select_list_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_select_list_elem + return p +} + +func InitEmptySelect_list_elemContext(p *Select_list_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_select_list_elem +} + +func (*Select_list_elemContext) IsSelect_list_elemContext() {} + +func NewSelect_list_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_list_elemContext { + var p = new(Select_list_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_select_list_elem + + return p +} + +func (s *Select_list_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_list_elemContext) Asterisk() IAsteriskContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAsteriskContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAsteriskContext) +} + +func (s *Select_list_elemContext) Udt_elem() IUdt_elemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUdt_elemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUdt_elemContext) +} + +func (s *Select_list_elemContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Select_list_elemContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Select_list_elemContext) Assignment_operator() IAssignment_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignment_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignment_operatorContext) +} + +func (s *Select_list_elemContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Select_list_elemContext) Expression_elem() IExpression_elemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_elemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_elemContext) +} + +func (s *Select_list_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_list_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_list_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSelect_list_elem(s) + } +} + +func (s *Select_list_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSelect_list_elem(s) + } +} + +func (s *Select_list_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSelect_list_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Select_list_elem() (localctx ISelect_list_elemContext) { + localctx = NewSelect_list_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1002, TSqlParserRULE_select_list_elem) + p.SetState(11806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1600, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11797) + p.Asterisk() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11798) + p.Udt_elem() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11799) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserPLUS_ASSIGN, TSqlParserMINUS_ASSIGN, TSqlParserMULT_ASSIGN, TSqlParserDIV_ASSIGN, TSqlParserMOD_ASSIGN, TSqlParserAND_ASSIGN, TSqlParserXOR_ASSIGN, TSqlParserOR_ASSIGN: + { + p.SetState(11800) + p.Assignment_operator() + } + + case TSqlParserEQUAL: + { + p.SetState(11801) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(11804) + p.expression(0) + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11805) + p.Expression_elem() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_sourcesContext is an interface to support dynamic dispatch. +type ITable_sourcesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_table_source returns the _table_source rule contexts. + Get_table_source() ITable_sourceContext + + // Set_table_source sets the _table_source rule contexts. + Set_table_source(ITable_sourceContext) + + // GetSource returns the source rule context list. + GetSource() []ITable_sourceContext + + // SetSource sets the source rule context list. + SetSource([]ITable_sourceContext) + + // Getter signatures + AllTable_source() []ITable_sourceContext + Table_source(i int) ITable_sourceContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTable_sourcesContext differentiates from other interfaces. + IsTable_sourcesContext() +} + +type Table_sourcesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _table_source ITable_sourceContext + source []ITable_sourceContext +} + +func NewEmptyTable_sourcesContext() *Table_sourcesContext { + var p = new(Table_sourcesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_sources + return p +} + +func InitEmptyTable_sourcesContext(p *Table_sourcesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_sources +} + +func (*Table_sourcesContext) IsTable_sourcesContext() {} + +func NewTable_sourcesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_sourcesContext { + var p = new(Table_sourcesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_table_sources + + return p +} + +func (s *Table_sourcesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_sourcesContext) Get_table_source() ITable_sourceContext { return s._table_source } + +func (s *Table_sourcesContext) Set_table_source(v ITable_sourceContext) { s._table_source = v } + +func (s *Table_sourcesContext) GetSource() []ITable_sourceContext { return s.source } + +func (s *Table_sourcesContext) SetSource(v []ITable_sourceContext) { s.source = v } + +func (s *Table_sourcesContext) AllTable_source() []ITable_sourceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_sourceContext); ok { + len++ + } + } + + tst := make([]ITable_sourceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_sourceContext); ok { + tst[i] = t.(ITable_sourceContext) + i++ + } + } + + return tst +} + +func (s *Table_sourcesContext) Table_source(i int) ITable_sourceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_sourceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_sourceContext) +} + +func (s *Table_sourcesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Table_sourcesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Table_sourcesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_sourcesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_sourcesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTable_sources(s) + } +} + +func (s *Table_sourcesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTable_sources(s) + } +} + +func (s *Table_sourcesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTable_sources(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Table_sources() (localctx ITable_sourcesContext) { + localctx = NewTable_sourcesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1004, TSqlParserRULE_table_sources) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11808) + + var _x = p.Table_source() + + localctx.(*Table_sourcesContext)._table_source = _x + } + localctx.(*Table_sourcesContext).source = append(localctx.(*Table_sourcesContext).source, localctx.(*Table_sourcesContext)._table_source) + p.SetState(11813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11809) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11810) + + var _x = p.Table_source() + + localctx.(*Table_sourcesContext)._table_source = _x + } + localctx.(*Table_sourcesContext).source = append(localctx.(*Table_sourcesContext).source, localctx.(*Table_sourcesContext)._table_source) + + p.SetState(11815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_sourceContext is an interface to support dynamic dispatch. +type ITable_sourceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_join_part returns the _join_part rule contexts. + Get_join_part() IJoin_partContext + + // Set_join_part sets the _join_part rule contexts. + Set_join_part(IJoin_partContext) + + // GetJoins returns the joins rule context list. + GetJoins() []IJoin_partContext + + // SetJoins sets the joins rule context list. + SetJoins([]IJoin_partContext) + + // Getter signatures + Table_source_item() ITable_source_itemContext + AllJoin_part() []IJoin_partContext + Join_part(i int) IJoin_partContext + + // IsTable_sourceContext differentiates from other interfaces. + IsTable_sourceContext() +} + +type Table_sourceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _join_part IJoin_partContext + joins []IJoin_partContext +} + +func NewEmptyTable_sourceContext() *Table_sourceContext { + var p = new(Table_sourceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_source + return p +} + +func InitEmptyTable_sourceContext(p *Table_sourceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_source +} + +func (*Table_sourceContext) IsTable_sourceContext() {} + +func NewTable_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_sourceContext { + var p = new(Table_sourceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_table_source + + return p +} + +func (s *Table_sourceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_sourceContext) Get_join_part() IJoin_partContext { return s._join_part } + +func (s *Table_sourceContext) Set_join_part(v IJoin_partContext) { s._join_part = v } + +func (s *Table_sourceContext) GetJoins() []IJoin_partContext { return s.joins } + +func (s *Table_sourceContext) SetJoins(v []IJoin_partContext) { s.joins = v } + +func (s *Table_sourceContext) Table_source_item() ITable_source_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_source_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_source_itemContext) +} + +func (s *Table_sourceContext) AllJoin_part() []IJoin_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoin_partContext); ok { + len++ + } + } + + tst := make([]IJoin_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoin_partContext); ok { + tst[i] = t.(IJoin_partContext) + i++ + } + } + + return tst +} + +func (s *Table_sourceContext) Join_part(i int) IJoin_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoin_partContext) +} + +func (s *Table_sourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_sourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_sourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTable_source(s) + } +} + +func (s *Table_sourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTable_source(s) + } +} + +func (s *Table_sourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTable_source(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Table_source() (localctx ITable_sourceContext) { + localctx = NewTable_sourceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1006, TSqlParserRULE_table_source) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11816) + p.Table_source_item() + } + p.SetState(11820) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1602, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11817) + + var _x = p.Join_part() + + localctx.(*Table_sourceContext)._join_part = _x + } + localctx.(*Table_sourceContext).joins = append(localctx.(*Table_sourceContext).joins, localctx.(*Table_sourceContext)._join_part) + + } + p.SetState(11822) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1602, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_source_itemContext is an interface to support dynamic dispatch. +type ITable_source_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLoc_id returns the loc_id token. + GetLoc_id() antlr.Token + + // GetLoc_id_call returns the loc_id_call token. + GetLoc_id_call() antlr.Token + + // SetLoc_id sets the loc_id token. + SetLoc_id(antlr.Token) + + // SetLoc_id_call sets the loc_id_call token. + SetLoc_id_call(antlr.Token) + + // GetLoc_fcall returns the loc_fcall rule contexts. + GetLoc_fcall() IFunction_callContext + + // GetOldstyle_fcall returns the oldstyle_fcall rule contexts. + GetOldstyle_fcall() IFunction_callContext + + // SetLoc_fcall sets the loc_fcall rule contexts. + SetLoc_fcall(IFunction_callContext) + + // SetOldstyle_fcall sets the oldstyle_fcall rule contexts. + SetOldstyle_fcall(IFunction_callContext) + + // Getter signatures + Full_table_name() IFull_table_nameContext + Deprecated_table_hint() IDeprecated_table_hintContext + As_table_alias() IAs_table_aliasContext + With_table_hints() IWith_table_hintsContext + Sybase_legacy_hints() ISybase_legacy_hintsContext + Rowset_function() IRowset_functionContext + LR_BRACKET() antlr.TerminalNode + Derived_table() IDerived_tableContext + RR_BRACKET() antlr.TerminalNode + Column_alias_list() IColumn_alias_listContext + Change_table() IChange_tableContext + Nodes_method() INodes_methodContext + Function_call() IFunction_callContext + LOCAL_ID() antlr.TerminalNode + DOT() antlr.TerminalNode + Open_xml() IOpen_xmlContext + Open_json() IOpen_jsonContext + DOUBLE_COLON() antlr.TerminalNode + Table_source() ITable_sourceContext + + // IsTable_source_itemContext differentiates from other interfaces. + IsTable_source_itemContext() +} + +type Table_source_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + loc_id antlr.Token + loc_id_call antlr.Token + loc_fcall IFunction_callContext + oldstyle_fcall IFunction_callContext +} + +func NewEmptyTable_source_itemContext() *Table_source_itemContext { + var p = new(Table_source_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_source_item + return p +} + +func InitEmptyTable_source_itemContext(p *Table_source_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_source_item +} + +func (*Table_source_itemContext) IsTable_source_itemContext() {} + +func NewTable_source_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_source_itemContext { + var p = new(Table_source_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_table_source_item + + return p +} + +func (s *Table_source_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_source_itemContext) GetLoc_id() antlr.Token { return s.loc_id } + +func (s *Table_source_itemContext) GetLoc_id_call() antlr.Token { return s.loc_id_call } + +func (s *Table_source_itemContext) SetLoc_id(v antlr.Token) { s.loc_id = v } + +func (s *Table_source_itemContext) SetLoc_id_call(v antlr.Token) { s.loc_id_call = v } + +func (s *Table_source_itemContext) GetLoc_fcall() IFunction_callContext { return s.loc_fcall } + +func (s *Table_source_itemContext) GetOldstyle_fcall() IFunction_callContext { return s.oldstyle_fcall } + +func (s *Table_source_itemContext) SetLoc_fcall(v IFunction_callContext) { s.loc_fcall = v } + +func (s *Table_source_itemContext) SetOldstyle_fcall(v IFunction_callContext) { s.oldstyle_fcall = v } + +func (s *Table_source_itemContext) Full_table_name() IFull_table_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_table_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_table_nameContext) +} + +func (s *Table_source_itemContext) Deprecated_table_hint() IDeprecated_table_hintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeprecated_table_hintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeprecated_table_hintContext) +} + +func (s *Table_source_itemContext) As_table_alias() IAs_table_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_table_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_table_aliasContext) +} + +func (s *Table_source_itemContext) With_table_hints() IWith_table_hintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_table_hintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_table_hintsContext) +} + +func (s *Table_source_itemContext) Sybase_legacy_hints() ISybase_legacy_hintsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISybase_legacy_hintsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISybase_legacy_hintsContext) +} + +func (s *Table_source_itemContext) Rowset_function() IRowset_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowset_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowset_functionContext) +} + +func (s *Table_source_itemContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Table_source_itemContext) Derived_table() IDerived_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDerived_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDerived_tableContext) +} + +func (s *Table_source_itemContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Table_source_itemContext) Column_alias_list() IColumn_alias_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_alias_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_alias_listContext) +} + +func (s *Table_source_itemContext) Change_table() IChange_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChange_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChange_tableContext) +} + +func (s *Table_source_itemContext) Nodes_method() INodes_methodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INodes_methodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INodes_methodContext) +} + +func (s *Table_source_itemContext) Function_call() IFunction_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_callContext) +} + +func (s *Table_source_itemContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Table_source_itemContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Table_source_itemContext) Open_xml() IOpen_xmlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpen_xmlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpen_xmlContext) +} + +func (s *Table_source_itemContext) Open_json() IOpen_jsonContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpen_jsonContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpen_jsonContext) +} + +func (s *Table_source_itemContext) DOUBLE_COLON() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_COLON, 0) +} + +func (s *Table_source_itemContext) Table_source() ITable_sourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_sourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_sourceContext) +} + +func (s *Table_source_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_source_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_source_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTable_source_item(s) + } +} + +func (s *Table_source_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTable_source_item(s) + } +} + +func (s *Table_source_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTable_source_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Table_source_item() (localctx ITable_source_itemContext) { + localctx = NewTable_source_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1008, TSqlParserRULE_table_source_item) + p.SetState(11891) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1617, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11823) + p.Full_table_name() + } + { + p.SetState(11824) + p.Deprecated_table_hint() + } + { + p.SetState(11825) + p.As_table_alias() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11827) + p.Full_table_name() + } + p.SetState(11829) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1603, p.GetParserRuleContext()) == 1 { + { + p.SetState(11828) + p.As_table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11834) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1604, p.GetParserRuleContext()) == 1 { + { + p.SetState(11831) + p.With_table_hints() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1604, p.GetParserRuleContext()) == 2 { + { + p.SetState(11832) + p.Deprecated_table_hint() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1604, p.GetParserRuleContext()) == 3 { + { + p.SetState(11833) + p.Sybase_legacy_hints() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11836) + p.Rowset_function() + } + p.SetState(11838) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1605, p.GetParserRuleContext()) == 1 { + { + p.SetState(11837) + p.As_table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11840) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11841) + p.Derived_table() + } + { + p.SetState(11842) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11847) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1607, p.GetParserRuleContext()) == 1 { + { + p.SetState(11843) + p.As_table_alias() + } + p.SetState(11845) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1606, p.GetParserRuleContext()) == 1 { + { + p.SetState(11844) + p.Column_alias_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11849) + p.Change_table() + } + p.SetState(11851) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1608, p.GetParserRuleContext()) == 1 { + { + p.SetState(11850) + p.As_table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11853) + p.Nodes_method() + } + p.SetState(11858) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1610, p.GetParserRuleContext()) == 1 { + { + p.SetState(11854) + p.As_table_alias() + } + p.SetState(11856) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1609, p.GetParserRuleContext()) == 1 { + { + p.SetState(11855) + p.Column_alias_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(11860) + p.Function_call() + } + p.SetState(11865) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1612, p.GetParserRuleContext()) == 1 { + { + p.SetState(11861) + p.As_table_alias() + } + p.SetState(11863) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1611, p.GetParserRuleContext()) == 1 { + { + p.SetState(11862) + p.Column_alias_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(11867) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*Table_source_itemContext).loc_id = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11869) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1613, p.GetParserRuleContext()) == 1 { + { + p.SetState(11868) + p.As_table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(11871) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*Table_source_itemContext).loc_id_call = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11872) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11873) + + var _x = p.Function_call() + + localctx.(*Table_source_itemContext).loc_fcall = _x + } + p.SetState(11878) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1615, p.GetParserRuleContext()) == 1 { + { + p.SetState(11874) + p.As_table_alias() + } + p.SetState(11876) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1614, p.GetParserRuleContext()) == 1 { + { + p.SetState(11875) + p.Column_alias_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(11880) + p.Open_xml() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(11881) + p.Open_json() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(11882) + p.Match(TSqlParserDOUBLE_COLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11883) + + var _x = p.Function_call() + + localctx.(*Table_source_itemContext).oldstyle_fcall = _x + } + p.SetState(11885) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1616, p.GetParserRuleContext()) == 1 { + { + p.SetState(11884) + p.As_table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(11887) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11888) + p.Table_source() + } + { + p.SetState(11889) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpen_xmlContext is an interface to support dynamic dispatch. +type IOpen_xmlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPENXML() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + Schema_declaration() ISchema_declarationContext + As_table_alias() IAs_table_aliasContext + + // IsOpen_xmlContext differentiates from other interfaces. + IsOpen_xmlContext() +} + +type Open_xmlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpen_xmlContext() *Open_xmlContext { + var p = new(Open_xmlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_open_xml + return p +} + +func InitEmptyOpen_xmlContext(p *Open_xmlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_open_xml +} + +func (*Open_xmlContext) IsOpen_xmlContext() {} + +func NewOpen_xmlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Open_xmlContext { + var p = new(Open_xmlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_open_xml + + return p +} + +func (s *Open_xmlContext) GetParser() antlr.Parser { return s.parser } + +func (s *Open_xmlContext) OPENXML() antlr.TerminalNode { + return s.GetToken(TSqlParserOPENXML, 0) +} + +func (s *Open_xmlContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Open_xmlContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Open_xmlContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Open_xmlContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Open_xmlContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Open_xmlContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Open_xmlContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Open_xmlContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Open_xmlContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Open_xmlContext) Schema_declaration() ISchema_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_declarationContext) +} + +func (s *Open_xmlContext) As_table_alias() IAs_table_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_table_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_table_aliasContext) +} + +func (s *Open_xmlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Open_xmlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Open_xmlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOpen_xml(s) + } +} + +func (s *Open_xmlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOpen_xml(s) + } +} + +func (s *Open_xmlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOpen_xml(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Open_xml() (localctx IOpen_xmlContext) { + localctx = NewOpen_xmlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1010, TSqlParserRULE_open_xml) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11893) + p.Match(TSqlParserOPENXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11894) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11895) + p.expression(0) + } + { + p.SetState(11896) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11897) + p.expression(0) + } + p.SetState(11900) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(11898) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11899) + p.expression(0) + } + + } + { + p.SetState(11902) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11908) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1619, p.GetParserRuleContext()) == 1 { + { + p.SetState(11903) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11904) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11905) + p.Schema_declaration() + } + { + p.SetState(11906) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11911) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1620, p.GetParserRuleContext()) == 1 { + { + p.SetState(11910) + p.As_table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpen_jsonContext is an interface to support dynamic dispatch. +type IOpen_jsonContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPENJSON() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + WITH() antlr.TerminalNode + Json_declaration() IJson_declarationContext + As_table_alias() IAs_table_aliasContext + + // IsOpen_jsonContext differentiates from other interfaces. + IsOpen_jsonContext() +} + +type Open_jsonContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpen_jsonContext() *Open_jsonContext { + var p = new(Open_jsonContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_open_json + return p +} + +func InitEmptyOpen_jsonContext(p *Open_jsonContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_open_json +} + +func (*Open_jsonContext) IsOpen_jsonContext() {} + +func NewOpen_jsonContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Open_jsonContext { + var p = new(Open_jsonContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_open_json + + return p +} + +func (s *Open_jsonContext) GetParser() antlr.Parser { return s.parser } + +func (s *Open_jsonContext) OPENJSON() antlr.TerminalNode { + return s.GetToken(TSqlParserOPENJSON, 0) +} + +func (s *Open_jsonContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Open_jsonContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Open_jsonContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Open_jsonContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Open_jsonContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Open_jsonContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Open_jsonContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Open_jsonContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Open_jsonContext) Json_declaration() IJson_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_declarationContext) +} + +func (s *Open_jsonContext) As_table_alias() IAs_table_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_table_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_table_aliasContext) +} + +func (s *Open_jsonContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Open_jsonContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Open_jsonContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOpen_json(s) + } +} + +func (s *Open_jsonContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOpen_json(s) + } +} + +func (s *Open_jsonContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOpen_json(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Open_json() (localctx IOpen_jsonContext) { + localctx = NewOpen_jsonContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1012, TSqlParserRULE_open_json) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11913) + p.Match(TSqlParserOPENJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11914) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11915) + p.expression(0) + } + p.SetState(11918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(11916) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11917) + p.expression(0) + } + + } + { + p.SetState(11920) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11926) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1622, p.GetParserRuleContext()) == 1 { + { + p.SetState(11921) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11922) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11923) + p.Json_declaration() + } + { + p.SetState(11924) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11929) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1623, p.GetParserRuleContext()) == 1 { + { + p.SetState(11928) + p.As_table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_declarationContext is an interface to support dynamic dispatch. +type IJson_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_json_column_declaration returns the _json_column_declaration rule contexts. + Get_json_column_declaration() IJson_column_declarationContext + + // Set_json_column_declaration sets the _json_column_declaration rule contexts. + Set_json_column_declaration(IJson_column_declarationContext) + + // GetJson_col returns the json_col rule context list. + GetJson_col() []IJson_column_declarationContext + + // SetJson_col sets the json_col rule context list. + SetJson_col([]IJson_column_declarationContext) + + // Getter signatures + AllJson_column_declaration() []IJson_column_declarationContext + Json_column_declaration(i int) IJson_column_declarationContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsJson_declarationContext differentiates from other interfaces. + IsJson_declarationContext() +} + +type Json_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _json_column_declaration IJson_column_declarationContext + json_col []IJson_column_declarationContext +} + +func NewEmptyJson_declarationContext() *Json_declarationContext { + var p = new(Json_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_json_declaration + return p +} + +func InitEmptyJson_declarationContext(p *Json_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_json_declaration +} + +func (*Json_declarationContext) IsJson_declarationContext() {} + +func NewJson_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_declarationContext { + var p = new(Json_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_json_declaration + + return p +} + +func (s *Json_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_declarationContext) Get_json_column_declaration() IJson_column_declarationContext { + return s._json_column_declaration +} + +func (s *Json_declarationContext) Set_json_column_declaration(v IJson_column_declarationContext) { + s._json_column_declaration = v +} + +func (s *Json_declarationContext) GetJson_col() []IJson_column_declarationContext { return s.json_col } + +func (s *Json_declarationContext) SetJson_col(v []IJson_column_declarationContext) { s.json_col = v } + +func (s *Json_declarationContext) AllJson_column_declaration() []IJson_column_declarationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJson_column_declarationContext); ok { + len++ + } + } + + tst := make([]IJson_column_declarationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJson_column_declarationContext); ok { + tst[i] = t.(IJson_column_declarationContext) + i++ + } + } + + return tst +} + +func (s *Json_declarationContext) Json_column_declaration(i int) IJson_column_declarationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_column_declarationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJson_column_declarationContext) +} + +func (s *Json_declarationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Json_declarationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Json_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterJson_declaration(s) + } +} + +func (s *Json_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitJson_declaration(s) + } +} + +func (s *Json_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitJson_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Json_declaration() (localctx IJson_declarationContext) { + localctx = NewJson_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1014, TSqlParserRULE_json_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11931) + + var _x = p.Json_column_declaration() + + localctx.(*Json_declarationContext)._json_column_declaration = _x + } + localctx.(*Json_declarationContext).json_col = append(localctx.(*Json_declarationContext).json_col, localctx.(*Json_declarationContext)._json_column_declaration) + p.SetState(11936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11932) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11933) + + var _x = p.Json_column_declaration() + + localctx.(*Json_declarationContext)._json_column_declaration = _x + } + localctx.(*Json_declarationContext).json_col = append(localctx.(*Json_declarationContext).json_col, localctx.(*Json_declarationContext)._json_column_declaration) + + p.SetState(11938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_column_declarationContext is an interface to support dynamic dispatch. +type IJson_column_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_declaration() IColumn_declarationContext + AS() antlr.TerminalNode + JSON() antlr.TerminalNode + + // IsJson_column_declarationContext differentiates from other interfaces. + IsJson_column_declarationContext() +} + +type Json_column_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_column_declarationContext() *Json_column_declarationContext { + var p = new(Json_column_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_json_column_declaration + return p +} + +func InitEmptyJson_column_declarationContext(p *Json_column_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_json_column_declaration +} + +func (*Json_column_declarationContext) IsJson_column_declarationContext() {} + +func NewJson_column_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_column_declarationContext { + var p = new(Json_column_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_json_column_declaration + + return p +} + +func (s *Json_column_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_column_declarationContext) Column_declaration() IColumn_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_declarationContext) +} + +func (s *Json_column_declarationContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *Json_column_declarationContext) JSON() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON, 0) +} + +func (s *Json_column_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_column_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_column_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterJson_column_declaration(s) + } +} + +func (s *Json_column_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitJson_column_declaration(s) + } +} + +func (s *Json_column_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitJson_column_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Json_column_declaration() (localctx IJson_column_declarationContext) { + localctx = NewJson_column_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1016, TSqlParserRULE_json_column_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11939) + p.Column_declaration() + } + p.SetState(11942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(11940) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11941) + p.Match(TSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISchema_declarationContext is an interface to support dynamic dispatch. +type ISchema_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_column_declaration returns the _column_declaration rule contexts. + Get_column_declaration() IColumn_declarationContext + + // Set_column_declaration sets the _column_declaration rule contexts. + Set_column_declaration(IColumn_declarationContext) + + // GetXml_col returns the xml_col rule context list. + GetXml_col() []IColumn_declarationContext + + // SetXml_col sets the xml_col rule context list. + SetXml_col([]IColumn_declarationContext) + + // Getter signatures + AllColumn_declaration() []IColumn_declarationContext + Column_declaration(i int) IColumn_declarationContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSchema_declarationContext differentiates from other interfaces. + IsSchema_declarationContext() +} + +type Schema_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _column_declaration IColumn_declarationContext + xml_col []IColumn_declarationContext +} + +func NewEmptySchema_declarationContext() *Schema_declarationContext { + var p = new(Schema_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_schema_declaration + return p +} + +func InitEmptySchema_declarationContext(p *Schema_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_schema_declaration +} + +func (*Schema_declarationContext) IsSchema_declarationContext() {} + +func NewSchema_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_declarationContext { + var p = new(Schema_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_schema_declaration + + return p +} + +func (s *Schema_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_declarationContext) Get_column_declaration() IColumn_declarationContext { + return s._column_declaration +} + +func (s *Schema_declarationContext) Set_column_declaration(v IColumn_declarationContext) { + s._column_declaration = v +} + +func (s *Schema_declarationContext) GetXml_col() []IColumn_declarationContext { return s.xml_col } + +func (s *Schema_declarationContext) SetXml_col(v []IColumn_declarationContext) { s.xml_col = v } + +func (s *Schema_declarationContext) AllColumn_declaration() []IColumn_declarationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_declarationContext); ok { + len++ + } + } + + tst := make([]IColumn_declarationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_declarationContext); ok { + tst[i] = t.(IColumn_declarationContext) + i++ + } + } + + return tst +} + +func (s *Schema_declarationContext) Column_declaration(i int) IColumn_declarationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_declarationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_declarationContext) +} + +func (s *Schema_declarationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Schema_declarationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Schema_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSchema_declaration(s) + } +} + +func (s *Schema_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSchema_declaration(s) + } +} + +func (s *Schema_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSchema_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Schema_declaration() (localctx ISchema_declarationContext) { + localctx = NewSchema_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1018, TSqlParserRULE_schema_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11944) + + var _x = p.Column_declaration() + + localctx.(*Schema_declarationContext)._column_declaration = _x + } + localctx.(*Schema_declarationContext).xml_col = append(localctx.(*Schema_declarationContext).xml_col, localctx.(*Schema_declarationContext)._column_declaration) + p.SetState(11949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(11945) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11946) + + var _x = p.Column_declaration() + + localctx.(*Schema_declarationContext)._column_declaration = _x + } + localctx.(*Schema_declarationContext).xml_col = append(localctx.(*Schema_declarationContext).xml_col, localctx.(*Schema_declarationContext)._column_declaration) + + p.SetState(11951) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_declarationContext is an interface to support dynamic dispatch. +type IColumn_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + Data_type() IData_typeContext + STRING() antlr.TerminalNode + + // IsColumn_declarationContext differentiates from other interfaces. + IsColumn_declarationContext() +} + +type Column_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_declarationContext() *Column_declarationContext { + var p = new(Column_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_declaration + return p +} + +func InitEmptyColumn_declarationContext(p *Column_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_declaration +} + +func (*Column_declarationContext) IsColumn_declarationContext() {} + +func NewColumn_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_declarationContext { + var p = new(Column_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_column_declaration + + return p +} + +func (s *Column_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_declarationContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Column_declarationContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Column_declarationContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Column_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumn_declaration(s) + } +} + +func (s *Column_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumn_declaration(s) + } +} + +func (s *Column_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumn_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Column_declaration() (localctx IColumn_declarationContext) { + localctx = NewColumn_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1020, TSqlParserRULE_column_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11952) + p.Id_() + } + { + p.SetState(11953) + p.Data_type() + } + p.SetState(11955) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSTRING { + { + p.SetState(11954) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IChange_tableContext is an interface to support dynamic dispatch. +type IChange_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Change_table_changes() IChange_table_changesContext + Change_table_version() IChange_table_versionContext + + // IsChange_tableContext differentiates from other interfaces. + IsChange_tableContext() +} + +type Change_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyChange_tableContext() *Change_tableContext { + var p = new(Change_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_change_table + return p +} + +func InitEmptyChange_tableContext(p *Change_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_change_table +} + +func (*Change_tableContext) IsChange_tableContext() {} + +func NewChange_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Change_tableContext { + var p = new(Change_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_change_table + + return p +} + +func (s *Change_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Change_tableContext) Change_table_changes() IChange_table_changesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChange_table_changesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChange_table_changesContext) +} + +func (s *Change_tableContext) Change_table_version() IChange_table_versionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChange_table_versionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChange_table_versionContext) +} + +func (s *Change_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Change_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Change_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterChange_table(s) + } +} + +func (s *Change_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitChange_table(s) + } +} + +func (s *Change_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitChange_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Change_table() (localctx IChange_tableContext) { + localctx = NewChange_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1022, TSqlParserRULE_change_table) + p.SetState(11959) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1628, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11957) + p.Change_table_changes() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11958) + p.Change_table_version() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IChange_table_changesContext is an interface to support dynamic dispatch. +type IChange_table_changesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetChangesid returns the changesid token. + GetChangesid() antlr.Token + + // SetChangesid sets the changesid token. + SetChangesid(antlr.Token) + + // GetChangetable returns the changetable rule contexts. + GetChangetable() ITable_nameContext + + // SetChangetable sets the changetable rule contexts. + SetChangetable(ITable_nameContext) + + // Getter signatures + CHANGETABLE() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + CHANGES() antlr.TerminalNode + COMMA() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Table_name() ITable_nameContext + NULL_() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + + // IsChange_table_changesContext differentiates from other interfaces. + IsChange_table_changesContext() +} + +type Change_table_changesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + changetable ITable_nameContext + changesid antlr.Token +} + +func NewEmptyChange_table_changesContext() *Change_table_changesContext { + var p = new(Change_table_changesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_change_table_changes + return p +} + +func InitEmptyChange_table_changesContext(p *Change_table_changesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_change_table_changes +} + +func (*Change_table_changesContext) IsChange_table_changesContext() {} + +func NewChange_table_changesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Change_table_changesContext { + var p = new(Change_table_changesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_change_table_changes + + return p +} + +func (s *Change_table_changesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Change_table_changesContext) GetChangesid() antlr.Token { return s.changesid } + +func (s *Change_table_changesContext) SetChangesid(v antlr.Token) { s.changesid = v } + +func (s *Change_table_changesContext) GetChangetable() ITable_nameContext { return s.changetable } + +func (s *Change_table_changesContext) SetChangetable(v ITable_nameContext) { s.changetable = v } + +func (s *Change_table_changesContext) CHANGETABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserCHANGETABLE, 0) +} + +func (s *Change_table_changesContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Change_table_changesContext) CHANGES() antlr.TerminalNode { + return s.GetToken(TSqlParserCHANGES, 0) +} + +func (s *Change_table_changesContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Change_table_changesContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Change_table_changesContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Change_table_changesContext) NULL_() antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_, 0) +} + +func (s *Change_table_changesContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Change_table_changesContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Change_table_changesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Change_table_changesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Change_table_changesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterChange_table_changes(s) + } +} + +func (s *Change_table_changesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitChange_table_changes(s) + } +} + +func (s *Change_table_changesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitChange_table_changes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Change_table_changes() (localctx IChange_table_changesContext) { + localctx = NewChange_table_changesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1024, TSqlParserRULE_change_table_changes) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11961) + p.Match(TSqlParserCHANGETABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11962) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11963) + p.Match(TSqlParserCHANGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11964) + + var _x = p.Table_name() + + localctx.(*Change_table_changesContext).changetable = _x + } + { + p.SetState(11965) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11966) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Change_table_changesContext).changesid = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserNULL_ || _la == TSqlParserLOCAL_ID || _la == TSqlParserDECIMAL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Change_table_changesContext).changesid = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11967) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IChange_table_versionContext is an interface to support dynamic dispatch. +type IChange_table_versionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetVersiontable returns the versiontable rule contexts. + GetVersiontable() ITable_nameContext + + // GetPk_columns returns the pk_columns rule contexts. + GetPk_columns() IFull_column_name_listContext + + // GetPk_values returns the pk_values rule contexts. + GetPk_values() ISelect_listContext + + // SetVersiontable sets the versiontable rule contexts. + SetVersiontable(ITable_nameContext) + + // SetPk_columns sets the pk_columns rule contexts. + SetPk_columns(IFull_column_name_listContext) + + // SetPk_values sets the pk_values rule contexts. + SetPk_values(ISelect_listContext) + + // Getter signatures + CHANGETABLE() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + VERSION() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Table_name() ITable_nameContext + Full_column_name_list() IFull_column_name_listContext + Select_list() ISelect_listContext + + // IsChange_table_versionContext differentiates from other interfaces. + IsChange_table_versionContext() +} + +type Change_table_versionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + versiontable ITable_nameContext + pk_columns IFull_column_name_listContext + pk_values ISelect_listContext +} + +func NewEmptyChange_table_versionContext() *Change_table_versionContext { + var p = new(Change_table_versionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_change_table_version + return p +} + +func InitEmptyChange_table_versionContext(p *Change_table_versionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_change_table_version +} + +func (*Change_table_versionContext) IsChange_table_versionContext() {} + +func NewChange_table_versionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Change_table_versionContext { + var p = new(Change_table_versionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_change_table_version + + return p +} + +func (s *Change_table_versionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Change_table_versionContext) GetVersiontable() ITable_nameContext { return s.versiontable } + +func (s *Change_table_versionContext) GetPk_columns() IFull_column_name_listContext { + return s.pk_columns +} + +func (s *Change_table_versionContext) GetPk_values() ISelect_listContext { return s.pk_values } + +func (s *Change_table_versionContext) SetVersiontable(v ITable_nameContext) { s.versiontable = v } + +func (s *Change_table_versionContext) SetPk_columns(v IFull_column_name_listContext) { + s.pk_columns = v +} + +func (s *Change_table_versionContext) SetPk_values(v ISelect_listContext) { s.pk_values = v } + +func (s *Change_table_versionContext) CHANGETABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserCHANGETABLE, 0) +} + +func (s *Change_table_versionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Change_table_versionContext) VERSION() antlr.TerminalNode { + return s.GetToken(TSqlParserVERSION, 0) +} + +func (s *Change_table_versionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Change_table_versionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Change_table_versionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Change_table_versionContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Change_table_versionContext) Full_column_name_list() IFull_column_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_name_listContext) +} + +func (s *Change_table_versionContext) Select_list() ISelect_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_listContext) +} + +func (s *Change_table_versionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Change_table_versionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Change_table_versionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterChange_table_version(s) + } +} + +func (s *Change_table_versionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitChange_table_version(s) + } +} + +func (s *Change_table_versionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitChange_table_version(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Change_table_version() (localctx IChange_table_versionContext) { + localctx = NewChange_table_versionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1026, TSqlParserRULE_change_table_version) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11969) + p.Match(TSqlParserCHANGETABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11970) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11971) + p.Match(TSqlParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11972) + + var _x = p.Table_name() + + localctx.(*Change_table_versionContext).versiontable = _x + } + { + p.SetState(11973) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11974) + + var _x = p.Full_column_name_list() + + localctx.(*Change_table_versionContext).pk_columns = _x + } + { + p.SetState(11975) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11976) + + var _x = p.Select_list() + + localctx.(*Change_table_versionContext).pk_values = _x + } + { + p.SetState(11977) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_partContext is an interface to support dynamic dispatch. +type IJoin_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Join_on() IJoin_onContext + Cross_join() ICross_joinContext + Apply_() IApply_Context + Pivot() IPivotContext + Unpivot() IUnpivotContext + + // IsJoin_partContext differentiates from other interfaces. + IsJoin_partContext() +} + +type Join_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_partContext() *Join_partContext { + var p = new(Join_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_join_part + return p +} + +func InitEmptyJoin_partContext(p *Join_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_join_part +} + +func (*Join_partContext) IsJoin_partContext() {} + +func NewJoin_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_partContext { + var p = new(Join_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_join_part + + return p +} + +func (s *Join_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_partContext) Join_on() IJoin_onContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_onContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoin_onContext) +} + +func (s *Join_partContext) Cross_join() ICross_joinContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICross_joinContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICross_joinContext) +} + +func (s *Join_partContext) Apply_() IApply_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IApply_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IApply_Context) +} + +func (s *Join_partContext) Pivot() IPivotContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivotContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivotContext) +} + +func (s *Join_partContext) Unpivot() IUnpivotContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivotContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivotContext) +} + +func (s *Join_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterJoin_part(s) + } +} + +func (s *Join_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitJoin_part(s) + } +} + +func (s *Join_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitJoin_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Join_part() (localctx IJoin_partContext) { + localctx = NewJoin_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1028, TSqlParserRULE_join_part) + p.SetState(11984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1629, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11979) + p.Join_on() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11980) + p.Cross_join() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11981) + p.Apply_() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11982) + p.Pivot() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11983) + p.Unpivot() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_onContext is an interface to support dynamic dispatch. +type IJoin_onContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetInner returns the inner token. + GetInner() antlr.Token + + // GetJoin_type returns the join_type token. + GetJoin_type() antlr.Token + + // GetOuter returns the outer token. + GetOuter() antlr.Token + + // GetJoin_hint returns the join_hint token. + GetJoin_hint() antlr.Token + + // SetInner sets the inner token. + SetInner(antlr.Token) + + // SetJoin_type sets the join_type token. + SetJoin_type(antlr.Token) + + // SetOuter sets the outer token. + SetOuter(antlr.Token) + + // SetJoin_hint sets the join_hint token. + SetJoin_hint(antlr.Token) + + // GetSource returns the source rule contexts. + GetSource() ITable_sourceContext + + // GetCond returns the cond rule contexts. + GetCond() ISearch_conditionContext + + // SetSource sets the source rule contexts. + SetSource(ITable_sourceContext) + + // SetCond sets the cond rule contexts. + SetCond(ISearch_conditionContext) + + // Getter signatures + JOIN() antlr.TerminalNode + ON() antlr.TerminalNode + Table_source() ITable_sourceContext + Search_condition() ISearch_conditionContext + LEFT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + FULL() antlr.TerminalNode + LOOP() antlr.TerminalNode + HASH() antlr.TerminalNode + MERGE() antlr.TerminalNode + REMOTE() antlr.TerminalNode + INNER() antlr.TerminalNode + OUTER() antlr.TerminalNode + + // IsJoin_onContext differentiates from other interfaces. + IsJoin_onContext() +} + +type Join_onContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + inner antlr.Token + join_type antlr.Token + outer antlr.Token + join_hint antlr.Token + source ITable_sourceContext + cond ISearch_conditionContext +} + +func NewEmptyJoin_onContext() *Join_onContext { + var p = new(Join_onContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_join_on + return p +} + +func InitEmptyJoin_onContext(p *Join_onContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_join_on +} + +func (*Join_onContext) IsJoin_onContext() {} + +func NewJoin_onContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_onContext { + var p = new(Join_onContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_join_on + + return p +} + +func (s *Join_onContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_onContext) GetInner() antlr.Token { return s.inner } + +func (s *Join_onContext) GetJoin_type() antlr.Token { return s.join_type } + +func (s *Join_onContext) GetOuter() antlr.Token { return s.outer } + +func (s *Join_onContext) GetJoin_hint() antlr.Token { return s.join_hint } + +func (s *Join_onContext) SetInner(v antlr.Token) { s.inner = v } + +func (s *Join_onContext) SetJoin_type(v antlr.Token) { s.join_type = v } + +func (s *Join_onContext) SetOuter(v antlr.Token) { s.outer = v } + +func (s *Join_onContext) SetJoin_hint(v antlr.Token) { s.join_hint = v } + +func (s *Join_onContext) GetSource() ITable_sourceContext { return s.source } + +func (s *Join_onContext) GetCond() ISearch_conditionContext { return s.cond } + +func (s *Join_onContext) SetSource(v ITable_sourceContext) { s.source = v } + +func (s *Join_onContext) SetCond(v ISearch_conditionContext) { s.cond = v } + +func (s *Join_onContext) JOIN() antlr.TerminalNode { + return s.GetToken(TSqlParserJOIN, 0) +} + +func (s *Join_onContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Join_onContext) Table_source() ITable_sourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_sourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_sourceContext) +} + +func (s *Join_onContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Join_onContext) LEFT() antlr.TerminalNode { + return s.GetToken(TSqlParserLEFT, 0) +} + +func (s *Join_onContext) RIGHT() antlr.TerminalNode { + return s.GetToken(TSqlParserRIGHT, 0) +} + +func (s *Join_onContext) FULL() antlr.TerminalNode { + return s.GetToken(TSqlParserFULL, 0) +} + +func (s *Join_onContext) LOOP() antlr.TerminalNode { + return s.GetToken(TSqlParserLOOP, 0) +} + +func (s *Join_onContext) HASH() antlr.TerminalNode { + return s.GetToken(TSqlParserHASH, 0) +} + +func (s *Join_onContext) MERGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMERGE, 0) +} + +func (s *Join_onContext) REMOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOTE, 0) +} + +func (s *Join_onContext) INNER() antlr.TerminalNode { + return s.GetToken(TSqlParserINNER, 0) +} + +func (s *Join_onContext) OUTER() antlr.TerminalNode { + return s.GetToken(TSqlParserOUTER, 0) +} + +func (s *Join_onContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_onContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_onContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterJoin_on(s) + } +} + +func (s *Join_onContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitJoin_on(s) + } +} + +func (s *Join_onContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitJoin_on(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Join_on() (localctx IJoin_onContext) { + localctx = NewJoin_onContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1030, TSqlParserRULE_join_on) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserHASH, TSqlParserINNER, TSqlParserJOIN, TSqlParserLOOP, TSqlParserMERGE, TSqlParserREMOTE: + p.SetState(11987) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserINNER { + { + p.SetState(11986) + + var _m = p.Match(TSqlParserINNER) + + localctx.(*Join_onContext).inner = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserFULL, TSqlParserLEFT, TSqlParserRIGHT: + { + p.SetState(11989) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Join_onContext).join_type = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFULL || _la == TSqlParserLEFT || _la == TSqlParserRIGHT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Join_onContext).join_type = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(11991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserOUTER { + { + p.SetState(11990) + + var _m = p.Match(TSqlParserOUTER) + + localctx.(*Join_onContext).outer = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(11996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserHASH || _la == TSqlParserLOOP || _la == TSqlParserMERGE || _la == TSqlParserREMOTE { + { + p.SetState(11995) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Join_onContext).join_hint = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserHASH || _la == TSqlParserLOOP || _la == TSqlParserMERGE || _la == TSqlParserREMOTE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Join_onContext).join_hint = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(11998) + p.Match(TSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11999) + + var _x = p.Table_source() + + localctx.(*Join_onContext).source = _x + } + { + p.SetState(12000) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12001) + + var _x = p.search_condition(0) + + localctx.(*Join_onContext).cond = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICross_joinContext is an interface to support dynamic dispatch. +type ICross_joinContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CROSS() antlr.TerminalNode + JOIN() antlr.TerminalNode + Table_source_item() ITable_source_itemContext + + // IsCross_joinContext differentiates from other interfaces. + IsCross_joinContext() +} + +type Cross_joinContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCross_joinContext() *Cross_joinContext { + var p = new(Cross_joinContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_cross_join + return p +} + +func InitEmptyCross_joinContext(p *Cross_joinContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_cross_join +} + +func (*Cross_joinContext) IsCross_joinContext() {} + +func NewCross_joinContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cross_joinContext { + var p = new(Cross_joinContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_cross_join + + return p +} + +func (s *Cross_joinContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cross_joinContext) CROSS() antlr.TerminalNode { + return s.GetToken(TSqlParserCROSS, 0) +} + +func (s *Cross_joinContext) JOIN() antlr.TerminalNode { + return s.GetToken(TSqlParserJOIN, 0) +} + +func (s *Cross_joinContext) Table_source_item() ITable_source_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_source_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_source_itemContext) +} + +func (s *Cross_joinContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cross_joinContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cross_joinContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCross_join(s) + } +} + +func (s *Cross_joinContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCross_join(s) + } +} + +func (s *Cross_joinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCross_join(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Cross_join() (localctx ICross_joinContext) { + localctx = NewCross_joinContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1032, TSqlParserRULE_cross_join) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12003) + p.Match(TSqlParserCROSS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12004) + p.Match(TSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12005) + p.Table_source_item() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IApply_Context is an interface to support dynamic dispatch. +type IApply_Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetApply_style returns the apply_style token. + GetApply_style() antlr.Token + + // SetApply_style sets the apply_style token. + SetApply_style(antlr.Token) + + // GetSource returns the source rule contexts. + GetSource() ITable_source_itemContext + + // SetSource sets the source rule contexts. + SetSource(ITable_source_itemContext) + + // Getter signatures + APPLY() antlr.TerminalNode + Table_source_item() ITable_source_itemContext + CROSS() antlr.TerminalNode + OUTER() antlr.TerminalNode + + // IsApply_Context differentiates from other interfaces. + IsApply_Context() +} + +type Apply_Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser + apply_style antlr.Token + source ITable_source_itemContext +} + +func NewEmptyApply_Context() *Apply_Context { + var p = new(Apply_Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_apply_ + return p +} + +func InitEmptyApply_Context(p *Apply_Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_apply_ +} + +func (*Apply_Context) IsApply_Context() {} + +func NewApply_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Apply_Context { + var p = new(Apply_Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_apply_ + + return p +} + +func (s *Apply_Context) GetParser() antlr.Parser { return s.parser } + +func (s *Apply_Context) GetApply_style() antlr.Token { return s.apply_style } + +func (s *Apply_Context) SetApply_style(v antlr.Token) { s.apply_style = v } + +func (s *Apply_Context) GetSource() ITable_source_itemContext { return s.source } + +func (s *Apply_Context) SetSource(v ITable_source_itemContext) { s.source = v } + +func (s *Apply_Context) APPLY() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLY, 0) +} + +func (s *Apply_Context) Table_source_item() ITable_source_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_source_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_source_itemContext) +} + +func (s *Apply_Context) CROSS() antlr.TerminalNode { + return s.GetToken(TSqlParserCROSS, 0) +} + +func (s *Apply_Context) OUTER() antlr.TerminalNode { + return s.GetToken(TSqlParserOUTER, 0) +} + +func (s *Apply_Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Apply_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Apply_Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterApply_(s) + } +} + +func (s *Apply_Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitApply_(s) + } +} + +func (s *Apply_Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitApply_(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Apply_() (localctx IApply_Context) { + localctx = NewApply_Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1034, TSqlParserRULE_apply_) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12007) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Apply_Context).apply_style = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCROSS || _la == TSqlParserOUTER) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Apply_Context).apply_style = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12008) + p.Match(TSqlParserAPPLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12009) + + var _x = p.Table_source_item() + + localctx.(*Apply_Context).source = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivotContext is an interface to support dynamic dispatch. +type IPivotContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PIVOT() antlr.TerminalNode + Pivot_clause() IPivot_clauseContext + As_table_alias() IAs_table_aliasContext + + // IsPivotContext differentiates from other interfaces. + IsPivotContext() +} + +type PivotContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivotContext() *PivotContext { + var p = new(PivotContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_pivot + return p +} + +func InitEmptyPivotContext(p *PivotContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_pivot +} + +func (*PivotContext) IsPivotContext() {} + +func NewPivotContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PivotContext { + var p = new(PivotContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_pivot + + return p +} + +func (s *PivotContext) GetParser() antlr.Parser { return s.parser } + +func (s *PivotContext) PIVOT() antlr.TerminalNode { + return s.GetToken(TSqlParserPIVOT, 0) +} + +func (s *PivotContext) Pivot_clause() IPivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_clauseContext) +} + +func (s *PivotContext) As_table_alias() IAs_table_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_table_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_table_aliasContext) +} + +func (s *PivotContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PivotContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PivotContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPivot(s) + } +} + +func (s *PivotContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPivot(s) + } +} + +func (s *PivotContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPivot(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Pivot() (localctx IPivotContext) { + localctx = NewPivotContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1036, TSqlParserRULE_pivot) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12011) + p.Match(TSqlParserPIVOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12012) + p.Pivot_clause() + } + { + p.SetState(12013) + p.As_table_alias() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnpivotContext is an interface to support dynamic dispatch. +type IUnpivotContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNPIVOT() antlr.TerminalNode + Unpivot_clause() IUnpivot_clauseContext + As_table_alias() IAs_table_aliasContext + + // IsUnpivotContext differentiates from other interfaces. + IsUnpivotContext() +} + +type UnpivotContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnpivotContext() *UnpivotContext { + var p = new(UnpivotContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_unpivot + return p +} + +func InitEmptyUnpivotContext(p *UnpivotContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_unpivot +} + +func (*UnpivotContext) IsUnpivotContext() {} + +func NewUnpivotContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnpivotContext { + var p = new(UnpivotContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_unpivot + + return p +} + +func (s *UnpivotContext) GetParser() antlr.Parser { return s.parser } + +func (s *UnpivotContext) UNPIVOT() antlr.TerminalNode { + return s.GetToken(TSqlParserUNPIVOT, 0) +} + +func (s *UnpivotContext) Unpivot_clause() IUnpivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_clauseContext) +} + +func (s *UnpivotContext) As_table_alias() IAs_table_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_table_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_table_aliasContext) +} + +func (s *UnpivotContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnpivotContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UnpivotContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUnpivot(s) + } +} + +func (s *UnpivotContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUnpivot(s) + } +} + +func (s *UnpivotContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUnpivot(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Unpivot() (localctx IUnpivotContext) { + localctx = NewUnpivotContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1038, TSqlParserRULE_unpivot) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12015) + p.Match(TSqlParserUNPIVOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12016) + p.Unpivot_clause() + } + { + p.SetState(12017) + p.As_table_alias() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_clauseContext is an interface to support dynamic dispatch. +type IPivot_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + Aggregate_windowed_function() IAggregate_windowed_functionContext + FOR() antlr.TerminalNode + Full_column_name() IFull_column_nameContext + IN() antlr.TerminalNode + Column_alias_list() IColumn_alias_listContext + RR_BRACKET() antlr.TerminalNode + + // IsPivot_clauseContext differentiates from other interfaces. + IsPivot_clauseContext() +} + +type Pivot_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_clauseContext() *Pivot_clauseContext { + var p = new(Pivot_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_pivot_clause + return p +} + +func InitEmptyPivot_clauseContext(p *Pivot_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_pivot_clause +} + +func (*Pivot_clauseContext) IsPivot_clauseContext() {} + +func NewPivot_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_clauseContext { + var p = new(Pivot_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_pivot_clause + + return p +} + +func (s *Pivot_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_clauseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Pivot_clauseContext) Aggregate_windowed_function() IAggregate_windowed_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_windowed_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_windowed_functionContext) +} + +func (s *Pivot_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Pivot_clauseContext) Full_column_name() IFull_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *Pivot_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(TSqlParserIN, 0) +} + +func (s *Pivot_clauseContext) Column_alias_list() IColumn_alias_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_alias_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_alias_listContext) +} + +func (s *Pivot_clauseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Pivot_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPivot_clause(s) + } +} + +func (s *Pivot_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPivot_clause(s) + } +} + +func (s *Pivot_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPivot_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Pivot_clause() (localctx IPivot_clauseContext) { + localctx = NewPivot_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1040, TSqlParserRULE_pivot_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12019) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12020) + p.Aggregate_windowed_function() + } + { + p.SetState(12021) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12022) + p.Full_column_name() + } + { + p.SetState(12023) + p.Match(TSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12024) + p.Column_alias_list() + } + { + p.SetState(12025) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnpivot_clauseContext is an interface to support dynamic dispatch. +type IUnpivot_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetUnpivot_exp returns the unpivot_exp rule contexts. + GetUnpivot_exp() IExpressionContext + + // SetUnpivot_exp sets the unpivot_exp rule contexts. + SetUnpivot_exp(IExpressionContext) + + // Getter signatures + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + FOR() antlr.TerminalNode + Full_column_name() IFull_column_nameContext + IN() antlr.TerminalNode + Full_column_name_list() IFull_column_name_listContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + Expression() IExpressionContext + + // IsUnpivot_clauseContext differentiates from other interfaces. + IsUnpivot_clauseContext() +} + +type Unpivot_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + unpivot_exp IExpressionContext +} + +func NewEmptyUnpivot_clauseContext() *Unpivot_clauseContext { + var p = new(Unpivot_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_unpivot_clause + return p +} + +func InitEmptyUnpivot_clauseContext(p *Unpivot_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_unpivot_clause +} + +func (*Unpivot_clauseContext) IsUnpivot_clauseContext() {} + +func NewUnpivot_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unpivot_clauseContext { + var p = new(Unpivot_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_unpivot_clause + + return p +} + +func (s *Unpivot_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unpivot_clauseContext) GetUnpivot_exp() IExpressionContext { return s.unpivot_exp } + +func (s *Unpivot_clauseContext) SetUnpivot_exp(v IExpressionContext) { s.unpivot_exp = v } + +func (s *Unpivot_clauseContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Unpivot_clauseContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Unpivot_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *Unpivot_clauseContext) Full_column_name() IFull_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *Unpivot_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(TSqlParserIN, 0) +} + +func (s *Unpivot_clauseContext) Full_column_name_list() IFull_column_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_name_listContext) +} + +func (s *Unpivot_clauseContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Unpivot_clauseContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Unpivot_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Unpivot_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unpivot_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unpivot_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUnpivot_clause(s) + } +} + +func (s *Unpivot_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUnpivot_clause(s) + } +} + +func (s *Unpivot_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUnpivot_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Unpivot_clause() (localctx IUnpivot_clauseContext) { + localctx = NewUnpivot_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1042, TSqlParserRULE_unpivot_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12027) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12028) + + var _x = p.expression(0) + + localctx.(*Unpivot_clauseContext).unpivot_exp = _x + } + { + p.SetState(12029) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12030) + p.Full_column_name() + } + { + p.SetState(12031) + p.Match(TSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12032) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12033) + p.Full_column_name_list() + } + { + p.SetState(12034) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12035) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFull_column_name_listContext is an interface to support dynamic dispatch. +type IFull_column_name_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_full_column_name returns the _full_column_name rule contexts. + Get_full_column_name() IFull_column_nameContext + + // Set_full_column_name sets the _full_column_name rule contexts. + Set_full_column_name(IFull_column_nameContext) + + // GetColumn returns the column rule context list. + GetColumn() []IFull_column_nameContext + + // SetColumn sets the column rule context list. + SetColumn([]IFull_column_nameContext) + + // Getter signatures + AllFull_column_name() []IFull_column_nameContext + Full_column_name(i int) IFull_column_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFull_column_name_listContext differentiates from other interfaces. + IsFull_column_name_listContext() +} + +type Full_column_name_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _full_column_name IFull_column_nameContext + column []IFull_column_nameContext +} + +func NewEmptyFull_column_name_listContext() *Full_column_name_listContext { + var p = new(Full_column_name_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_full_column_name_list + return p +} + +func InitEmptyFull_column_name_listContext(p *Full_column_name_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_full_column_name_list +} + +func (*Full_column_name_listContext) IsFull_column_name_listContext() {} + +func NewFull_column_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Full_column_name_listContext { + var p = new(Full_column_name_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_full_column_name_list + + return p +} + +func (s *Full_column_name_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Full_column_name_listContext) Get_full_column_name() IFull_column_nameContext { + return s._full_column_name +} + +func (s *Full_column_name_listContext) Set_full_column_name(v IFull_column_nameContext) { + s._full_column_name = v +} + +func (s *Full_column_name_listContext) GetColumn() []IFull_column_nameContext { return s.column } + +func (s *Full_column_name_listContext) SetColumn(v []IFull_column_nameContext) { s.column = v } + +func (s *Full_column_name_listContext) AllFull_column_name() []IFull_column_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFull_column_nameContext); ok { + len++ + } + } + + tst := make([]IFull_column_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFull_column_nameContext); ok { + tst[i] = t.(IFull_column_nameContext) + i++ + } + } + + return tst +} + +func (s *Full_column_name_listContext) Full_column_name(i int) IFull_column_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *Full_column_name_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Full_column_name_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Full_column_name_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Full_column_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Full_column_name_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFull_column_name_list(s) + } +} + +func (s *Full_column_name_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFull_column_name_list(s) + } +} + +func (s *Full_column_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFull_column_name_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Full_column_name_list() (localctx IFull_column_name_listContext) { + localctx = NewFull_column_name_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1044, TSqlParserRULE_full_column_name_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12037) + + var _x = p.Full_column_name() + + localctx.(*Full_column_name_listContext)._full_column_name = _x + } + localctx.(*Full_column_name_listContext).column = append(localctx.(*Full_column_name_listContext).column, localctx.(*Full_column_name_listContext)._full_column_name) + p.SetState(12042) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1634, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(12038) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12039) + + var _x = p.Full_column_name() + + localctx.(*Full_column_name_listContext)._full_column_name = _x + } + localctx.(*Full_column_name_listContext).column = append(localctx.(*Full_column_name_listContext).column, localctx.(*Full_column_name_listContext)._full_column_name) + + } + p.SetState(12044) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1634, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRowset_functionContext is an interface to support dynamic dispatch. +type IRowset_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetProvider_name returns the provider_name token. + GetProvider_name() antlr.Token + + // GetConnectionString returns the connectionString token. + GetConnectionString() antlr.Token + + // GetSql returns the sql token. + GetSql() antlr.Token + + // GetData_file returns the data_file token. + GetData_file() antlr.Token + + // SetProvider_name sets the provider_name token. + SetProvider_name(antlr.Token) + + // SetConnectionString sets the connectionString token. + SetConnectionString(antlr.Token) + + // SetSql sets the sql token. + SetSql(antlr.Token) + + // SetData_file sets the data_file token. + SetData_file(antlr.Token) + + // Getter signatures + OPENROWSET() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + BULK() antlr.TerminalNode + AllBulk_option() []IBulk_optionContext + Bulk_option(i int) IBulk_optionContext + Id_() IId_Context + + // IsRowset_functionContext differentiates from other interfaces. + IsRowset_functionContext() +} + +type Rowset_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + provider_name antlr.Token + connectionString antlr.Token + sql antlr.Token + data_file antlr.Token +} + +func NewEmptyRowset_functionContext() *Rowset_functionContext { + var p = new(Rowset_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_rowset_function + return p +} + +func InitEmptyRowset_functionContext(p *Rowset_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_rowset_function +} + +func (*Rowset_functionContext) IsRowset_functionContext() {} + +func NewRowset_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rowset_functionContext { + var p = new(Rowset_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_rowset_function + + return p +} + +func (s *Rowset_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rowset_functionContext) GetProvider_name() antlr.Token { return s.provider_name } + +func (s *Rowset_functionContext) GetConnectionString() antlr.Token { return s.connectionString } + +func (s *Rowset_functionContext) GetSql() antlr.Token { return s.sql } + +func (s *Rowset_functionContext) GetData_file() antlr.Token { return s.data_file } + +func (s *Rowset_functionContext) SetProvider_name(v antlr.Token) { s.provider_name = v } + +func (s *Rowset_functionContext) SetConnectionString(v antlr.Token) { s.connectionString = v } + +func (s *Rowset_functionContext) SetSql(v antlr.Token) { s.sql = v } + +func (s *Rowset_functionContext) SetData_file(v antlr.Token) { s.data_file = v } + +func (s *Rowset_functionContext) OPENROWSET() antlr.TerminalNode { + return s.GetToken(TSqlParserOPENROWSET, 0) +} + +func (s *Rowset_functionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Rowset_functionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Rowset_functionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Rowset_functionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Rowset_functionContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Rowset_functionContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Rowset_functionContext) BULK() antlr.TerminalNode { + return s.GetToken(TSqlParserBULK, 0) +} + +func (s *Rowset_functionContext) AllBulk_option() []IBulk_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBulk_optionContext); ok { + len++ + } + } + + tst := make([]IBulk_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBulk_optionContext); ok { + tst[i] = t.(IBulk_optionContext) + i++ + } + } + + return tst +} + +func (s *Rowset_functionContext) Bulk_option(i int) IBulk_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBulk_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBulk_optionContext) +} + +func (s *Rowset_functionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Rowset_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rowset_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rowset_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRowset_function(s) + } +} + +func (s *Rowset_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRowset_function(s) + } +} + +func (s *Rowset_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRowset_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Rowset_function() (localctx IRowset_functionContext) { + localctx = NewRowset_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1046, TSqlParserRULE_rowset_function) + var _la int + + p.SetState(12071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1637, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12045) + p.Match(TSqlParserOPENROWSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12046) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12047) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Rowset_functionContext).provider_name = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12048) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12049) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Rowset_functionContext).connectionString = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12050) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12051) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Rowset_functionContext).sql = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12052) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12053) + p.Match(TSqlParserOPENROWSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12054) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12055) + p.Match(TSqlParserBULK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12056) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Rowset_functionContext).data_file = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12057) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12067) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1636, p.GetParserRuleContext()) { + case 1: + { + p.SetState(12058) + p.Bulk_option() + } + p.SetState(12063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(12059) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12060) + p.Bulk_option() + } + + p.SetState(12065) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(12066) + p.Id_() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(12069) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBulk_optionContext is an interface to support dynamic dispatch. +type IBulk_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBulk_option_value returns the bulk_option_value token. + GetBulk_option_value() antlr.Token + + // SetBulk_option_value sets the bulk_option_value token. + SetBulk_option_value(antlr.Token) + + // Getter signatures + Id_() IId_Context + EQUAL() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsBulk_optionContext differentiates from other interfaces. + IsBulk_optionContext() +} + +type Bulk_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + bulk_option_value antlr.Token +} + +func NewEmptyBulk_optionContext() *Bulk_optionContext { + var p = new(Bulk_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_bulk_option + return p +} + +func InitEmptyBulk_optionContext(p *Bulk_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_bulk_option +} + +func (*Bulk_optionContext) IsBulk_optionContext() {} + +func NewBulk_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bulk_optionContext { + var p = new(Bulk_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_bulk_option + + return p +} + +func (s *Bulk_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bulk_optionContext) GetBulk_option_value() antlr.Token { return s.bulk_option_value } + +func (s *Bulk_optionContext) SetBulk_option_value(v antlr.Token) { s.bulk_option_value = v } + +func (s *Bulk_optionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Bulk_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Bulk_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Bulk_optionContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Bulk_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bulk_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bulk_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBulk_option(s) + } +} + +func (s *Bulk_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBulk_option(s) + } +} + +func (s *Bulk_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBulk_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Bulk_option() (localctx IBulk_optionContext) { + localctx = NewBulk_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1048, TSqlParserRULE_bulk_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12073) + p.Id_() + } + { + p.SetState(12074) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12075) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Bulk_optionContext).bulk_option_value = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDECIMAL || _la == TSqlParserSTRING) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Bulk_optionContext).bulk_option_value = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDerived_tableContext is an interface to support dynamic dispatch. +type IDerived_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSubquery() []ISubqueryContext + Subquery(i int) ISubqueryContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllUNION() []antlr.TerminalNode + UNION(i int) antlr.TerminalNode + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + Table_value_constructor() ITable_value_constructorContext + + // IsDerived_tableContext differentiates from other interfaces. + IsDerived_tableContext() +} + +type Derived_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDerived_tableContext() *Derived_tableContext { + var p = new(Derived_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_derived_table + return p +} + +func InitEmptyDerived_tableContext(p *Derived_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_derived_table +} + +func (*Derived_tableContext) IsDerived_tableContext() {} + +func NewDerived_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Derived_tableContext { + var p = new(Derived_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_derived_table + + return p +} + +func (s *Derived_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Derived_tableContext) AllSubquery() []ISubqueryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubqueryContext); ok { + len++ + } + } + + tst := make([]ISubqueryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubqueryContext); ok { + tst[i] = t.(ISubqueryContext) + i++ + } + } + + return tst +} + +func (s *Derived_tableContext) Subquery(i int) ISubqueryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Derived_tableContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Derived_tableContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Derived_tableContext) AllUNION() []antlr.TerminalNode { + return s.GetTokens(TSqlParserUNION) +} + +func (s *Derived_tableContext) UNION(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserUNION, i) +} + +func (s *Derived_tableContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserALL) +} + +func (s *Derived_tableContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserALL, i) +} + +func (s *Derived_tableContext) Table_value_constructor() ITable_value_constructorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_value_constructorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_value_constructorContext) +} + +func (s *Derived_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Derived_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Derived_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDerived_table(s) + } +} + +func (s *Derived_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDerived_table(s) + } +} + +func (s *Derived_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDerived_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Derived_table() (localctx IDerived_tableContext) { + localctx = NewDerived_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1050, TSqlParserRULE_derived_table) + var _la int + + p.SetState(12095) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1639, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12077) + p.Subquery() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12078) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12079) + p.Subquery() + } + p.SetState(12085) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserUNION { + { + p.SetState(12080) + p.Match(TSqlParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12081) + p.Match(TSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12082) + p.Subquery() + } + + p.SetState(12087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12088) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12090) + p.Table_value_constructor() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12091) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12092) + p.Table_value_constructor() + } + { + p.SetState(12093) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_callContext is an interface to support dynamic dispatch. +type IFunction_callContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsFunction_callContext differentiates from other interfaces. + IsFunction_callContext() +} + +type Function_callContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_callContext() *Function_callContext { + var p = new(Function_callContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_function_call + return p +} + +func InitEmptyFunction_callContext(p *Function_callContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_function_call +} + +func (*Function_callContext) IsFunction_callContext() {} + +func NewFunction_callContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_callContext { + var p = new(Function_callContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_function_call + + return p +} + +func (s *Function_callContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_callContext) CopyAll(ctx *Function_callContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *Function_callContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_callContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type RANKING_WINDOWED_FUNCContext struct { + Function_callContext +} + +func NewRANKING_WINDOWED_FUNCContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RANKING_WINDOWED_FUNCContext { + var p = new(RANKING_WINDOWED_FUNCContext) + + InitEmptyFunction_callContext(&p.Function_callContext) + p.parser = parser + p.CopyAll(ctx.(*Function_callContext)) + + return p +} + +func (s *RANKING_WINDOWED_FUNCContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RANKING_WINDOWED_FUNCContext) Ranking_windowed_function() IRanking_windowed_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRanking_windowed_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRanking_windowed_functionContext) +} + +func (s *RANKING_WINDOWED_FUNCContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRANKING_WINDOWED_FUNC(s) + } +} + +func (s *RANKING_WINDOWED_FUNCContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRANKING_WINDOWED_FUNC(s) + } +} + +func (s *RANKING_WINDOWED_FUNCContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRANKING_WINDOWED_FUNC(s) + + default: + return t.VisitChildren(s) + } +} + +type BUILT_IN_FUNCContext struct { + Function_callContext +} + +func NewBUILT_IN_FUNCContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BUILT_IN_FUNCContext { + var p = new(BUILT_IN_FUNCContext) + + InitEmptyFunction_callContext(&p.Function_callContext) + p.parser = parser + p.CopyAll(ctx.(*Function_callContext)) + + return p +} + +func (s *BUILT_IN_FUNCContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BUILT_IN_FUNCContext) Built_in_functions() IBuilt_in_functionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBuilt_in_functionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBuilt_in_functionsContext) +} + +func (s *BUILT_IN_FUNCContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBUILT_IN_FUNC(s) + } +} + +func (s *BUILT_IN_FUNCContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBUILT_IN_FUNC(s) + } +} + +func (s *BUILT_IN_FUNCContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBUILT_IN_FUNC(s) + + default: + return t.VisitChildren(s) + } +} + +type FREE_TEXTContext struct { + Function_callContext +} + +func NewFREE_TEXTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FREE_TEXTContext { + var p = new(FREE_TEXTContext) + + InitEmptyFunction_callContext(&p.Function_callContext) + p.parser = parser + p.CopyAll(ctx.(*Function_callContext)) + + return p +} + +func (s *FREE_TEXTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FREE_TEXTContext) Freetext_function() IFreetext_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFreetext_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFreetext_functionContext) +} + +func (s *FREE_TEXTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFREE_TEXT(s) + } +} + +func (s *FREE_TEXTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFREE_TEXT(s) + } +} + +func (s *FREE_TEXTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFREE_TEXT(s) + + default: + return t.VisitChildren(s) + } +} + +type ANALYTIC_WINDOWED_FUNCContext struct { + Function_callContext +} + +func NewANALYTIC_WINDOWED_FUNCContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ANALYTIC_WINDOWED_FUNCContext { + var p = new(ANALYTIC_WINDOWED_FUNCContext) + + InitEmptyFunction_callContext(&p.Function_callContext) + p.parser = parser + p.CopyAll(ctx.(*Function_callContext)) + + return p +} + +func (s *ANALYTIC_WINDOWED_FUNCContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ANALYTIC_WINDOWED_FUNCContext) Analytic_windowed_function() IAnalytic_windowed_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalytic_windowed_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnalytic_windowed_functionContext) +} + +func (s *ANALYTIC_WINDOWED_FUNCContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterANALYTIC_WINDOWED_FUNC(s) + } +} + +func (s *ANALYTIC_WINDOWED_FUNCContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitANALYTIC_WINDOWED_FUNC(s) + } +} + +func (s *ANALYTIC_WINDOWED_FUNCContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitANALYTIC_WINDOWED_FUNC(s) + + default: + return t.VisitChildren(s) + } +} + +type SCALAR_FUNCTIONContext struct { + Function_callContext +} + +func NewSCALAR_FUNCTIONContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SCALAR_FUNCTIONContext { + var p = new(SCALAR_FUNCTIONContext) + + InitEmptyFunction_callContext(&p.Function_callContext) + p.parser = parser + p.CopyAll(ctx.(*Function_callContext)) + + return p +} + +func (s *SCALAR_FUNCTIONContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SCALAR_FUNCTIONContext) Scalar_function_name() IScalar_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IScalar_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IScalar_function_nameContext) +} + +func (s *SCALAR_FUNCTIONContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SCALAR_FUNCTIONContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SCALAR_FUNCTIONContext) Expression_list_() IExpression_list_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_list_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_list_Context) +} + +func (s *SCALAR_FUNCTIONContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSCALAR_FUNCTION(s) + } +} + +func (s *SCALAR_FUNCTIONContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSCALAR_FUNCTION(s) + } +} + +func (s *SCALAR_FUNCTIONContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSCALAR_FUNCTION(s) + + default: + return t.VisitChildren(s) + } +} + +type PARTITION_FUNCContext struct { + Function_callContext +} + +func NewPARTITION_FUNCContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PARTITION_FUNCContext { + var p = new(PARTITION_FUNCContext) + + InitEmptyFunction_callContext(&p.Function_callContext) + p.parser = parser + p.CopyAll(ctx.(*Function_callContext)) + + return p +} + +func (s *PARTITION_FUNCContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PARTITION_FUNCContext) Partition_function() IPartition_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_functionContext) +} + +func (s *PARTITION_FUNCContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPARTITION_FUNC(s) + } +} + +func (s *PARTITION_FUNCContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPARTITION_FUNC(s) + } +} + +func (s *PARTITION_FUNCContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPARTITION_FUNC(s) + + default: + return t.VisitChildren(s) + } +} + +type AGGREGATE_WINDOWED_FUNCContext struct { + Function_callContext +} + +func NewAGGREGATE_WINDOWED_FUNCContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AGGREGATE_WINDOWED_FUNCContext { + var p = new(AGGREGATE_WINDOWED_FUNCContext) + + InitEmptyFunction_callContext(&p.Function_callContext) + p.parser = parser + p.CopyAll(ctx.(*Function_callContext)) + + return p +} + +func (s *AGGREGATE_WINDOWED_FUNCContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AGGREGATE_WINDOWED_FUNCContext) Aggregate_windowed_function() IAggregate_windowed_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_windowed_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_windowed_functionContext) +} + +func (s *AGGREGATE_WINDOWED_FUNCContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAGGREGATE_WINDOWED_FUNC(s) + } +} + +func (s *AGGREGATE_WINDOWED_FUNCContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAGGREGATE_WINDOWED_FUNC(s) + } +} + +func (s *AGGREGATE_WINDOWED_FUNCContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAGGREGATE_WINDOWED_FUNC(s) + + default: + return t.VisitChildren(s) + } +} + +type HIERARCHYID_METHODContext struct { + Function_callContext +} + +func NewHIERARCHYID_METHODContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HIERARCHYID_METHODContext { + var p = new(HIERARCHYID_METHODContext) + + InitEmptyFunction_callContext(&p.Function_callContext) + p.parser = parser + p.CopyAll(ctx.(*Function_callContext)) + + return p +} + +func (s *HIERARCHYID_METHODContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HIERARCHYID_METHODContext) Hierarchyid_static_method() IHierarchyid_static_methodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHierarchyid_static_methodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHierarchyid_static_methodContext) +} + +func (s *HIERARCHYID_METHODContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterHIERARCHYID_METHOD(s) + } +} + +func (s *HIERARCHYID_METHODContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitHIERARCHYID_METHOD(s) + } +} + +func (s *HIERARCHYID_METHODContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitHIERARCHYID_METHOD(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Function_call() (localctx IFunction_callContext) { + localctx = NewFunction_callContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1052, TSqlParserRULE_function_call) + var _la int + + p.SetState(12111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1641, p.GetParserRuleContext()) { + case 1: + localctx = NewRANKING_WINDOWED_FUNCContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12097) + p.Ranking_windowed_function() + } + + case 2: + localctx = NewAGGREGATE_WINDOWED_FUNCContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12098) + p.Aggregate_windowed_function() + } + + case 3: + localctx = NewANALYTIC_WINDOWED_FUNCContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12099) + p.Analytic_windowed_function() + } + + case 4: + localctx = NewBUILT_IN_FUNCContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12100) + p.Built_in_functions() + } + + case 5: + localctx = NewSCALAR_FUNCTIONContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(12101) + p.Scalar_function_name() + } + { + p.SetState(12102) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12104) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(12103) + p.Expression_list_() + } + + } + { + p.SetState(12106) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + localctx = NewFREE_TEXTContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(12108) + p.Freetext_function() + } + + case 7: + localctx = NewPARTITION_FUNCContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(12109) + p.Partition_function() + } + + case 8: + localctx = NewHIERARCHYID_METHODContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(12110) + p.Hierarchyid_static_method() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartition_functionContext is an interface to support dynamic dispatch. +type IPartition_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatabase returns the database rule contexts. + GetDatabase() IId_Context + + // GetFunc_name returns the func_name rule contexts. + GetFunc_name() IId_Context + + // SetDatabase sets the database rule contexts. + SetDatabase(IId_Context) + + // SetFunc_name sets the func_name rule contexts. + SetFunc_name(IId_Context) + + // Getter signatures + DOLLAR_PARTITION() antlr.TerminalNode + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Expression() IExpressionContext + RR_BRACKET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + + // IsPartition_functionContext differentiates from other interfaces. + IsPartition_functionContext() +} + +type Partition_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database IId_Context + func_name IId_Context +} + +func NewEmptyPartition_functionContext() *Partition_functionContext { + var p = new(Partition_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_partition_function + return p +} + +func InitEmptyPartition_functionContext(p *Partition_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_partition_function +} + +func (*Partition_functionContext) IsPartition_functionContext() {} + +func NewPartition_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_functionContext { + var p = new(Partition_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_partition_function + + return p +} + +func (s *Partition_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_functionContext) GetDatabase() IId_Context { return s.database } + +func (s *Partition_functionContext) GetFunc_name() IId_Context { return s.func_name } + +func (s *Partition_functionContext) SetDatabase(v IId_Context) { s.database = v } + +func (s *Partition_functionContext) SetFunc_name(v IId_Context) { s.func_name = v } + +func (s *Partition_functionContext) DOLLAR_PARTITION() antlr.TerminalNode { + return s.GetToken(TSqlParserDOLLAR_PARTITION, 0) +} + +func (s *Partition_functionContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Partition_functionContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Partition_functionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Partition_functionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Partition_functionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Partition_functionContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Partition_functionContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Partition_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPartition_function(s) + } +} + +func (s *Partition_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPartition_function(s) + } +} + +func (s *Partition_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPartition_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Partition_function() (localctx IPartition_functionContext) { + localctx = NewPartition_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1054, TSqlParserRULE_partition_function) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12116) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&22413823) != 0) { + { + p.SetState(12113) + + var _x = p.Id_() + + localctx.(*Partition_functionContext).database = _x + } + { + p.SetState(12114) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12118) + p.Match(TSqlParserDOLLAR_PARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12119) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12120) + + var _x = p.Id_() + + localctx.(*Partition_functionContext).func_name = _x + } + { + p.SetState(12121) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12122) + p.expression(0) + } + { + p.SetState(12123) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFreetext_functionContext is an interface to support dynamic dispatch. +type IFreetext_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + Table_name() ITable_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + CONTAINSTABLE() antlr.TerminalNode + FREETEXTTABLE() antlr.TerminalNode + AllFull_column_name() []IFull_column_nameContext + Full_column_name(i int) IFull_column_nameContext + STAR() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + SEMANTICSIMILARITYTABLE() antlr.TerminalNode + SEMANTICKEYPHRASETABLE() antlr.TerminalNode + SEMANTICSIMILARITYDETAILSTABLE() antlr.TerminalNode + + // IsFreetext_functionContext differentiates from other interfaces. + IsFreetext_functionContext() +} + +type Freetext_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFreetext_functionContext() *Freetext_functionContext { + var p = new(Freetext_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_freetext_function + return p +} + +func InitEmptyFreetext_functionContext(p *Freetext_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_freetext_function +} + +func (*Freetext_functionContext) IsFreetext_functionContext() {} + +func NewFreetext_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Freetext_functionContext { + var p = new(Freetext_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_freetext_function + + return p +} + +func (s *Freetext_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Freetext_functionContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Freetext_functionContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Freetext_functionContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Freetext_functionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Freetext_functionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Freetext_functionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Freetext_functionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Freetext_functionContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Freetext_functionContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Freetext_functionContext) CONTAINSTABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTAINSTABLE, 0) +} + +func (s *Freetext_functionContext) FREETEXTTABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserFREETEXTTABLE, 0) +} + +func (s *Freetext_functionContext) AllFull_column_name() []IFull_column_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFull_column_nameContext); ok { + len++ + } + } + + tst := make([]IFull_column_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFull_column_nameContext); ok { + tst[i] = t.(IFull_column_nameContext) + i++ + } + } + + return tst +} + +func (s *Freetext_functionContext) Full_column_name(i int) IFull_column_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *Freetext_functionContext) STAR() antlr.TerminalNode { + return s.GetToken(TSqlParserSTAR, 0) +} + +func (s *Freetext_functionContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserLANGUAGE, 0) +} + +func (s *Freetext_functionContext) SEMANTICSIMILARITYTABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMANTICSIMILARITYTABLE, 0) +} + +func (s *Freetext_functionContext) SEMANTICKEYPHRASETABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMANTICKEYPHRASETABLE, 0) +} + +func (s *Freetext_functionContext) SEMANTICSIMILARITYDETAILSTABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMANTICSIMILARITYDETAILSTABLE, 0) +} + +func (s *Freetext_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Freetext_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Freetext_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFreetext_function(s) + } +} + +func (s *Freetext_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFreetext_function(s) + } +} + +func (s *Freetext_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFreetext_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Freetext_function() (localctx IFreetext_functionContext) { + localctx = NewFreetext_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1056, TSqlParserRULE_freetext_function) + var _la int + + p.SetState(12193) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCONTAINSTABLE, TSqlParserFREETEXTTABLE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12125) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCONTAINSTABLE || _la == TSqlParserFREETEXTTABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12126) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12127) + p.Table_name() + } + { + p.SetState(12128) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserDOLLAR: + { + p.SetState(12129) + p.Full_column_name() + } + + case TSqlParserLR_BRACKET: + { + p.SetState(12130) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12131) + p.Full_column_name() + } + p.SetState(12136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(12132) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12133) + p.Full_column_name() + } + + p.SetState(12138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12139) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSTAR: + { + p.SetState(12141) + p.Match(TSqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(12144) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12145) + p.expression(0) + } + p.SetState(12149) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1645, p.GetParserRuleContext()) == 1 { + { + p.SetState(12146) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12147) + p.Match(TSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12148) + p.expression(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(12151) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12152) + p.expression(0) + } + + } + { + p.SetState(12155) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSEMANTICKEYPHRASETABLE, TSqlParserSEMANTICSIMILARITYTABLE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12157) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserSEMANTICKEYPHRASETABLE || _la == TSqlParserSEMANTICSIMILARITYTABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12158) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12159) + p.Table_name() + } + { + p.SetState(12160) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12174) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserDOLLAR: + { + p.SetState(12161) + p.Full_column_name() + } + + case TSqlParserLR_BRACKET: + { + p.SetState(12162) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12163) + p.Full_column_name() + } + p.SetState(12168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(12164) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12165) + p.Full_column_name() + } + + p.SetState(12170) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12171) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSTAR: + { + p.SetState(12173) + p.Match(TSqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(12176) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12177) + p.expression(0) + } + { + p.SetState(12178) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSEMANTICSIMILARITYDETAILSTABLE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12180) + p.Match(TSqlParserSEMANTICSIMILARITYDETAILSTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12181) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12182) + p.Table_name() + } + { + p.SetState(12183) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12184) + p.Full_column_name() + } + { + p.SetState(12185) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12186) + p.expression(0) + } + { + p.SetState(12187) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12188) + p.Full_column_name() + } + { + p.SetState(12189) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12190) + p.expression(0) + } + { + p.SetState(12191) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFreetext_predicateContext is an interface to support dynamic dispatch. +type IFreetext_predicateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONTAINS() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllFull_column_name() []IFull_column_nameContext + Full_column_name(i int) IFull_column_nameContext + STAR() antlr.TerminalNode + PROPERTY() antlr.TerminalNode + FREETEXT() antlr.TerminalNode + Table_name() ITable_nameContext + LANGUAGE() antlr.TerminalNode + + // IsFreetext_predicateContext differentiates from other interfaces. + IsFreetext_predicateContext() +} + +type Freetext_predicateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFreetext_predicateContext() *Freetext_predicateContext { + var p = new(Freetext_predicateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_freetext_predicate + return p +} + +func InitEmptyFreetext_predicateContext(p *Freetext_predicateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_freetext_predicate +} + +func (*Freetext_predicateContext) IsFreetext_predicateContext() {} + +func NewFreetext_predicateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Freetext_predicateContext { + var p = new(Freetext_predicateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_freetext_predicate + + return p +} + +func (s *Freetext_predicateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Freetext_predicateContext) CONTAINS() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTAINS, 0) +} + +func (s *Freetext_predicateContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Freetext_predicateContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Freetext_predicateContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Freetext_predicateContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Freetext_predicateContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Freetext_predicateContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Freetext_predicateContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Freetext_predicateContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Freetext_predicateContext) AllFull_column_name() []IFull_column_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFull_column_nameContext); ok { + len++ + } + } + + tst := make([]IFull_column_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFull_column_nameContext); ok { + tst[i] = t.(IFull_column_nameContext) + i++ + } + } + + return tst +} + +func (s *Freetext_predicateContext) Full_column_name(i int) IFull_column_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *Freetext_predicateContext) STAR() antlr.TerminalNode { + return s.GetToken(TSqlParserSTAR, 0) +} + +func (s *Freetext_predicateContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserPROPERTY, 0) +} + +func (s *Freetext_predicateContext) FREETEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserFREETEXT, 0) +} + +func (s *Freetext_predicateContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Freetext_predicateContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserLANGUAGE, 0) +} + +func (s *Freetext_predicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Freetext_predicateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Freetext_predicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFreetext_predicate(s) + } +} + +func (s *Freetext_predicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFreetext_predicate(s) + } +} + +func (s *Freetext_predicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFreetext_predicate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Freetext_predicate() (localctx IFreetext_predicateContext) { + localctx = NewFreetext_predicateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1058, TSqlParserRULE_freetext_predicate) + var _la int + + p.SetState(12254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCONTAINS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12195) + p.Match(TSqlParserCONTAINS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12196) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1651, p.GetParserRuleContext()) { + case 1: + { + p.SetState(12197) + p.Full_column_name() + } + + case 2: + { + p.SetState(12198) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12199) + p.Full_column_name() + } + p.SetState(12204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(12200) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12201) + p.Full_column_name() + } + + p.SetState(12206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12207) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(12209) + p.Match(TSqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(12210) + p.Match(TSqlParserPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12211) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12212) + p.Full_column_name() + } + { + p.SetState(12213) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12214) + p.expression(0) + } + { + p.SetState(12215) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(12219) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12220) + p.expression(0) + } + { + p.SetState(12221) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserFREETEXT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12223) + p.Match(TSqlParserFREETEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12224) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12228) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1652, p.GetParserRuleContext()) == 1 { + { + p.SetState(12225) + p.Table_name() + } + { + p.SetState(12226) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserDOLLAR: + { + p.SetState(12230) + p.Full_column_name() + } + + case TSqlParserLR_BRACKET: + { + p.SetState(12231) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12232) + p.Full_column_name() + } + p.SetState(12237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(12233) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12234) + p.Full_column_name() + } + + p.SetState(12239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12240) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSTAR: + { + p.SetState(12242) + p.Match(TSqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(12245) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12246) + p.expression(0) + } + p.SetState(12250) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(12247) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12248) + p.Match(TSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12249) + p.expression(0) + } + + } + { + p.SetState(12252) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_key_valueContext is an interface to support dynamic dispatch. +type IJson_key_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetJson_key_name returns the json_key_name rule contexts. + GetJson_key_name() IExpressionContext + + // GetValue_expression returns the value_expression rule contexts. + GetValue_expression() IExpressionContext + + // SetJson_key_name sets the json_key_name rule contexts. + SetJson_key_name(IExpressionContext) + + // SetValue_expression sets the value_expression rule contexts. + SetValue_expression(IExpressionContext) + + // Getter signatures + COLON() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + + // IsJson_key_valueContext differentiates from other interfaces. + IsJson_key_valueContext() +} + +type Json_key_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + json_key_name IExpressionContext + value_expression IExpressionContext +} + +func NewEmptyJson_key_valueContext() *Json_key_valueContext { + var p = new(Json_key_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_json_key_value + return p +} + +func InitEmptyJson_key_valueContext(p *Json_key_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_json_key_value +} + +func (*Json_key_valueContext) IsJson_key_valueContext() {} + +func NewJson_key_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_key_valueContext { + var p = new(Json_key_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_json_key_value + + return p +} + +func (s *Json_key_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_key_valueContext) GetJson_key_name() IExpressionContext { return s.json_key_name } + +func (s *Json_key_valueContext) GetValue_expression() IExpressionContext { return s.value_expression } + +func (s *Json_key_valueContext) SetJson_key_name(v IExpressionContext) { s.json_key_name = v } + +func (s *Json_key_valueContext) SetValue_expression(v IExpressionContext) { s.value_expression = v } + +func (s *Json_key_valueContext) COLON() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLON, 0) +} + +func (s *Json_key_valueContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Json_key_valueContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_key_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_key_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_key_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterJson_key_value(s) + } +} + +func (s *Json_key_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitJson_key_value(s) + } +} + +func (s *Json_key_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitJson_key_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Json_key_value() (localctx IJson_key_valueContext) { + localctx = NewJson_key_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1060, TSqlParserRULE_json_key_value) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12256) + + var _x = p.expression(0) + + localctx.(*Json_key_valueContext).json_key_name = _x + } + { + p.SetState(12257) + p.Match(TSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12258) + + var _x = p.expression(0) + + localctx.(*Json_key_valueContext).value_expression = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_null_clauseContext is an interface to support dynamic dispatch. +type IJson_null_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + ABSENT() antlr.TerminalNode + + // IsJson_null_clauseContext differentiates from other interfaces. + IsJson_null_clauseContext() +} + +type Json_null_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_null_clauseContext() *Json_null_clauseContext { + var p = new(Json_null_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_json_null_clause + return p +} + +func InitEmptyJson_null_clauseContext(p *Json_null_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_json_null_clause +} + +func (*Json_null_clauseContext) IsJson_null_clauseContext() {} + +func NewJson_null_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_null_clauseContext { + var p = new(Json_null_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_json_null_clause + + return p +} + +func (s *Json_null_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_null_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Json_null_clauseContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(TSqlParserNULL_) +} + +func (s *Json_null_clauseContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_, i) +} + +func (s *Json_null_clauseContext) ABSENT() antlr.TerminalNode { + return s.GetToken(TSqlParserABSENT, 0) +} + +func (s *Json_null_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_null_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_null_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterJson_null_clause(s) + } +} + +func (s *Json_null_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitJson_null_clause(s) + } +} + +func (s *Json_null_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitJson_null_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Json_null_clause() (localctx IJson_null_clauseContext) { + localctx = NewJson_null_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1062, TSqlParserRULE_json_null_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12260) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserABSENT || _la == TSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12261) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12262) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBuilt_in_functionsContext is an interface to support dynamic dispatch. +type IBuilt_in_functionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsBuilt_in_functionsContext differentiates from other interfaces. + IsBuilt_in_functionsContext() +} + +type Built_in_functionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBuilt_in_functionsContext() *Built_in_functionsContext { + var p = new(Built_in_functionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_built_in_functions + return p +} + +func InitEmptyBuilt_in_functionsContext(p *Built_in_functionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_built_in_functions +} + +func (*Built_in_functionsContext) IsBuilt_in_functionsContext() {} + +func NewBuilt_in_functionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Built_in_functionsContext { + var p = new(Built_in_functionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_built_in_functions + + return p +} + +func (s *Built_in_functionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Built_in_functionsContext) CopyAll(ctx *Built_in_functionsContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *Built_in_functionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Built_in_functionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type COL_NAMEContext struct { + Built_in_functionsContext + table_id IExpressionContext + column_id IExpressionContext +} + +func NewCOL_NAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *COL_NAMEContext { + var p = new(COL_NAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *COL_NAMEContext) GetTable_id() IExpressionContext { return s.table_id } + +func (s *COL_NAMEContext) GetColumn_id() IExpressionContext { return s.column_id } + +func (s *COL_NAMEContext) SetTable_id(v IExpressionContext) { s.table_id = v } + +func (s *COL_NAMEContext) SetColumn_id(v IExpressionContext) { s.column_id = v } + +func (s *COL_NAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *COL_NAMEContext) COL_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserCOL_NAME, 0) +} + +func (s *COL_NAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *COL_NAMEContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *COL_NAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *COL_NAMEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *COL_NAMEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *COL_NAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCOL_NAME(s) + } +} + +func (s *COL_NAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCOL_NAME(s) + } +} + +func (s *COL_NAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCOL_NAME(s) + + default: + return t.VisitChildren(s) + } +} + +type CHECKSUMContext struct { + Built_in_functionsContext + star antlr.Token +} + +func NewCHECKSUMContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CHECKSUMContext { + var p = new(CHECKSUMContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CHECKSUMContext) GetStar() antlr.Token { return s.star } + +func (s *CHECKSUMContext) SetStar(v antlr.Token) { s.star = v } + +func (s *CHECKSUMContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CHECKSUMContext) CHECKSUM() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKSUM, 0) +} + +func (s *CHECKSUMContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CHECKSUMContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CHECKSUMContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *CHECKSUMContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CHECKSUMContext) STAR() antlr.TerminalNode { + return s.GetToken(TSqlParserSTAR, 0) +} + +func (s *CHECKSUMContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *CHECKSUMContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *CHECKSUMContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCHECKSUM(s) + } +} + +func (s *CHECKSUMContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCHECKSUM(s) + } +} + +func (s *CHECKSUMContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCHECKSUM(s) + + default: + return t.VisitChildren(s) + } +} + +type DECOMPRESSContext struct { + Built_in_functionsContext + expr IExpressionContext +} + +func NewDECOMPRESSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DECOMPRESSContext { + var p = new(DECOMPRESSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DECOMPRESSContext) GetExpr() IExpressionContext { return s.expr } + +func (s *DECOMPRESSContext) SetExpr(v IExpressionContext) { s.expr = v } + +func (s *DECOMPRESSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DECOMPRESSContext) DECOMPRESS() antlr.TerminalNode { + return s.GetToken(TSqlParserDECOMPRESS, 0) +} + +func (s *DECOMPRESSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DECOMPRESSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DECOMPRESSContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DECOMPRESSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDECOMPRESS(s) + } +} + +func (s *DECOMPRESSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDECOMPRESS(s) + } +} + +func (s *DECOMPRESSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDECOMPRESS(s) + + default: + return t.VisitChildren(s) + } +} + +type CURRENT_TIMEZONE_IDContext struct { + Built_in_functionsContext +} + +func NewCURRENT_TIMEZONE_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CURRENT_TIMEZONE_IDContext { + var p = new(CURRENT_TIMEZONE_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CURRENT_TIMEZONE_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CURRENT_TIMEZONE_IDContext) CURRENT_TIMEZONE_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT_TIMEZONE_ID, 0) +} + +func (s *CURRENT_TIMEZONE_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CURRENT_TIMEZONE_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CURRENT_TIMEZONE_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCURRENT_TIMEZONE_ID(s) + } +} + +func (s *CURRENT_TIMEZONE_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCURRENT_TIMEZONE_ID(s) + } +} + +func (s *CURRENT_TIMEZONE_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCURRENT_TIMEZONE_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type MONTHContext struct { + Built_in_functionsContext + date IExpressionContext +} + +func NewMONTHContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MONTHContext { + var p = new(MONTHContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *MONTHContext) GetDate() IExpressionContext { return s.date } + +func (s *MONTHContext) SetDate(v IExpressionContext) { s.date = v } + +func (s *MONTHContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MONTHContext) MONTH() antlr.TerminalNode { + return s.GetToken(TSqlParserMONTH, 0) +} + +func (s *MONTHContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *MONTHContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *MONTHContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *MONTHContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMONTH(s) + } +} + +func (s *MONTHContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMONTH(s) + } +} + +func (s *MONTHContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMONTH(s) + + default: + return t.VisitChildren(s) + } +} + +type RANDContext struct { + Built_in_functionsContext + seed IExpressionContext +} + +func NewRANDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RANDContext { + var p = new(RANDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *RANDContext) GetSeed() IExpressionContext { return s.seed } + +func (s *RANDContext) SetSeed(v IExpressionContext) { s.seed = v } + +func (s *RANDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RANDContext) RAND() antlr.TerminalNode { + return s.GetToken(TSqlParserRAND, 0) +} + +func (s *RANDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *RANDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *RANDContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *RANDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRAND(s) + } +} + +func (s *RANDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRAND(s) + } +} + +func (s *RANDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRAND(s) + + default: + return t.VisitChildren(s) + } +} + +type FORMATContext struct { + Built_in_functionsContext + value IExpressionContext + format IExpressionContext + culture IExpressionContext +} + +func NewFORMATContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FORMATContext { + var p = new(FORMATContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FORMATContext) GetValue() IExpressionContext { return s.value } + +func (s *FORMATContext) GetFormat() IExpressionContext { return s.format } + +func (s *FORMATContext) GetCulture() IExpressionContext { return s.culture } + +func (s *FORMATContext) SetValue(v IExpressionContext) { s.value = v } + +func (s *FORMATContext) SetFormat(v IExpressionContext) { s.format = v } + +func (s *FORMATContext) SetCulture(v IExpressionContext) { s.culture = v } + +func (s *FORMATContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FORMATContext) FORMAT() antlr.TerminalNode { + return s.GetToken(TSqlParserFORMAT, 0) +} + +func (s *FORMATContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FORMATContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *FORMATContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *FORMATContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FORMATContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *FORMATContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FORMATContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFORMAT(s) + } +} + +func (s *FORMATContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFORMAT(s) + } +} + +func (s *FORMATContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFORMAT(s) + + default: + return t.VisitChildren(s) + } +} + +type TRIMContext struct { + Built_in_functionsContext + characters IExpressionContext + string_ IExpressionContext +} + +func NewTRIMContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TRIMContext { + var p = new(TRIMContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *TRIMContext) GetCharacters() IExpressionContext { return s.characters } + +func (s *TRIMContext) GetString_() IExpressionContext { return s.string_ } + +func (s *TRIMContext) SetCharacters(v IExpressionContext) { s.characters = v } + +func (s *TRIMContext) SetString_(v IExpressionContext) { s.string_ = v } + +func (s *TRIMContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TRIMContext) TRIM() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIM, 0) +} + +func (s *TRIMContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *TRIMContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *TRIMContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *TRIMContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *TRIMContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *TRIMContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTRIM(s) + } +} + +func (s *TRIMContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTRIM(s) + } +} + +func (s *TRIMContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTRIM(s) + + default: + return t.VisitChildren(s) + } +} + +type LEASTContext struct { + Built_in_functionsContext +} + +func NewLEASTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LEASTContext { + var p = new(LEASTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *LEASTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LEASTContext) LEAST() antlr.TerminalNode { + return s.GetToken(TSqlParserLEAST, 0) +} + +func (s *LEASTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *LEASTContext) Expression_list_() IExpression_list_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_list_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_list_Context) +} + +func (s *LEASTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *LEASTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterLEAST(s) + } +} + +func (s *LEASTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitLEAST(s) + } +} + +func (s *LEASTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitLEAST(s) + + default: + return t.VisitChildren(s) + } +} + +type APP_NAMEContext struct { + Built_in_functionsContext +} + +func NewAPP_NAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *APP_NAMEContext { + var p = new(APP_NAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *APP_NAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *APP_NAMEContext) APP_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserAPP_NAME, 0) +} + +func (s *APP_NAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *APP_NAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *APP_NAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAPP_NAME(s) + } +} + +func (s *APP_NAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAPP_NAME(s) + } +} + +func (s *APP_NAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAPP_NAME(s) + + default: + return t.VisitChildren(s) + } +} + +type USER_IDContext struct { + Built_in_functionsContext + user IExpressionContext +} + +func NewUSER_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *USER_IDContext { + var p = new(USER_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *USER_IDContext) GetUser() IExpressionContext { return s.user } + +func (s *USER_IDContext) SetUser(v IExpressionContext) { s.user = v } + +func (s *USER_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *USER_IDContext) USER_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER_ID, 0) +} + +func (s *USER_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *USER_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *USER_IDContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *USER_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUSER_ID(s) + } +} + +func (s *USER_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUSER_ID(s) + } +} + +func (s *USER_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUSER_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type FILE_NAMEContext struct { + Built_in_functionsContext + file_id IExpressionContext +} + +func NewFILE_NAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FILE_NAMEContext { + var p = new(FILE_NAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FILE_NAMEContext) GetFile_id() IExpressionContext { return s.file_id } + +func (s *FILE_NAMEContext) SetFile_id(v IExpressionContext) { s.file_id = v } + +func (s *FILE_NAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FILE_NAMEContext) FILE_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE_NAME, 0) +} + +func (s *FILE_NAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FILE_NAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FILE_NAMEContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FILE_NAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFILE_NAME(s) + } +} + +func (s *FILE_NAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFILE_NAME(s) + } +} + +func (s *FILE_NAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFILE_NAME(s) + + default: + return t.VisitChildren(s) + } +} + +type SESSION_CONTEXTContext struct { + Built_in_functionsContext + key antlr.Token +} + +func NewSESSION_CONTEXTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SESSION_CONTEXTContext { + var p = new(SESSION_CONTEXTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SESSION_CONTEXTContext) GetKey() antlr.Token { return s.key } + +func (s *SESSION_CONTEXTContext) SetKey(v antlr.Token) { s.key = v } + +func (s *SESSION_CONTEXTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SESSION_CONTEXTContext) SESSION_CONTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserSESSION_CONTEXT, 0) +} + +func (s *SESSION_CONTEXTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SESSION_CONTEXTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SESSION_CONTEXTContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *SESSION_CONTEXTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSESSION_CONTEXT(s) + } +} + +func (s *SESSION_CONTEXTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSESSION_CONTEXT(s) + } +} + +func (s *SESSION_CONTEXTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSESSION_CONTEXT(s) + + default: + return t.VisitChildren(s) + } +} + +type STRContext struct { + Built_in_functionsContext + float_expression IExpressionContext + length_expression IExpressionContext + decimal IExpressionContext +} + +func NewSTRContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *STRContext { + var p = new(STRContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *STRContext) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *STRContext) GetLength_expression() IExpressionContext { return s.length_expression } + +func (s *STRContext) GetDecimal() IExpressionContext { return s.decimal } + +func (s *STRContext) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *STRContext) SetLength_expression(v IExpressionContext) { s.length_expression = v } + +func (s *STRContext) SetDecimal(v IExpressionContext) { s.decimal = v } + +func (s *STRContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *STRContext) STR() antlr.TerminalNode { + return s.GetToken(TSqlParserSTR, 0) +} + +func (s *STRContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *STRContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *STRContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *STRContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *STRContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *STRContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *STRContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSTR(s) + } +} + +func (s *STRContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSTR(s) + } +} + +func (s *STRContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSTR(s) + + default: + return t.VisitChildren(s) + } +} + +type CONVERTContext struct { + Built_in_functionsContext + convert_data_type IData_typeContext + convert_expression IExpressionContext + style IExpressionContext +} + +func NewCONVERTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CONVERTContext { + var p = new(CONVERTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CONVERTContext) GetConvert_data_type() IData_typeContext { return s.convert_data_type } + +func (s *CONVERTContext) GetConvert_expression() IExpressionContext { return s.convert_expression } + +func (s *CONVERTContext) GetStyle() IExpressionContext { return s.style } + +func (s *CONVERTContext) SetConvert_data_type(v IData_typeContext) { s.convert_data_type = v } + +func (s *CONVERTContext) SetConvert_expression(v IExpressionContext) { s.convert_expression = v } + +func (s *CONVERTContext) SetStyle(v IExpressionContext) { s.style = v } + +func (s *CONVERTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CONVERTContext) CONVERT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONVERT, 0) +} + +func (s *CONVERTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CONVERTContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *CONVERTContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *CONVERTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CONVERTContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *CONVERTContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *CONVERTContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CONVERTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCONVERT(s) + } +} + +func (s *CONVERTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCONVERT(s) + } +} + +func (s *CONVERTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCONVERT(s) + + default: + return t.VisitChildren(s) + } +} + +type XML_DATA_TYPE_FUNCContext struct { + Built_in_functionsContext +} + +func NewXML_DATA_TYPE_FUNCContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *XML_DATA_TYPE_FUNCContext { + var p = new(XML_DATA_TYPE_FUNCContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *XML_DATA_TYPE_FUNCContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XML_DATA_TYPE_FUNCContext) Xml_data_type_methods() IXml_data_type_methodsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_data_type_methodsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_data_type_methodsContext) +} + +func (s *XML_DATA_TYPE_FUNCContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterXML_DATA_TYPE_FUNC(s) + } +} + +func (s *XML_DATA_TYPE_FUNCContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitXML_DATA_TYPE_FUNC(s) + } +} + +func (s *XML_DATA_TYPE_FUNCContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitXML_DATA_TYPE_FUNC(s) + + default: + return t.VisitChildren(s) + } +} + +type LOG10Context struct { + Built_in_functionsContext + float_expression IExpressionContext +} + +func NewLOG10Context(parser antlr.Parser, ctx antlr.ParserRuleContext) *LOG10Context { + var p = new(LOG10Context) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *LOG10Context) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *LOG10Context) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *LOG10Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LOG10Context) LOG10() antlr.TerminalNode { + return s.GetToken(TSqlParserLOG10, 0) +} + +func (s *LOG10Context) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *LOG10Context) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *LOG10Context) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *LOG10Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterLOG10(s) + } +} + +func (s *LOG10Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitLOG10(s) + } +} + +func (s *LOG10Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitLOG10(s) + + default: + return t.VisitChildren(s) + } +} + +type FLOORContext struct { + Built_in_functionsContext + numeric_expression IExpressionContext +} + +func NewFLOORContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FLOORContext { + var p = new(FLOORContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FLOORContext) GetNumeric_expression() IExpressionContext { return s.numeric_expression } + +func (s *FLOORContext) SetNumeric_expression(v IExpressionContext) { s.numeric_expression = v } + +func (s *FLOORContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FLOORContext) FLOOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFLOOR, 0) +} + +func (s *FLOORContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FLOORContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FLOORContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FLOORContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFLOOR(s) + } +} + +func (s *FLOORContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFLOOR(s) + } +} + +func (s *FLOORContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFLOOR(s) + + default: + return t.VisitChildren(s) + } +} + +type YEARContext struct { + Built_in_functionsContext + date IExpressionContext +} + +func NewYEARContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *YEARContext { + var p = new(YEARContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *YEARContext) GetDate() IExpressionContext { return s.date } + +func (s *YEARContext) SetDate(v IExpressionContext) { s.date = v } + +func (s *YEARContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *YEARContext) YEAR() antlr.TerminalNode { + return s.GetToken(TSqlParserYEAR, 0) +} + +func (s *YEARContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *YEARContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *YEARContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *YEARContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterYEAR(s) + } +} + +func (s *YEARContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitYEAR(s) + } +} + +func (s *YEARContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitYEAR(s) + + default: + return t.VisitChildren(s) + } +} + +type PARSEContext struct { + Built_in_functionsContext + str IExpressionContext + culture IExpressionContext +} + +func NewPARSEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PARSEContext { + var p = new(PARSEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *PARSEContext) GetStr() IExpressionContext { return s.str } + +func (s *PARSEContext) GetCulture() IExpressionContext { return s.culture } + +func (s *PARSEContext) SetStr(v IExpressionContext) { s.str = v } + +func (s *PARSEContext) SetCulture(v IExpressionContext) { s.culture = v } + +func (s *PARSEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PARSEContext) PARSE() antlr.TerminalNode { + return s.GetToken(TSqlParserPARSE, 0) +} + +func (s *PARSEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *PARSEContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *PARSEContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *PARSEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *PARSEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *PARSEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PARSEContext) USING() antlr.TerminalNode { + return s.GetToken(TSqlParserUSING, 0) +} + +func (s *PARSEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPARSE(s) + } +} + +func (s *PARSEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPARSE(s) + } +} + +func (s *PARSEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPARSE(s) + + default: + return t.VisitChildren(s) + } +} + +type ORIGINAL_LOGINContext struct { + Built_in_functionsContext +} + +func NewORIGINAL_LOGINContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ORIGINAL_LOGINContext { + var p = new(ORIGINAL_LOGINContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ORIGINAL_LOGINContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ORIGINAL_LOGINContext) ORIGINAL_LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserORIGINAL_LOGIN, 0) +} + +func (s *ORIGINAL_LOGINContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ORIGINAL_LOGINContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ORIGINAL_LOGINContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterORIGINAL_LOGIN(s) + } +} + +func (s *ORIGINAL_LOGINContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitORIGINAL_LOGIN(s) + } +} + +func (s *ORIGINAL_LOGINContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitORIGINAL_LOGIN(s) + + default: + return t.VisitChildren(s) + } +} + +type MATH_SIGNContext struct { + Built_in_functionsContext + numeric_expression IExpressionContext +} + +func NewMATH_SIGNContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MATH_SIGNContext { + var p = new(MATH_SIGNContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *MATH_SIGNContext) GetNumeric_expression() IExpressionContext { return s.numeric_expression } + +func (s *MATH_SIGNContext) SetNumeric_expression(v IExpressionContext) { s.numeric_expression = v } + +func (s *MATH_SIGNContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MATH_SIGNContext) SIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserSIGN, 0) +} + +func (s *MATH_SIGNContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *MATH_SIGNContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *MATH_SIGNContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *MATH_SIGNContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMATH_SIGN(s) + } +} + +func (s *MATH_SIGNContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMATH_SIGN(s) + } +} + +func (s *MATH_SIGNContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMATH_SIGN(s) + + default: + return t.VisitChildren(s) + } +} + +type TIMEFROMPARTSContext struct { + Built_in_functionsContext + hour IExpressionContext + minute IExpressionContext + seconds IExpressionContext + fractions IExpressionContext + precision antlr.Token +} + +func NewTIMEFROMPARTSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TIMEFROMPARTSContext { + var p = new(TIMEFROMPARTSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *TIMEFROMPARTSContext) GetPrecision() antlr.Token { return s.precision } + +func (s *TIMEFROMPARTSContext) SetPrecision(v antlr.Token) { s.precision = v } + +func (s *TIMEFROMPARTSContext) GetHour() IExpressionContext { return s.hour } + +func (s *TIMEFROMPARTSContext) GetMinute() IExpressionContext { return s.minute } + +func (s *TIMEFROMPARTSContext) GetSeconds() IExpressionContext { return s.seconds } + +func (s *TIMEFROMPARTSContext) GetFractions() IExpressionContext { return s.fractions } + +func (s *TIMEFROMPARTSContext) SetHour(v IExpressionContext) { s.hour = v } + +func (s *TIMEFROMPARTSContext) SetMinute(v IExpressionContext) { s.minute = v } + +func (s *TIMEFROMPARTSContext) SetSeconds(v IExpressionContext) { s.seconds = v } + +func (s *TIMEFROMPARTSContext) SetFractions(v IExpressionContext) { s.fractions = v } + +func (s *TIMEFROMPARTSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TIMEFROMPARTSContext) TIMEFROMPARTS() antlr.TerminalNode { + return s.GetToken(TSqlParserTIMEFROMPARTS, 0) +} + +func (s *TIMEFROMPARTSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *TIMEFROMPARTSContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *TIMEFROMPARTSContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *TIMEFROMPARTSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *TIMEFROMPARTSContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *TIMEFROMPARTSContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *TIMEFROMPARTSContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *TIMEFROMPARTSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTIMEFROMPARTS(s) + } +} + +func (s *TIMEFROMPARTSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTIMEFROMPARTS(s) + } +} + +func (s *TIMEFROMPARTSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTIMEFROMPARTS(s) + + default: + return t.VisitChildren(s) + } +} + +type LEFTContext struct { + Built_in_functionsContext + character_expression IExpressionContext + integer_expression IExpressionContext +} + +func NewLEFTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LEFTContext { + var p = new(LEFTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *LEFTContext) GetCharacter_expression() IExpressionContext { return s.character_expression } + +func (s *LEFTContext) GetInteger_expression() IExpressionContext { return s.integer_expression } + +func (s *LEFTContext) SetCharacter_expression(v IExpressionContext) { s.character_expression = v } + +func (s *LEFTContext) SetInteger_expression(v IExpressionContext) { s.integer_expression = v } + +func (s *LEFTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LEFTContext) LEFT() antlr.TerminalNode { + return s.GetToken(TSqlParserLEFT, 0) +} + +func (s *LEFTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *LEFTContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *LEFTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *LEFTContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *LEFTContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *LEFTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterLEFT(s) + } +} + +func (s *LEFTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitLEFT(s) + } +} + +func (s *LEFTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitLEFT(s) + + default: + return t.VisitChildren(s) + } +} + +type GET_FILESTREAM_TRANSACTION_CONTEXTContext struct { + Built_in_functionsContext +} + +func NewGET_FILESTREAM_TRANSACTION_CONTEXTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GET_FILESTREAM_TRANSACTION_CONTEXTContext { + var p = new(GET_FILESTREAM_TRANSACTION_CONTEXTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *GET_FILESTREAM_TRANSACTION_CONTEXTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GET_FILESTREAM_TRANSACTION_CONTEXTContext) GET_FILESTREAM_TRANSACTION_CONTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, 0) +} + +func (s *GET_FILESTREAM_TRANSACTION_CONTEXTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *GET_FILESTREAM_TRANSACTION_CONTEXTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *GET_FILESTREAM_TRANSACTION_CONTEXTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterGET_FILESTREAM_TRANSACTION_CONTEXT(s) + } +} + +func (s *GET_FILESTREAM_TRANSACTION_CONTEXTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitGET_FILESTREAM_TRANSACTION_CONTEXT(s) + } +} + +func (s *GET_FILESTREAM_TRANSACTION_CONTEXTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitGET_FILESTREAM_TRANSACTION_CONTEXT(s) + + default: + return t.VisitChildren(s) + } +} + +type FILEPROPERTYContext struct { + Built_in_functionsContext + file_name IExpressionContext + property IExpressionContext +} + +func NewFILEPROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FILEPROPERTYContext { + var p = new(FILEPROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FILEPROPERTYContext) GetFile_name() IExpressionContext { return s.file_name } + +func (s *FILEPROPERTYContext) GetProperty() IExpressionContext { return s.property } + +func (s *FILEPROPERTYContext) SetFile_name(v IExpressionContext) { s.file_name = v } + +func (s *FILEPROPERTYContext) SetProperty(v IExpressionContext) { s.property = v } + +func (s *FILEPROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FILEPROPERTYContext) FILEPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEPROPERTY, 0) +} + +func (s *FILEPROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FILEPROPERTYContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *FILEPROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FILEPROPERTYContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *FILEPROPERTYContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FILEPROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFILEPROPERTY(s) + } +} + +func (s *FILEPROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFILEPROPERTY(s) + } +} + +func (s *FILEPROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFILEPROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type IDENT_SEEDContext struct { + Built_in_functionsContext + table_or_view IExpressionContext +} + +func NewIDENT_SEEDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IDENT_SEEDContext { + var p = new(IDENT_SEEDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *IDENT_SEEDContext) GetTable_or_view() IExpressionContext { return s.table_or_view } + +func (s *IDENT_SEEDContext) SetTable_or_view(v IExpressionContext) { s.table_or_view = v } + +func (s *IDENT_SEEDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IDENT_SEEDContext) IDENT_SEED() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENT_SEED, 0) +} + +func (s *IDENT_SEEDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *IDENT_SEEDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *IDENT_SEEDContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IDENT_SEEDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterIDENT_SEED(s) + } +} + +func (s *IDENT_SEEDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitIDENT_SEED(s) + } +} + +func (s *IDENT_SEEDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitIDENT_SEED(s) + + default: + return t.VisitChildren(s) + } +} + +type IDENTITYContext struct { + Built_in_functionsContext + datatype IData_typeContext + seed antlr.Token + increment antlr.Token +} + +func NewIDENTITYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IDENTITYContext { + var p = new(IDENTITYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *IDENTITYContext) GetSeed() antlr.Token { return s.seed } + +func (s *IDENTITYContext) GetIncrement() antlr.Token { return s.increment } + +func (s *IDENTITYContext) SetSeed(v antlr.Token) { s.seed = v } + +func (s *IDENTITYContext) SetIncrement(v antlr.Token) { s.increment = v } + +func (s *IDENTITYContext) GetDatatype() IData_typeContext { return s.datatype } + +func (s *IDENTITYContext) SetDatatype(v IData_typeContext) { s.datatype = v } + +func (s *IDENTITYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IDENTITYContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENTITY, 0) +} + +func (s *IDENTITYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *IDENTITYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *IDENTITYContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *IDENTITYContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *IDENTITYContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *IDENTITYContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *IDENTITYContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *IDENTITYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterIDENTITY(s) + } +} + +func (s *IDENTITYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitIDENTITY(s) + } +} + +func (s *IDENTITYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitIDENTITY(s) + + default: + return t.VisitChildren(s) + } +} + +type CURRENT_TRANSACTION_IDContext struct { + Built_in_functionsContext +} + +func NewCURRENT_TRANSACTION_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CURRENT_TRANSACTION_IDContext { + var p = new(CURRENT_TRANSACTION_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CURRENT_TRANSACTION_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CURRENT_TRANSACTION_IDContext) CURRENT_TRANSACTION_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT_TRANSACTION_ID, 0) +} + +func (s *CURRENT_TRANSACTION_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CURRENT_TRANSACTION_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CURRENT_TRANSACTION_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCURRENT_TRANSACTION_ID(s) + } +} + +func (s *CURRENT_TRANSACTION_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCURRENT_TRANSACTION_ID(s) + } +} + +func (s *CURRENT_TRANSACTION_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCURRENT_TRANSACTION_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type LTRIMContext struct { + Built_in_functionsContext + character_expression IExpressionContext +} + +func NewLTRIMContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LTRIMContext { + var p = new(LTRIMContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *LTRIMContext) GetCharacter_expression() IExpressionContext { return s.character_expression } + +func (s *LTRIMContext) SetCharacter_expression(v IExpressionContext) { s.character_expression = v } + +func (s *LTRIMContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LTRIMContext) LTRIM() antlr.TerminalNode { + return s.GetToken(TSqlParserLTRIM, 0) +} + +func (s *LTRIMContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *LTRIMContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *LTRIMContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *LTRIMContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterLTRIM(s) + } +} + +func (s *LTRIMContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitLTRIM(s) + } +} + +func (s *LTRIMContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitLTRIM(s) + + default: + return t.VisitChildren(s) + } +} + +type ROWCOUNT_BIGContext struct { + Built_in_functionsContext +} + +func NewROWCOUNT_BIGContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ROWCOUNT_BIGContext { + var p = new(ROWCOUNT_BIGContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ROWCOUNT_BIGContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ROWCOUNT_BIGContext) ROWCOUNT_BIG() antlr.TerminalNode { + return s.GetToken(TSqlParserROWCOUNT_BIG, 0) +} + +func (s *ROWCOUNT_BIGContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ROWCOUNT_BIGContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ROWCOUNT_BIGContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterROWCOUNT_BIG(s) + } +} + +func (s *ROWCOUNT_BIGContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitROWCOUNT_BIG(s) + } +} + +func (s *ROWCOUNT_BIGContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitROWCOUNT_BIG(s) + + default: + return t.VisitChildren(s) + } +} + +type CERTENCODEDContext struct { + Built_in_functionsContext + certid IExpressionContext +} + +func NewCERTENCODEDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CERTENCODEDContext { + var p = new(CERTENCODEDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CERTENCODEDContext) GetCertid() IExpressionContext { return s.certid } + +func (s *CERTENCODEDContext) SetCertid(v IExpressionContext) { s.certid = v } + +func (s *CERTENCODEDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CERTENCODEDContext) CERTENCODED() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTENCODED, 0) +} + +func (s *CERTENCODEDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CERTENCODEDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CERTENCODEDContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CERTENCODEDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCERTENCODED(s) + } +} + +func (s *CERTENCODEDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCERTENCODED(s) + } +} + +func (s *CERTENCODEDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCERTENCODED(s) + + default: + return t.VisitChildren(s) + } +} + +type JSON_VALUEContext struct { + Built_in_functionsContext + expr IExpressionContext + path IExpressionContext +} + +func NewJSON_VALUEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSON_VALUEContext { + var p = new(JSON_VALUEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *JSON_VALUEContext) GetExpr() IExpressionContext { return s.expr } + +func (s *JSON_VALUEContext) GetPath() IExpressionContext { return s.path } + +func (s *JSON_VALUEContext) SetExpr(v IExpressionContext) { s.expr = v } + +func (s *JSON_VALUEContext) SetPath(v IExpressionContext) { s.path = v } + +func (s *JSON_VALUEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JSON_VALUEContext) JSON_VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON_VALUE, 0) +} + +func (s *JSON_VALUEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *JSON_VALUEContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *JSON_VALUEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *JSON_VALUEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *JSON_VALUEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *JSON_VALUEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterJSON_VALUE(s) + } +} + +func (s *JSON_VALUEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitJSON_VALUE(s) + } +} + +func (s *JSON_VALUEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitJSON_VALUE(s) + + default: + return t.VisitChildren(s) + } +} + +type SYSDATETIMEContext struct { + Built_in_functionsContext +} + +func NewSYSDATETIMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SYSDATETIMEContext { + var p = new(SYSDATETIMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SYSDATETIMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SYSDATETIMEContext) SYSDATETIME() antlr.TerminalNode { + return s.GetToken(TSqlParserSYSDATETIME, 0) +} + +func (s *SYSDATETIMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SYSDATETIMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SYSDATETIMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSYSDATETIME(s) + } +} + +func (s *SYSDATETIMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSYSDATETIME(s) + } +} + +func (s *SYSDATETIMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSYSDATETIME(s) + + default: + return t.VisitChildren(s) + } +} + +type CERTPRIVATEKEYContext struct { + Built_in_functionsContext + certid IExpressionContext + encryption_password IExpressionContext + decryption_pasword IExpressionContext +} + +func NewCERTPRIVATEKEYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CERTPRIVATEKEYContext { + var p = new(CERTPRIVATEKEYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CERTPRIVATEKEYContext) GetCertid() IExpressionContext { return s.certid } + +func (s *CERTPRIVATEKEYContext) GetEncryption_password() IExpressionContext { + return s.encryption_password +} + +func (s *CERTPRIVATEKEYContext) GetDecryption_pasword() IExpressionContext { + return s.decryption_pasword +} + +func (s *CERTPRIVATEKEYContext) SetCertid(v IExpressionContext) { s.certid = v } + +func (s *CERTPRIVATEKEYContext) SetEncryption_password(v IExpressionContext) { + s.encryption_password = v +} + +func (s *CERTPRIVATEKEYContext) SetDecryption_pasword(v IExpressionContext) { s.decryption_pasword = v } + +func (s *CERTPRIVATEKEYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CERTPRIVATEKEYContext) CERTPRIVATEKEY() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTPRIVATEKEY, 0) +} + +func (s *CERTPRIVATEKEYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CERTPRIVATEKEYContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *CERTPRIVATEKEYContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *CERTPRIVATEKEYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CERTPRIVATEKEYContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *CERTPRIVATEKEYContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CERTPRIVATEKEYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCERTPRIVATEKEY(s) + } +} + +func (s *CERTPRIVATEKEYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCERTPRIVATEKEY(s) + } +} + +func (s *CERTPRIVATEKEYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCERTPRIVATEKEY(s) + + default: + return t.VisitChildren(s) + } +} + +type SPACEContext struct { + Built_in_functionsContext + integer_expression IExpressionContext +} + +func NewSPACEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SPACEContext { + var p = new(SPACEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SPACEContext) GetInteger_expression() IExpressionContext { return s.integer_expression } + +func (s *SPACEContext) SetInteger_expression(v IExpressionContext) { s.integer_expression = v } + +func (s *SPACEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SPACEContext) SPACE_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserSPACE_KEYWORD, 0) +} + +func (s *SPACEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SPACEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SPACEContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SPACEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSPACE(s) + } +} + +func (s *SPACEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSPACE(s) + } +} + +func (s *SPACEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSPACE(s) + + default: + return t.VisitChildren(s) + } +} + +type UPPERContext struct { + Built_in_functionsContext + character_expression IExpressionContext +} + +func NewUPPERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UPPERContext { + var p = new(UPPERContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *UPPERContext) GetCharacter_expression() IExpressionContext { return s.character_expression } + +func (s *UPPERContext) SetCharacter_expression(v IExpressionContext) { s.character_expression = v } + +func (s *UPPERContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UPPERContext) UPPER() antlr.TerminalNode { + return s.GetToken(TSqlParserUPPER, 0) +} + +func (s *UPPERContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *UPPERContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *UPPERContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *UPPERContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUPPER(s) + } +} + +func (s *UPPERContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUPPER(s) + } +} + +func (s *UPPERContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUPPER(s) + + default: + return t.VisitChildren(s) + } +} + +type ABSContext struct { + Built_in_functionsContext + numeric_expression IExpressionContext +} + +func NewABSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ABSContext { + var p = new(ABSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ABSContext) GetNumeric_expression() IExpressionContext { return s.numeric_expression } + +func (s *ABSContext) SetNumeric_expression(v IExpressionContext) { s.numeric_expression = v } + +func (s *ABSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ABSContext) ABS() antlr.TerminalNode { + return s.GetToken(TSqlParserABS, 0) +} + +func (s *ABSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ABSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ABSContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ABSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterABS(s) + } +} + +func (s *ABSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitABS(s) + } +} + +func (s *ABSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitABS(s) + + default: + return t.VisitChildren(s) + } +} + +type ISJSONContext struct { + Built_in_functionsContext + json_expr IExpressionContext + json_type_constraint IExpressionContext +} + +func NewISJSONContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ISJSONContext { + var p = new(ISJSONContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ISJSONContext) GetJson_expr() IExpressionContext { return s.json_expr } + +func (s *ISJSONContext) GetJson_type_constraint() IExpressionContext { return s.json_type_constraint } + +func (s *ISJSONContext) SetJson_expr(v IExpressionContext) { s.json_expr = v } + +func (s *ISJSONContext) SetJson_type_constraint(v IExpressionContext) { s.json_type_constraint = v } + +func (s *ISJSONContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ISJSONContext) ISJSON() antlr.TerminalNode { + return s.GetToken(TSqlParserISJSON, 0) +} + +func (s *ISJSONContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ISJSONContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ISJSONContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *ISJSONContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ISJSONContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *ISJSONContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterISJSON(s) + } +} + +func (s *ISJSONContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitISJSON(s) + } +} + +func (s *ISJSONContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitISJSON(s) + + default: + return t.VisitChildren(s) + } +} + +type HAS_PERMS_BY_NAMEContext struct { + Built_in_functionsContext + securable IExpressionContext + securable_class IExpressionContext + permission IExpressionContext + sub_securable IExpressionContext + sub_securable_class IExpressionContext +} + +func NewHAS_PERMS_BY_NAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HAS_PERMS_BY_NAMEContext { + var p = new(HAS_PERMS_BY_NAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *HAS_PERMS_BY_NAMEContext) GetSecurable() IExpressionContext { return s.securable } + +func (s *HAS_PERMS_BY_NAMEContext) GetSecurable_class() IExpressionContext { return s.securable_class } + +func (s *HAS_PERMS_BY_NAMEContext) GetPermission() IExpressionContext { return s.permission } + +func (s *HAS_PERMS_BY_NAMEContext) GetSub_securable() IExpressionContext { return s.sub_securable } + +func (s *HAS_PERMS_BY_NAMEContext) GetSub_securable_class() IExpressionContext { + return s.sub_securable_class +} + +func (s *HAS_PERMS_BY_NAMEContext) SetSecurable(v IExpressionContext) { s.securable = v } + +func (s *HAS_PERMS_BY_NAMEContext) SetSecurable_class(v IExpressionContext) { s.securable_class = v } + +func (s *HAS_PERMS_BY_NAMEContext) SetPermission(v IExpressionContext) { s.permission = v } + +func (s *HAS_PERMS_BY_NAMEContext) SetSub_securable(v IExpressionContext) { s.sub_securable = v } + +func (s *HAS_PERMS_BY_NAMEContext) SetSub_securable_class(v IExpressionContext) { + s.sub_securable_class = v +} + +func (s *HAS_PERMS_BY_NAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HAS_PERMS_BY_NAMEContext) HAS_PERMS_BY_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserHAS_PERMS_BY_NAME, 0) +} + +func (s *HAS_PERMS_BY_NAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *HAS_PERMS_BY_NAMEContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *HAS_PERMS_BY_NAMEContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *HAS_PERMS_BY_NAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *HAS_PERMS_BY_NAMEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *HAS_PERMS_BY_NAMEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *HAS_PERMS_BY_NAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterHAS_PERMS_BY_NAME(s) + } +} + +func (s *HAS_PERMS_BY_NAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitHAS_PERMS_BY_NAME(s) + } +} + +func (s *HAS_PERMS_BY_NAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitHAS_PERMS_BY_NAME(s) + + default: + return t.VisitChildren(s) + } +} + +type SUSER_IDContext struct { + Built_in_functionsContext + login IExpressionContext +} + +func NewSUSER_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SUSER_IDContext { + var p = new(SUSER_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SUSER_IDContext) GetLogin() IExpressionContext { return s.login } + +func (s *SUSER_IDContext) SetLogin(v IExpressionContext) { s.login = v } + +func (s *SUSER_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SUSER_IDContext) SUSER_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserSUSER_ID, 0) +} + +func (s *SUSER_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SUSER_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SUSER_IDContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SUSER_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSUSER_ID(s) + } +} + +func (s *SUSER_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSUSER_ID(s) + } +} + +func (s *SUSER_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSUSER_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type SCOPE_IDENTITYContext struct { + Built_in_functionsContext +} + +func NewSCOPE_IDENTITYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SCOPE_IDENTITYContext { + var p = new(SCOPE_IDENTITYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SCOPE_IDENTITYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SCOPE_IDENTITYContext) SCOPE_IDENTITY() antlr.TerminalNode { + return s.GetToken(TSqlParserSCOPE_IDENTITY, 0) +} + +func (s *SCOPE_IDENTITYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SCOPE_IDENTITYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SCOPE_IDENTITYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSCOPE_IDENTITY(s) + } +} + +func (s *SCOPE_IDENTITYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSCOPE_IDENTITY(s) + } +} + +func (s *SCOPE_IDENTITYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSCOPE_IDENTITY(s) + + default: + return t.VisitChildren(s) + } +} + +type JSON_QUERYContext struct { + Built_in_functionsContext + expr IExpressionContext + path IExpressionContext +} + +func NewJSON_QUERYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSON_QUERYContext { + var p = new(JSON_QUERYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *JSON_QUERYContext) GetExpr() IExpressionContext { return s.expr } + +func (s *JSON_QUERYContext) GetPath() IExpressionContext { return s.path } + +func (s *JSON_QUERYContext) SetExpr(v IExpressionContext) { s.expr = v } + +func (s *JSON_QUERYContext) SetPath(v IExpressionContext) { s.path = v } + +func (s *JSON_QUERYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JSON_QUERYContext) JSON_QUERY() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON_QUERY, 0) +} + +func (s *JSON_QUERYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *JSON_QUERYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *JSON_QUERYContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *JSON_QUERYContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *JSON_QUERYContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *JSON_QUERYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterJSON_QUERY(s) + } +} + +func (s *JSON_QUERYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitJSON_QUERY(s) + } +} + +func (s *JSON_QUERYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitJSON_QUERY(s) + + default: + return t.VisitChildren(s) + } +} + +type INDEX_COLContext struct { + Built_in_functionsContext + table_or_view_name IExpressionContext + index_id IExpressionContext + key_id IExpressionContext +} + +func NewINDEX_COLContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *INDEX_COLContext { + var p = new(INDEX_COLContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *INDEX_COLContext) GetTable_or_view_name() IExpressionContext { return s.table_or_view_name } + +func (s *INDEX_COLContext) GetIndex_id() IExpressionContext { return s.index_id } + +func (s *INDEX_COLContext) GetKey_id() IExpressionContext { return s.key_id } + +func (s *INDEX_COLContext) SetTable_or_view_name(v IExpressionContext) { s.table_or_view_name = v } + +func (s *INDEX_COLContext) SetIndex_id(v IExpressionContext) { s.index_id = v } + +func (s *INDEX_COLContext) SetKey_id(v IExpressionContext) { s.key_id = v } + +func (s *INDEX_COLContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *INDEX_COLContext) INDEX_COL() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX_COL, 0) +} + +func (s *INDEX_COLContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *INDEX_COLContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *INDEX_COLContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *INDEX_COLContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *INDEX_COLContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *INDEX_COLContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *INDEX_COLContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterINDEX_COL(s) + } +} + +func (s *INDEX_COLContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitINDEX_COL(s) + } +} + +func (s *INDEX_COLContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitINDEX_COL(s) + + default: + return t.VisitChildren(s) + } +} + +type DATABASE_PRINCIPAL_IDContext struct { + Built_in_functionsContext + principal_name IExpressionContext +} + +func NewDATABASE_PRINCIPAL_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATABASE_PRINCIPAL_IDContext { + var p = new(DATABASE_PRINCIPAL_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATABASE_PRINCIPAL_IDContext) GetPrincipal_name() IExpressionContext { + return s.principal_name +} + +func (s *DATABASE_PRINCIPAL_IDContext) SetPrincipal_name(v IExpressionContext) { s.principal_name = v } + +func (s *DATABASE_PRINCIPAL_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATABASE_PRINCIPAL_IDContext) DATABASE_PRINCIPAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE_PRINCIPAL_ID, 0) +} + +func (s *DATABASE_PRINCIPAL_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATABASE_PRINCIPAL_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATABASE_PRINCIPAL_IDContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATABASE_PRINCIPAL_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATABASE_PRINCIPAL_ID(s) + } +} + +func (s *DATABASE_PRINCIPAL_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATABASE_PRINCIPAL_ID(s) + } +} + +func (s *DATABASE_PRINCIPAL_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATABASE_PRINCIPAL_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type PATINDEXContext struct { + Built_in_functionsContext + pattern IExpressionContext + string_expression IExpressionContext +} + +func NewPATINDEXContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PATINDEXContext { + var p = new(PATINDEXContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *PATINDEXContext) GetPattern() IExpressionContext { return s.pattern } + +func (s *PATINDEXContext) GetString_expression() IExpressionContext { return s.string_expression } + +func (s *PATINDEXContext) SetPattern(v IExpressionContext) { s.pattern = v } + +func (s *PATINDEXContext) SetString_expression(v IExpressionContext) { s.string_expression = v } + +func (s *PATINDEXContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PATINDEXContext) PATINDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserPATINDEX, 0) +} + +func (s *PATINDEXContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *PATINDEXContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *PATINDEXContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *PATINDEXContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *PATINDEXContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PATINDEXContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPATINDEX(s) + } +} + +func (s *PATINDEXContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPATINDEX(s) + } +} + +func (s *PATINDEXContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPATINDEX(s) + + default: + return t.VisitChildren(s) + } +} + +type FULLTEXTSERVICEPROPERTYContext struct { + Built_in_functionsContext + property IExpressionContext +} + +func NewFULLTEXTSERVICEPROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FULLTEXTSERVICEPROPERTYContext { + var p = new(FULLTEXTSERVICEPROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FULLTEXTSERVICEPROPERTYContext) GetProperty() IExpressionContext { return s.property } + +func (s *FULLTEXTSERVICEPROPERTYContext) SetProperty(v IExpressionContext) { s.property = v } + +func (s *FULLTEXTSERVICEPROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FULLTEXTSERVICEPROPERTYContext) FULLTEXTSERVICEPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXTSERVICEPROPERTY, 0) +} + +func (s *FULLTEXTSERVICEPROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FULLTEXTSERVICEPROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FULLTEXTSERVICEPROPERTYContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FULLTEXTSERVICEPROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFULLTEXTSERVICEPROPERTY(s) + } +} + +func (s *FULLTEXTSERVICEPROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFULLTEXTSERVICEPROPERTY(s) + } +} + +func (s *FULLTEXTSERVICEPROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFULLTEXTSERVICEPROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type SMALLDATETIMEFROMPARTSContext struct { + Built_in_functionsContext + year IExpressionContext + month IExpressionContext + day IExpressionContext + hour IExpressionContext + minute IExpressionContext +} + +func NewSMALLDATETIMEFROMPARTSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SMALLDATETIMEFROMPARTSContext { + var p = new(SMALLDATETIMEFROMPARTSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SMALLDATETIMEFROMPARTSContext) GetYear() IExpressionContext { return s.year } + +func (s *SMALLDATETIMEFROMPARTSContext) GetMonth() IExpressionContext { return s.month } + +func (s *SMALLDATETIMEFROMPARTSContext) GetDay() IExpressionContext { return s.day } + +func (s *SMALLDATETIMEFROMPARTSContext) GetHour() IExpressionContext { return s.hour } + +func (s *SMALLDATETIMEFROMPARTSContext) GetMinute() IExpressionContext { return s.minute } + +func (s *SMALLDATETIMEFROMPARTSContext) SetYear(v IExpressionContext) { s.year = v } + +func (s *SMALLDATETIMEFROMPARTSContext) SetMonth(v IExpressionContext) { s.month = v } + +func (s *SMALLDATETIMEFROMPARTSContext) SetDay(v IExpressionContext) { s.day = v } + +func (s *SMALLDATETIMEFROMPARTSContext) SetHour(v IExpressionContext) { s.hour = v } + +func (s *SMALLDATETIMEFROMPARTSContext) SetMinute(v IExpressionContext) { s.minute = v } + +func (s *SMALLDATETIMEFROMPARTSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SMALLDATETIMEFROMPARTSContext) SMALLDATETIMEFROMPARTS() antlr.TerminalNode { + return s.GetToken(TSqlParserSMALLDATETIMEFROMPARTS, 0) +} + +func (s *SMALLDATETIMEFROMPARTSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SMALLDATETIMEFROMPARTSContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *SMALLDATETIMEFROMPARTSContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *SMALLDATETIMEFROMPARTSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SMALLDATETIMEFROMPARTSContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *SMALLDATETIMEFROMPARTSContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SMALLDATETIMEFROMPARTSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSMALLDATETIMEFROMPARTS(s) + } +} + +func (s *SMALLDATETIMEFROMPARTSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSMALLDATETIMEFROMPARTS(s) + } +} + +func (s *SMALLDATETIMEFROMPARTSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSMALLDATETIMEFROMPARTS(s) + + default: + return t.VisitChildren(s) + } +} + +type IDENT_CURRENTContext struct { + Built_in_functionsContext + table_or_view IExpressionContext +} + +func NewIDENT_CURRENTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IDENT_CURRENTContext { + var p = new(IDENT_CURRENTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *IDENT_CURRENTContext) GetTable_or_view() IExpressionContext { return s.table_or_view } + +func (s *IDENT_CURRENTContext) SetTable_or_view(v IExpressionContext) { s.table_or_view = v } + +func (s *IDENT_CURRENTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IDENT_CURRENTContext) IDENT_CURRENT() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENT_CURRENT, 0) +} + +func (s *IDENT_CURRENTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *IDENT_CURRENTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *IDENT_CURRENTContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IDENT_CURRENTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterIDENT_CURRENT(s) + } +} + +func (s *IDENT_CURRENTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitIDENT_CURRENT(s) + } +} + +func (s *IDENT_CURRENTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitIDENT_CURRENT(s) + + default: + return t.VisitChildren(s) + } +} + +type SESSIONPROPERTYContext struct { + Built_in_functionsContext + option_name IExpressionContext +} + +func NewSESSIONPROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SESSIONPROPERTYContext { + var p = new(SESSIONPROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SESSIONPROPERTYContext) GetOption_name() IExpressionContext { return s.option_name } + +func (s *SESSIONPROPERTYContext) SetOption_name(v IExpressionContext) { s.option_name = v } + +func (s *SESSIONPROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SESSIONPROPERTYContext) SESSIONPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserSESSIONPROPERTY, 0) +} + +func (s *SESSIONPROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SESSIONPROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SESSIONPROPERTYContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SESSIONPROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSESSIONPROPERTY(s) + } +} + +func (s *SESSIONPROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSESSIONPROPERTY(s) + } +} + +func (s *SESSIONPROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSESSIONPROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type FETCH_STATUSContext struct { + Built_in_functionsContext +} + +func NewFETCH_STATUSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FETCH_STATUSContext { + var p = new(FETCH_STATUSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FETCH_STATUSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FETCH_STATUSContext) FETCH_STATUS() antlr.TerminalNode { + return s.GetToken(TSqlParserFETCH_STATUS, 0) +} + +func (s *FETCH_STATUSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFETCH_STATUS(s) + } +} + +func (s *FETCH_STATUSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFETCH_STATUS(s) + } +} + +func (s *FETCH_STATUSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFETCH_STATUS(s) + + default: + return t.VisitChildren(s) + } +} + +type POWERContext struct { + Built_in_functionsContext + float_expression IExpressionContext + y IExpressionContext +} + +func NewPOWERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *POWERContext { + var p = new(POWERContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *POWERContext) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *POWERContext) GetY() IExpressionContext { return s.y } + +func (s *POWERContext) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *POWERContext) SetY(v IExpressionContext) { s.y = v } + +func (s *POWERContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *POWERContext) POWER() antlr.TerminalNode { + return s.GetToken(TSqlParserPOWER, 0) +} + +func (s *POWERContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *POWERContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *POWERContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *POWERContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *POWERContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *POWERContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPOWER(s) + } +} + +func (s *POWERContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPOWER(s) + } +} + +func (s *POWERContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPOWER(s) + + default: + return t.VisitChildren(s) + } +} + +type REPLICATEContext struct { + Built_in_functionsContext + string_expression IExpressionContext + integer_expression IExpressionContext +} + +func NewREPLICATEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *REPLICATEContext { + var p = new(REPLICATEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *REPLICATEContext) GetString_expression() IExpressionContext { return s.string_expression } + +func (s *REPLICATEContext) GetInteger_expression() IExpressionContext { return s.integer_expression } + +func (s *REPLICATEContext) SetString_expression(v IExpressionContext) { s.string_expression = v } + +func (s *REPLICATEContext) SetInteger_expression(v IExpressionContext) { s.integer_expression = v } + +func (s *REPLICATEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *REPLICATEContext) REPLICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLICATE, 0) +} + +func (s *REPLICATEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *REPLICATEContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *REPLICATEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *REPLICATEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *REPLICATEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *REPLICATEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterREPLICATE(s) + } +} + +func (s *REPLICATEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitREPLICATE(s) + } +} + +func (s *REPLICATEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitREPLICATE(s) + + default: + return t.VisitChildren(s) + } +} + +type USER_NAMEContext struct { + Built_in_functionsContext + id IExpressionContext +} + +func NewUSER_NAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *USER_NAMEContext { + var p = new(USER_NAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *USER_NAMEContext) GetId() IExpressionContext { return s.id } + +func (s *USER_NAMEContext) SetId(v IExpressionContext) { s.id = v } + +func (s *USER_NAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *USER_NAMEContext) USER_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER_NAME, 0) +} + +func (s *USER_NAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *USER_NAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *USER_NAMEContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *USER_NAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUSER_NAME(s) + } +} + +func (s *USER_NAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUSER_NAME(s) + } +} + +func (s *USER_NAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUSER_NAME(s) + + default: + return t.VisitChildren(s) + } +} + +type OBJECT_DEFINITIONContext struct { + Built_in_functionsContext + object_id IExpressionContext +} + +func NewOBJECT_DEFINITIONContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OBJECT_DEFINITIONContext { + var p = new(OBJECT_DEFINITIONContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *OBJECT_DEFINITIONContext) GetObject_id() IExpressionContext { return s.object_id } + +func (s *OBJECT_DEFINITIONContext) SetObject_id(v IExpressionContext) { s.object_id = v } + +func (s *OBJECT_DEFINITIONContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OBJECT_DEFINITIONContext) OBJECT_DEFINITION() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT_DEFINITION, 0) +} + +func (s *OBJECT_DEFINITIONContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *OBJECT_DEFINITIONContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *OBJECT_DEFINITIONContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *OBJECT_DEFINITIONContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOBJECT_DEFINITION(s) + } +} + +func (s *OBJECT_DEFINITIONContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOBJECT_DEFINITION(s) + } +} + +func (s *OBJECT_DEFINITIONContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOBJECT_DEFINITION(s) + + default: + return t.VisitChildren(s) + } +} + +type IS_SRVROLEMEMBERContext struct { + Built_in_functionsContext + role IExpressionContext + login IExpressionContext +} + +func NewIS_SRVROLEMEMBERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IS_SRVROLEMEMBERContext { + var p = new(IS_SRVROLEMEMBERContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *IS_SRVROLEMEMBERContext) GetRole() IExpressionContext { return s.role } + +func (s *IS_SRVROLEMEMBERContext) GetLogin() IExpressionContext { return s.login } + +func (s *IS_SRVROLEMEMBERContext) SetRole(v IExpressionContext) { s.role = v } + +func (s *IS_SRVROLEMEMBERContext) SetLogin(v IExpressionContext) { s.login = v } + +func (s *IS_SRVROLEMEMBERContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IS_SRVROLEMEMBERContext) IS_SRVROLEMEMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserIS_SRVROLEMEMBER, 0) +} + +func (s *IS_SRVROLEMEMBERContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *IS_SRVROLEMEMBERContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *IS_SRVROLEMEMBERContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *IS_SRVROLEMEMBERContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IS_SRVROLEMEMBERContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *IS_SRVROLEMEMBERContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterIS_SRVROLEMEMBER(s) + } +} + +func (s *IS_SRVROLEMEMBERContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitIS_SRVROLEMEMBER(s) + } +} + +func (s *IS_SRVROLEMEMBERContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitIS_SRVROLEMEMBER(s) + + default: + return t.VisitChildren(s) + } +} + +type NEWSEQUENTIALIDContext struct { + Built_in_functionsContext +} + +func NewNEWSEQUENTIALIDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NEWSEQUENTIALIDContext { + var p = new(NEWSEQUENTIALIDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *NEWSEQUENTIALIDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NEWSEQUENTIALIDContext) NEWSEQUENTIALID() antlr.TerminalNode { + return s.GetToken(TSqlParserNEWSEQUENTIALID, 0) +} + +func (s *NEWSEQUENTIALIDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *NEWSEQUENTIALIDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *NEWSEQUENTIALIDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterNEWSEQUENTIALID(s) + } +} + +func (s *NEWSEQUENTIALIDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitNEWSEQUENTIALID(s) + } +} + +func (s *NEWSEQUENTIALIDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitNEWSEQUENTIALID(s) + + default: + return t.VisitChildren(s) + } +} + +type OBJECT_NAMEContext struct { + Built_in_functionsContext + object_id IExpressionContext + database_id IExpressionContext +} + +func NewOBJECT_NAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OBJECT_NAMEContext { + var p = new(OBJECT_NAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *OBJECT_NAMEContext) GetObject_id() IExpressionContext { return s.object_id } + +func (s *OBJECT_NAMEContext) GetDatabase_id() IExpressionContext { return s.database_id } + +func (s *OBJECT_NAMEContext) SetObject_id(v IExpressionContext) { s.object_id = v } + +func (s *OBJECT_NAMEContext) SetDatabase_id(v IExpressionContext) { s.database_id = v } + +func (s *OBJECT_NAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OBJECT_NAMEContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT_NAME, 0) +} + +func (s *OBJECT_NAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *OBJECT_NAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *OBJECT_NAMEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *OBJECT_NAMEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *OBJECT_NAMEContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *OBJECT_NAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOBJECT_NAME(s) + } +} + +func (s *OBJECT_NAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOBJECT_NAME(s) + } +} + +func (s *OBJECT_NAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOBJECT_NAME(s) + + default: + return t.VisitChildren(s) + } +} + +type JSON_PATH_EXISTSContext struct { + Built_in_functionsContext + value_expression IExpressionContext + sql_json_path IExpressionContext +} + +func NewJSON_PATH_EXISTSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSON_PATH_EXISTSContext { + var p = new(JSON_PATH_EXISTSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *JSON_PATH_EXISTSContext) GetValue_expression() IExpressionContext { return s.value_expression } + +func (s *JSON_PATH_EXISTSContext) GetSql_json_path() IExpressionContext { return s.sql_json_path } + +func (s *JSON_PATH_EXISTSContext) SetValue_expression(v IExpressionContext) { s.value_expression = v } + +func (s *JSON_PATH_EXISTSContext) SetSql_json_path(v IExpressionContext) { s.sql_json_path = v } + +func (s *JSON_PATH_EXISTSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JSON_PATH_EXISTSContext) JSON_PATH_EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON_PATH_EXISTS, 0) +} + +func (s *JSON_PATH_EXISTSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *JSON_PATH_EXISTSContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *JSON_PATH_EXISTSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *JSON_PATH_EXISTSContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *JSON_PATH_EXISTSContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *JSON_PATH_EXISTSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterJSON_PATH_EXISTS(s) + } +} + +func (s *JSON_PATH_EXISTSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitJSON_PATH_EXISTS(s) + } +} + +func (s *JSON_PATH_EXISTSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitJSON_PATH_EXISTS(s) + + default: + return t.VisitChildren(s) + } +} + +type PWDCOMPAREContext struct { + Built_in_functionsContext + clear_text_password IExpressionContext + password_hash IExpressionContext + version IExpressionContext +} + +func NewPWDCOMPAREContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PWDCOMPAREContext { + var p = new(PWDCOMPAREContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *PWDCOMPAREContext) GetClear_text_password() IExpressionContext { return s.clear_text_password } + +func (s *PWDCOMPAREContext) GetPassword_hash() IExpressionContext { return s.password_hash } + +func (s *PWDCOMPAREContext) GetVersion() IExpressionContext { return s.version } + +func (s *PWDCOMPAREContext) SetClear_text_password(v IExpressionContext) { s.clear_text_password = v } + +func (s *PWDCOMPAREContext) SetPassword_hash(v IExpressionContext) { s.password_hash = v } + +func (s *PWDCOMPAREContext) SetVersion(v IExpressionContext) { s.version = v } + +func (s *PWDCOMPAREContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PWDCOMPAREContext) PWDCOMPARE() antlr.TerminalNode { + return s.GetToken(TSqlParserPWDCOMPARE, 0) +} + +func (s *PWDCOMPAREContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *PWDCOMPAREContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *PWDCOMPAREContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *PWDCOMPAREContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *PWDCOMPAREContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *PWDCOMPAREContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PWDCOMPAREContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPWDCOMPARE(s) + } +} + +func (s *PWDCOMPAREContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPWDCOMPARE(s) + } +} + +func (s *PWDCOMPAREContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPWDCOMPARE(s) + + default: + return t.VisitChildren(s) + } +} + +type SCHEMA_IDContext struct { + Built_in_functionsContext + schema_name IExpressionContext +} + +func NewSCHEMA_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SCHEMA_IDContext { + var p = new(SCHEMA_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SCHEMA_IDContext) GetSchema_name() IExpressionContext { return s.schema_name } + +func (s *SCHEMA_IDContext) SetSchema_name(v IExpressionContext) { s.schema_name = v } + +func (s *SCHEMA_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SCHEMA_IDContext) SCHEMA_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA_ID, 0) +} + +func (s *SCHEMA_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SCHEMA_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SCHEMA_IDContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SCHEMA_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSCHEMA_ID(s) + } +} + +func (s *SCHEMA_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSCHEMA_ID(s) + } +} + +func (s *SCHEMA_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSCHEMA_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type OBJECT_SCHEMA_NAMEContext struct { + Built_in_functionsContext + object_id IExpressionContext + database_id IExpressionContext +} + +func NewOBJECT_SCHEMA_NAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OBJECT_SCHEMA_NAMEContext { + var p = new(OBJECT_SCHEMA_NAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *OBJECT_SCHEMA_NAMEContext) GetObject_id() IExpressionContext { return s.object_id } + +func (s *OBJECT_SCHEMA_NAMEContext) GetDatabase_id() IExpressionContext { return s.database_id } + +func (s *OBJECT_SCHEMA_NAMEContext) SetObject_id(v IExpressionContext) { s.object_id = v } + +func (s *OBJECT_SCHEMA_NAMEContext) SetDatabase_id(v IExpressionContext) { s.database_id = v } + +func (s *OBJECT_SCHEMA_NAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OBJECT_SCHEMA_NAMEContext) OBJECT_SCHEMA_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT_SCHEMA_NAME, 0) +} + +func (s *OBJECT_SCHEMA_NAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *OBJECT_SCHEMA_NAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *OBJECT_SCHEMA_NAMEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *OBJECT_SCHEMA_NAMEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *OBJECT_SCHEMA_NAMEContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *OBJECT_SCHEMA_NAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOBJECT_SCHEMA_NAME(s) + } +} + +func (s *OBJECT_SCHEMA_NAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOBJECT_SCHEMA_NAME(s) + } +} + +func (s *OBJECT_SCHEMA_NAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOBJECT_SCHEMA_NAME(s) + + default: + return t.VisitChildren(s) + } +} + +type SUSER_SNAMEContext struct { + Built_in_functionsContext + server_user_sid IExpressionContext +} + +func NewSUSER_SNAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SUSER_SNAMEContext { + var p = new(SUSER_SNAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SUSER_SNAMEContext) GetServer_user_sid() IExpressionContext { return s.server_user_sid } + +func (s *SUSER_SNAMEContext) SetServer_user_sid(v IExpressionContext) { s.server_user_sid = v } + +func (s *SUSER_SNAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SUSER_SNAMEContext) SUSER_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserSUSER_NAME, 0) +} + +func (s *SUSER_SNAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SUSER_SNAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SUSER_SNAMEContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SUSER_SNAMEContext) SUSER_SNAME() antlr.TerminalNode { + return s.GetToken(TSqlParserSUSER_SNAME, 0) +} + +func (s *SUSER_SNAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSUSER_SNAME(s) + } +} + +func (s *SUSER_SNAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSUSER_SNAME(s) + } +} + +func (s *SUSER_SNAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSUSER_SNAME(s) + + default: + return t.VisitChildren(s) + } +} + +type DB_NAMEContext struct { + Built_in_functionsContext + database_id IExpressionContext +} + +func NewDB_NAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DB_NAMEContext { + var p = new(DB_NAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DB_NAMEContext) GetDatabase_id() IExpressionContext { return s.database_id } + +func (s *DB_NAMEContext) SetDatabase_id(v IExpressionContext) { s.database_id = v } + +func (s *DB_NAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DB_NAMEContext) DB_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserDB_NAME, 0) +} + +func (s *DB_NAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DB_NAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DB_NAMEContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DB_NAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDB_NAME(s) + } +} + +func (s *DB_NAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDB_NAME(s) + } +} + +func (s *DB_NAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDB_NAME(s) + + default: + return t.VisitChildren(s) + } +} + +type SUSER_SIDContext struct { + Built_in_functionsContext + login IExpressionContext + param2 IExpressionContext +} + +func NewSUSER_SIDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SUSER_SIDContext { + var p = new(SUSER_SIDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SUSER_SIDContext) GetLogin() IExpressionContext { return s.login } + +func (s *SUSER_SIDContext) GetParam2() IExpressionContext { return s.param2 } + +func (s *SUSER_SIDContext) SetLogin(v IExpressionContext) { s.login = v } + +func (s *SUSER_SIDContext) SetParam2(v IExpressionContext) { s.param2 = v } + +func (s *SUSER_SIDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SUSER_SIDContext) SUSER_SID() antlr.TerminalNode { + return s.GetToken(TSqlParserSUSER_SID, 0) +} + +func (s *SUSER_SIDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SUSER_SIDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SUSER_SIDContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *SUSER_SIDContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SUSER_SIDContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *SUSER_SIDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSUSER_SID(s) + } +} + +func (s *SUSER_SIDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSUSER_SID(s) + } +} + +func (s *SUSER_SIDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSUSER_SID(s) + + default: + return t.VisitChildren(s) + } +} + +type ASCIIContext struct { + Built_in_functionsContext + character_expression IExpressionContext +} + +func NewASCIIContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ASCIIContext { + var p = new(ASCIIContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ASCIIContext) GetCharacter_expression() IExpressionContext { return s.character_expression } + +func (s *ASCIIContext) SetCharacter_expression(v IExpressionContext) { s.character_expression = v } + +func (s *ASCIIContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ASCIIContext) ASCII() antlr.TerminalNode { + return s.GetToken(TSqlParserASCII, 0) +} + +func (s *ASCIIContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ASCIIContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ASCIIContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ASCIIContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterASCII(s) + } +} + +func (s *ASCIIContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitASCII(s) + } +} + +func (s *ASCIIContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitASCII(s) + + default: + return t.VisitChildren(s) + } +} + +type FILE_IDEXContext struct { + Built_in_functionsContext + file_name IExpressionContext +} + +func NewFILE_IDEXContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FILE_IDEXContext { + var p = new(FILE_IDEXContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FILE_IDEXContext) GetFile_name() IExpressionContext { return s.file_name } + +func (s *FILE_IDEXContext) SetFile_name(v IExpressionContext) { s.file_name = v } + +func (s *FILE_IDEXContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FILE_IDEXContext) FILE_IDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE_IDEX, 0) +} + +func (s *FILE_IDEXContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FILE_IDEXContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FILE_IDEXContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FILE_IDEXContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFILE_IDEX(s) + } +} + +func (s *FILE_IDEXContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFILE_IDEX(s) + } +} + +func (s *FILE_IDEXContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFILE_IDEX(s) + + default: + return t.VisitChildren(s) + } +} + +type ERROR_SEVERITYContext struct { + Built_in_functionsContext +} + +func NewERROR_SEVERITYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ERROR_SEVERITYContext { + var p = new(ERROR_SEVERITYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ERROR_SEVERITYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ERROR_SEVERITYContext) ERROR_SEVERITY() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_SEVERITY, 0) +} + +func (s *ERROR_SEVERITYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ERROR_SEVERITYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ERROR_SEVERITYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterERROR_SEVERITY(s) + } +} + +func (s *ERROR_SEVERITYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitERROR_SEVERITY(s) + } +} + +func (s *ERROR_SEVERITYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitERROR_SEVERITY(s) + + default: + return t.VisitChildren(s) + } +} + +type REVERSEContext struct { + Built_in_functionsContext + string_expression IExpressionContext +} + +func NewREVERSEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *REVERSEContext { + var p = new(REVERSEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *REVERSEContext) GetString_expression() IExpressionContext { return s.string_expression } + +func (s *REVERSEContext) SetString_expression(v IExpressionContext) { s.string_expression = v } + +func (s *REVERSEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *REVERSEContext) REVERSE() antlr.TerminalNode { + return s.GetToken(TSqlParserREVERSE, 0) +} + +func (s *REVERSEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *REVERSEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *REVERSEContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *REVERSEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterREVERSE(s) + } +} + +func (s *REVERSEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitREVERSE(s) + } +} + +func (s *REVERSEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitREVERSE(s) + + default: + return t.VisitChildren(s) + } +} + +type ISDATEContext struct { + Built_in_functionsContext +} + +func NewISDATEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ISDATEContext { + var p = new(ISDATEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ISDATEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ISDATEContext) ISDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserISDATE, 0) +} + +func (s *ISDATEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ISDATEContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ISDATEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ISDATEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterISDATE(s) + } +} + +func (s *ISDATEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitISDATE(s) + } +} + +func (s *ISDATEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitISDATE(s) + + default: + return t.VisitChildren(s) + } +} + +type REPLACEContext struct { + Built_in_functionsContext + input IExpressionContext + replacing IExpressionContext + with IExpressionContext +} + +func NewREPLACEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *REPLACEContext { + var p = new(REPLACEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *REPLACEContext) GetInput() IExpressionContext { return s.input } + +func (s *REPLACEContext) GetReplacing() IExpressionContext { return s.replacing } + +func (s *REPLACEContext) GetWith() IExpressionContext { return s.with } + +func (s *REPLACEContext) SetInput(v IExpressionContext) { s.input = v } + +func (s *REPLACEContext) SetReplacing(v IExpressionContext) { s.replacing = v } + +func (s *REPLACEContext) SetWith(v IExpressionContext) { s.with = v } + +func (s *REPLACEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *REPLACEContext) REPLACE() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLACE, 0) +} + +func (s *REPLACEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *REPLACEContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *REPLACEContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *REPLACEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *REPLACEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *REPLACEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *REPLACEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterREPLACE(s) + } +} + +func (s *REPLACEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitREPLACE(s) + } +} + +func (s *REPLACEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitREPLACE(s) + + default: + return t.VisitChildren(s) + } +} + +type CURSOR_STATUSContext struct { + Built_in_functionsContext + scope antlr.Token + cursor IExpressionContext +} + +func NewCURSOR_STATUSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CURSOR_STATUSContext { + var p = new(CURSOR_STATUSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CURSOR_STATUSContext) GetScope() antlr.Token { return s.scope } + +func (s *CURSOR_STATUSContext) SetScope(v antlr.Token) { s.scope = v } + +func (s *CURSOR_STATUSContext) GetCursor() IExpressionContext { return s.cursor } + +func (s *CURSOR_STATUSContext) SetCursor(v IExpressionContext) { s.cursor = v } + +func (s *CURSOR_STATUSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CURSOR_STATUSContext) CURSOR_STATUS() antlr.TerminalNode { + return s.GetToken(TSqlParserCURSOR_STATUS, 0) +} + +func (s *CURSOR_STATUSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CURSOR_STATUSContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *CURSOR_STATUSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CURSOR_STATUSContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *CURSOR_STATUSContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CURSOR_STATUSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCURSOR_STATUS(s) + } +} + +func (s *CURSOR_STATUSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCURSOR_STATUS(s) + } +} + +func (s *CURSOR_STATUSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCURSOR_STATUS(s) + + default: + return t.VisitChildren(s) + } +} + +type MIN_ACTIVE_ROWVERSIONContext struct { + Built_in_functionsContext +} + +func NewMIN_ACTIVE_ROWVERSIONContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MIN_ACTIVE_ROWVERSIONContext { + var p = new(MIN_ACTIVE_ROWVERSIONContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *MIN_ACTIVE_ROWVERSIONContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MIN_ACTIVE_ROWVERSIONContext) MIN_ACTIVE_ROWVERSION() antlr.TerminalNode { + return s.GetToken(TSqlParserMIN_ACTIVE_ROWVERSION, 0) +} + +func (s *MIN_ACTIVE_ROWVERSIONContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *MIN_ACTIVE_ROWVERSIONContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *MIN_ACTIVE_ROWVERSIONContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterMIN_ACTIVE_ROWVERSION(s) + } +} + +func (s *MIN_ACTIVE_ROWVERSIONContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitMIN_ACTIVE_ROWVERSION(s) + } +} + +func (s *MIN_ACTIVE_ROWVERSIONContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitMIN_ACTIVE_ROWVERSION(s) + + default: + return t.VisitChildren(s) + } +} + +type HAS_DBACCESSContext struct { + Built_in_functionsContext + database_name IExpressionContext +} + +func NewHAS_DBACCESSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HAS_DBACCESSContext { + var p = new(HAS_DBACCESSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *HAS_DBACCESSContext) GetDatabase_name() IExpressionContext { return s.database_name } + +func (s *HAS_DBACCESSContext) SetDatabase_name(v IExpressionContext) { s.database_name = v } + +func (s *HAS_DBACCESSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HAS_DBACCESSContext) HAS_DBACCESS() antlr.TerminalNode { + return s.GetToken(TSqlParserHAS_DBACCESS, 0) +} + +func (s *HAS_DBACCESSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *HAS_DBACCESSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *HAS_DBACCESSContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *HAS_DBACCESSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterHAS_DBACCESS(s) + } +} + +func (s *HAS_DBACCESSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitHAS_DBACCESS(s) + } +} + +func (s *HAS_DBACCESSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitHAS_DBACCESS(s) + + default: + return t.VisitChildren(s) + } +} + +type NEXT_VALUE_FORContext struct { + Built_in_functionsContext + sequence_name ITable_nameContext +} + +func NewNEXT_VALUE_FORContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NEXT_VALUE_FORContext { + var p = new(NEXT_VALUE_FORContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *NEXT_VALUE_FORContext) GetSequence_name() ITable_nameContext { return s.sequence_name } + +func (s *NEXT_VALUE_FORContext) SetSequence_name(v ITable_nameContext) { s.sequence_name = v } + +func (s *NEXT_VALUE_FORContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NEXT_VALUE_FORContext) NEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserNEXT, 0) +} + +func (s *NEXT_VALUE_FORContext) VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserVALUE, 0) +} + +func (s *NEXT_VALUE_FORContext) FOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFOR, 0) +} + +func (s *NEXT_VALUE_FORContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *NEXT_VALUE_FORContext) OVER() antlr.TerminalNode { + return s.GetToken(TSqlParserOVER, 0) +} + +func (s *NEXT_VALUE_FORContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *NEXT_VALUE_FORContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *NEXT_VALUE_FORContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *NEXT_VALUE_FORContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterNEXT_VALUE_FOR(s) + } +} + +func (s *NEXT_VALUE_FORContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitNEXT_VALUE_FOR(s) + } +} + +func (s *NEXT_VALUE_FORContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitNEXT_VALUE_FOR(s) + + default: + return t.VisitChildren(s) + } +} + +type FILEGROUP_IDContext struct { + Built_in_functionsContext + filegroup_name IExpressionContext +} + +func NewFILEGROUP_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FILEGROUP_IDContext { + var p = new(FILEGROUP_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FILEGROUP_IDContext) GetFilegroup_name() IExpressionContext { return s.filegroup_name } + +func (s *FILEGROUP_IDContext) SetFilegroup_name(v IExpressionContext) { s.filegroup_name = v } + +func (s *FILEGROUP_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FILEGROUP_IDContext) FILEGROUP_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROUP_ID, 0) +} + +func (s *FILEGROUP_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FILEGROUP_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FILEGROUP_IDContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FILEGROUP_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFILEGROUP_ID(s) + } +} + +func (s *FILEGROUP_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFILEGROUP_ID(s) + } +} + +func (s *FILEGROUP_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFILEGROUP_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type LOWERContext struct { + Built_in_functionsContext + character_expression IExpressionContext +} + +func NewLOWERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LOWERContext { + var p = new(LOWERContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *LOWERContext) GetCharacter_expression() IExpressionContext { return s.character_expression } + +func (s *LOWERContext) SetCharacter_expression(v IExpressionContext) { s.character_expression = v } + +func (s *LOWERContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LOWERContext) LOWER() antlr.TerminalNode { + return s.GetToken(TSqlParserLOWER, 0) +} + +func (s *LOWERContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *LOWERContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *LOWERContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *LOWERContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterLOWER(s) + } +} + +func (s *LOWERContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitLOWER(s) + } +} + +func (s *LOWERContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitLOWER(s) + + default: + return t.VisitChildren(s) + } +} + +type DATENAMEContext struct { + Built_in_functionsContext + datepart IDateparts_15Context + date IExpressionContext +} + +func NewDATENAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATENAMEContext { + var p = new(DATENAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATENAMEContext) GetDatepart() IDateparts_15Context { return s.datepart } + +func (s *DATENAMEContext) GetDate() IExpressionContext { return s.date } + +func (s *DATENAMEContext) SetDatepart(v IDateparts_15Context) { s.datepart = v } + +func (s *DATENAMEContext) SetDate(v IExpressionContext) { s.date = v } + +func (s *DATENAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATENAMEContext) DATENAME() antlr.TerminalNode { + return s.GetToken(TSqlParserDATENAME, 0) +} + +func (s *DATENAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATENAMEContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *DATENAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATENAMEContext) Dateparts_15() IDateparts_15Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDateparts_15Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDateparts_15Context) +} + +func (s *DATENAMEContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATENAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATENAME(s) + } +} + +func (s *DATENAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATENAME(s) + } +} + +func (s *DATENAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATENAME(s) + + default: + return t.VisitChildren(s) + } +} + +type CEILINGContext struct { + Built_in_functionsContext + numeric_expression IExpressionContext +} + +func NewCEILINGContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CEILINGContext { + var p = new(CEILINGContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CEILINGContext) GetNumeric_expression() IExpressionContext { return s.numeric_expression } + +func (s *CEILINGContext) SetNumeric_expression(v IExpressionContext) { s.numeric_expression = v } + +func (s *CEILINGContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CEILINGContext) CEILING() antlr.TerminalNode { + return s.GetToken(TSqlParserCEILING, 0) +} + +func (s *CEILINGContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CEILINGContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CEILINGContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CEILINGContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCEILING(s) + } +} + +func (s *CEILINGContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCEILING(s) + } +} + +func (s *CEILINGContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCEILING(s) + + default: + return t.VisitChildren(s) + } +} + +type APPLOCK_TESTContext struct { + Built_in_functionsContext + database_principal IExpressionContext + resource_name IExpressionContext + lock_mode IExpressionContext + lock_owner IExpressionContext +} + +func NewAPPLOCK_TESTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *APPLOCK_TESTContext { + var p = new(APPLOCK_TESTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *APPLOCK_TESTContext) GetDatabase_principal() IExpressionContext { return s.database_principal } + +func (s *APPLOCK_TESTContext) GetResource_name() IExpressionContext { return s.resource_name } + +func (s *APPLOCK_TESTContext) GetLock_mode() IExpressionContext { return s.lock_mode } + +func (s *APPLOCK_TESTContext) GetLock_owner() IExpressionContext { return s.lock_owner } + +func (s *APPLOCK_TESTContext) SetDatabase_principal(v IExpressionContext) { s.database_principal = v } + +func (s *APPLOCK_TESTContext) SetResource_name(v IExpressionContext) { s.resource_name = v } + +func (s *APPLOCK_TESTContext) SetLock_mode(v IExpressionContext) { s.lock_mode = v } + +func (s *APPLOCK_TESTContext) SetLock_owner(v IExpressionContext) { s.lock_owner = v } + +func (s *APPLOCK_TESTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *APPLOCK_TESTContext) APPLOCK_TEST() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLOCK_TEST, 0) +} + +func (s *APPLOCK_TESTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *APPLOCK_TESTContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *APPLOCK_TESTContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *APPLOCK_TESTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *APPLOCK_TESTContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *APPLOCK_TESTContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *APPLOCK_TESTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAPPLOCK_TEST(s) + } +} + +func (s *APPLOCK_TESTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAPPLOCK_TEST(s) + } +} + +func (s *APPLOCK_TESTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAPPLOCK_TEST(s) + + default: + return t.VisitChildren(s) + } +} + +type SINContext struct { + Built_in_functionsContext + float_expression IExpressionContext +} + +func NewSINContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SINContext { + var p = new(SINContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SINContext) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *SINContext) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *SINContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SINContext) SIN() antlr.TerminalNode { + return s.GetToken(TSqlParserSIN, 0) +} + +func (s *SINContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SINContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SINContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SINContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSIN(s) + } +} + +func (s *SINContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSIN(s) + } +} + +func (s *SINContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSIN(s) + + default: + return t.VisitChildren(s) + } +} + +type TYPE_NAMEContext struct { + Built_in_functionsContext + type_id IExpressionContext +} + +func NewTYPE_NAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TYPE_NAMEContext { + var p = new(TYPE_NAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *TYPE_NAMEContext) GetType_id() IExpressionContext { return s.type_id } + +func (s *TYPE_NAMEContext) SetType_id(v IExpressionContext) { s.type_id = v } + +func (s *TYPE_NAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TYPE_NAMEContext) TYPE_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE_NAME, 0) +} + +func (s *TYPE_NAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *TYPE_NAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *TYPE_NAMEContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *TYPE_NAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTYPE_NAME(s) + } +} + +func (s *TYPE_NAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTYPE_NAME(s) + } +} + +func (s *TYPE_NAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTYPE_NAME(s) + + default: + return t.VisitChildren(s) + } +} + +type SYSUTCDATETIMEContext struct { + Built_in_functionsContext +} + +func NewSYSUTCDATETIMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SYSUTCDATETIMEContext { + var p = new(SYSUTCDATETIMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SYSUTCDATETIMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SYSUTCDATETIMEContext) SYSUTCDATETIME() antlr.TerminalNode { + return s.GetToken(TSqlParserSYSUTCDATETIME, 0) +} + +func (s *SYSUTCDATETIMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SYSUTCDATETIMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SYSUTCDATETIMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSYSUTCDATETIME(s) + } +} + +func (s *SYSUTCDATETIMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSYSUTCDATETIME(s) + } +} + +func (s *SYSUTCDATETIMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSYSUTCDATETIME(s) + + default: + return t.VisitChildren(s) + } +} + +type DATEADDContext struct { + Built_in_functionsContext + datepart IDateparts_12Context + number IExpressionContext + date IExpressionContext +} + +func NewDATEADDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATEADDContext { + var p = new(DATEADDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATEADDContext) GetDatepart() IDateparts_12Context { return s.datepart } + +func (s *DATEADDContext) GetNumber() IExpressionContext { return s.number } + +func (s *DATEADDContext) GetDate() IExpressionContext { return s.date } + +func (s *DATEADDContext) SetDatepart(v IDateparts_12Context) { s.datepart = v } + +func (s *DATEADDContext) SetNumber(v IExpressionContext) { s.number = v } + +func (s *DATEADDContext) SetDate(v IExpressionContext) { s.date = v } + +func (s *DATEADDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATEADDContext) DATEADD() antlr.TerminalNode { + return s.GetToken(TSqlParserDATEADD, 0) +} + +func (s *DATEADDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATEADDContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *DATEADDContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *DATEADDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATEADDContext) Dateparts_12() IDateparts_12Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDateparts_12Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDateparts_12Context) +} + +func (s *DATEADDContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *DATEADDContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATEADDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATEADD(s) + } +} + +func (s *DATEADDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATEADD(s) + } +} + +func (s *DATEADDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATEADD(s) + + default: + return t.VisitChildren(s) + } +} + +type DATETIMEFROMPARTSContext struct { + Built_in_functionsContext + year IExpressionContext + month IExpressionContext + day IExpressionContext + hour IExpressionContext + minute IExpressionContext + seconds IExpressionContext + milliseconds IExpressionContext +} + +func NewDATETIMEFROMPARTSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATETIMEFROMPARTSContext { + var p = new(DATETIMEFROMPARTSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATETIMEFROMPARTSContext) GetYear() IExpressionContext { return s.year } + +func (s *DATETIMEFROMPARTSContext) GetMonth() IExpressionContext { return s.month } + +func (s *DATETIMEFROMPARTSContext) GetDay() IExpressionContext { return s.day } + +func (s *DATETIMEFROMPARTSContext) GetHour() IExpressionContext { return s.hour } + +func (s *DATETIMEFROMPARTSContext) GetMinute() IExpressionContext { return s.minute } + +func (s *DATETIMEFROMPARTSContext) GetSeconds() IExpressionContext { return s.seconds } + +func (s *DATETIMEFROMPARTSContext) GetMilliseconds() IExpressionContext { return s.milliseconds } + +func (s *DATETIMEFROMPARTSContext) SetYear(v IExpressionContext) { s.year = v } + +func (s *DATETIMEFROMPARTSContext) SetMonth(v IExpressionContext) { s.month = v } + +func (s *DATETIMEFROMPARTSContext) SetDay(v IExpressionContext) { s.day = v } + +func (s *DATETIMEFROMPARTSContext) SetHour(v IExpressionContext) { s.hour = v } + +func (s *DATETIMEFROMPARTSContext) SetMinute(v IExpressionContext) { s.minute = v } + +func (s *DATETIMEFROMPARTSContext) SetSeconds(v IExpressionContext) { s.seconds = v } + +func (s *DATETIMEFROMPARTSContext) SetMilliseconds(v IExpressionContext) { s.milliseconds = v } + +func (s *DATETIMEFROMPARTSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATETIMEFROMPARTSContext) DATETIMEFROMPARTS() antlr.TerminalNode { + return s.GetToken(TSqlParserDATETIMEFROMPARTS, 0) +} + +func (s *DATETIMEFROMPARTSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATETIMEFROMPARTSContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *DATETIMEFROMPARTSContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *DATETIMEFROMPARTSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATETIMEFROMPARTSContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *DATETIMEFROMPARTSContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATETIMEFROMPARTSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATETIMEFROMPARTS(s) + } +} + +func (s *DATETIMEFROMPARTSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATETIMEFROMPARTS(s) + } +} + +func (s *DATETIMEFROMPARTSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATETIMEFROMPARTS(s) + + default: + return t.VisitChildren(s) + } +} + +type ERROR_MESSAGEContext struct { + Built_in_functionsContext +} + +func NewERROR_MESSAGEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ERROR_MESSAGEContext { + var p = new(ERROR_MESSAGEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ERROR_MESSAGEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ERROR_MESSAGEContext) ERROR_MESSAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_MESSAGE, 0) +} + +func (s *ERROR_MESSAGEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ERROR_MESSAGEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ERROR_MESSAGEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterERROR_MESSAGE(s) + } +} + +func (s *ERROR_MESSAGEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitERROR_MESSAGE(s) + } +} + +func (s *ERROR_MESSAGEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitERROR_MESSAGE(s) + + default: + return t.VisitChildren(s) + } +} + +type FILEGROUPPROPERTYContext struct { + Built_in_functionsContext + filegroup_name IExpressionContext + property IExpressionContext +} + +func NewFILEGROUPPROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FILEGROUPPROPERTYContext { + var p = new(FILEGROUPPROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FILEGROUPPROPERTYContext) GetFilegroup_name() IExpressionContext { return s.filegroup_name } + +func (s *FILEGROUPPROPERTYContext) GetProperty() IExpressionContext { return s.property } + +func (s *FILEGROUPPROPERTYContext) SetFilegroup_name(v IExpressionContext) { s.filegroup_name = v } + +func (s *FILEGROUPPROPERTYContext) SetProperty(v IExpressionContext) { s.property = v } + +func (s *FILEGROUPPROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FILEGROUPPROPERTYContext) FILEGROUPPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROUPPROPERTY, 0) +} + +func (s *FILEGROUPPROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FILEGROUPPROPERTYContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *FILEGROUPPROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FILEGROUPPROPERTYContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *FILEGROUPPROPERTYContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FILEGROUPPROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFILEGROUPPROPERTY(s) + } +} + +func (s *FILEGROUPPROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFILEGROUPPROPERTY(s) + } +} + +func (s *FILEGROUPPROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFILEGROUPPROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type EOMONTHContext struct { + Built_in_functionsContext + start_date IExpressionContext + month_to_add IExpressionContext +} + +func NewEOMONTHContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EOMONTHContext { + var p = new(EOMONTHContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *EOMONTHContext) GetStart_date() IExpressionContext { return s.start_date } + +func (s *EOMONTHContext) GetMonth_to_add() IExpressionContext { return s.month_to_add } + +func (s *EOMONTHContext) SetStart_date(v IExpressionContext) { s.start_date = v } + +func (s *EOMONTHContext) SetMonth_to_add(v IExpressionContext) { s.month_to_add = v } + +func (s *EOMONTHContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EOMONTHContext) EOMONTH() antlr.TerminalNode { + return s.GetToken(TSqlParserEOMONTH, 0) +} + +func (s *EOMONTHContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *EOMONTHContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *EOMONTHContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *EOMONTHContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *EOMONTHContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *EOMONTHContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEOMONTH(s) + } +} + +func (s *EOMONTHContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEOMONTH(s) + } +} + +func (s *EOMONTHContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEOMONTH(s) + + default: + return t.VisitChildren(s) + } +} + +type IDENT_INCRContext struct { + Built_in_functionsContext + table_or_view IExpressionContext +} + +func NewIDENT_INCRContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IDENT_INCRContext { + var p = new(IDENT_INCRContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *IDENT_INCRContext) GetTable_or_view() IExpressionContext { return s.table_or_view } + +func (s *IDENT_INCRContext) SetTable_or_view(v IExpressionContext) { s.table_or_view = v } + +func (s *IDENT_INCRContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IDENT_INCRContext) IDENT_INCR() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENT_INCR, 0) +} + +func (s *IDENT_INCRContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *IDENT_INCRContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *IDENT_INCRContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IDENT_INCRContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterIDENT_INCR(s) + } +} + +func (s *IDENT_INCRContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitIDENT_INCR(s) + } +} + +func (s *IDENT_INCRContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitIDENT_INCR(s) + + default: + return t.VisitChildren(s) + } +} + +type ASINContext struct { + Built_in_functionsContext + float_expression IExpressionContext +} + +func NewASINContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ASINContext { + var p = new(ASINContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ASINContext) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *ASINContext) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *ASINContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ASINContext) ASIN() antlr.TerminalNode { + return s.GetToken(TSqlParserASIN, 0) +} + +func (s *ASINContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ASINContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ASINContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ASINContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterASIN(s) + } +} + +func (s *ASINContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitASIN(s) + } +} + +func (s *ASINContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitASIN(s) + + default: + return t.VisitChildren(s) + } +} + +type NCHARContext struct { + Built_in_functionsContext + integer_expression IExpressionContext +} + +func NewNCHARContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NCHARContext { + var p = new(NCHARContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *NCHARContext) GetInteger_expression() IExpressionContext { return s.integer_expression } + +func (s *NCHARContext) SetInteger_expression(v IExpressionContext) { s.integer_expression = v } + +func (s *NCHARContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NCHARContext) NCHAR() antlr.TerminalNode { + return s.GetToken(TSqlParserNCHAR, 0) +} + +func (s *NCHARContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *NCHARContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *NCHARContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *NCHARContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterNCHAR(s) + } +} + +func (s *NCHARContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitNCHAR(s) + } +} + +func (s *NCHARContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitNCHAR(s) + + default: + return t.VisitChildren(s) + } +} + +type DIFFERENCEContext struct { + Built_in_functionsContext + character_expression_1 IExpressionContext + character_expression_2 IExpressionContext +} + +func NewDIFFERENCEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DIFFERENCEContext { + var p = new(DIFFERENCEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DIFFERENCEContext) GetCharacter_expression_1() IExpressionContext { + return s.character_expression_1 +} + +func (s *DIFFERENCEContext) GetCharacter_expression_2() IExpressionContext { + return s.character_expression_2 +} + +func (s *DIFFERENCEContext) SetCharacter_expression_1(v IExpressionContext) { + s.character_expression_1 = v +} + +func (s *DIFFERENCEContext) SetCharacter_expression_2(v IExpressionContext) { + s.character_expression_2 = v +} + +func (s *DIFFERENCEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DIFFERENCEContext) DIFFERENCE() antlr.TerminalNode { + return s.GetToken(TSqlParserDIFFERENCE, 0) +} + +func (s *DIFFERENCEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DIFFERENCEContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *DIFFERENCEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DIFFERENCEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *DIFFERENCEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DIFFERENCEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDIFFERENCE(s) + } +} + +func (s *DIFFERENCEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDIFFERENCE(s) + } +} + +func (s *DIFFERENCEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDIFFERENCE(s) + + default: + return t.VisitChildren(s) + } +} + +type CHARINDEXContext struct { + Built_in_functionsContext + expressionToFind IExpressionContext + expressionToSearch IExpressionContext + start_location IExpressionContext +} + +func NewCHARINDEXContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CHARINDEXContext { + var p = new(CHARINDEXContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CHARINDEXContext) GetExpressionToFind() IExpressionContext { return s.expressionToFind } + +func (s *CHARINDEXContext) GetExpressionToSearch() IExpressionContext { return s.expressionToSearch } + +func (s *CHARINDEXContext) GetStart_location() IExpressionContext { return s.start_location } + +func (s *CHARINDEXContext) SetExpressionToFind(v IExpressionContext) { s.expressionToFind = v } + +func (s *CHARINDEXContext) SetExpressionToSearch(v IExpressionContext) { s.expressionToSearch = v } + +func (s *CHARINDEXContext) SetStart_location(v IExpressionContext) { s.start_location = v } + +func (s *CHARINDEXContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CHARINDEXContext) CHARINDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserCHARINDEX, 0) +} + +func (s *CHARINDEXContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CHARINDEXContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *CHARINDEXContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *CHARINDEXContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CHARINDEXContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *CHARINDEXContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CHARINDEXContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCHARINDEX(s) + } +} + +func (s *CHARINDEXContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCHARINDEX(s) + } +} + +func (s *CHARINDEXContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCHARINDEX(s) + + default: + return t.VisitChildren(s) + } +} + +type TODATETIMEOFFSETContext struct { + Built_in_functionsContext + datetime_expression IExpressionContext + timezoneoffset_expression IExpressionContext +} + +func NewTODATETIMEOFFSETContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TODATETIMEOFFSETContext { + var p = new(TODATETIMEOFFSETContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *TODATETIMEOFFSETContext) GetDatetime_expression() IExpressionContext { + return s.datetime_expression +} + +func (s *TODATETIMEOFFSETContext) GetTimezoneoffset_expression() IExpressionContext { + return s.timezoneoffset_expression +} + +func (s *TODATETIMEOFFSETContext) SetDatetime_expression(v IExpressionContext) { + s.datetime_expression = v +} + +func (s *TODATETIMEOFFSETContext) SetTimezoneoffset_expression(v IExpressionContext) { + s.timezoneoffset_expression = v +} + +func (s *TODATETIMEOFFSETContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TODATETIMEOFFSETContext) TODATETIMEOFFSET() antlr.TerminalNode { + return s.GetToken(TSqlParserTODATETIMEOFFSET, 0) +} + +func (s *TODATETIMEOFFSETContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *TODATETIMEOFFSETContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *TODATETIMEOFFSETContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *TODATETIMEOFFSETContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *TODATETIMEOFFSETContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *TODATETIMEOFFSETContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTODATETIMEOFFSET(s) + } +} + +func (s *TODATETIMEOFFSETContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTODATETIMEOFFSET(s) + } +} + +func (s *TODATETIMEOFFSETContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTODATETIMEOFFSET(s) + + default: + return t.VisitChildren(s) + } +} + +type RADIANSContext struct { + Built_in_functionsContext + numeric_expression IExpressionContext +} + +func NewRADIANSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RADIANSContext { + var p = new(RADIANSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *RADIANSContext) GetNumeric_expression() IExpressionContext { return s.numeric_expression } + +func (s *RADIANSContext) SetNumeric_expression(v IExpressionContext) { s.numeric_expression = v } + +func (s *RADIANSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RADIANSContext) RADIANS() antlr.TerminalNode { + return s.GetToken(TSqlParserRADIANS, 0) +} + +func (s *RADIANSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *RADIANSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *RADIANSContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *RADIANSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRADIANS(s) + } +} + +func (s *RADIANSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRADIANS(s) + } +} + +func (s *RADIANSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRADIANS(s) + + default: + return t.VisitChildren(s) + } +} + +type CURRENT_TIMEZONEContext struct { + Built_in_functionsContext +} + +func NewCURRENT_TIMEZONEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CURRENT_TIMEZONEContext { + var p = new(CURRENT_TIMEZONEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CURRENT_TIMEZONEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CURRENT_TIMEZONEContext) CURRENT_TIMEZONE() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT_TIMEZONE, 0) +} + +func (s *CURRENT_TIMEZONEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CURRENT_TIMEZONEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CURRENT_TIMEZONEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCURRENT_TIMEZONE(s) + } +} + +func (s *CURRENT_TIMEZONEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCURRENT_TIMEZONE(s) + } +} + +func (s *CURRENT_TIMEZONEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCURRENT_TIMEZONE(s) + + default: + return t.VisitChildren(s) + } +} + +type COL_LENGTHContext struct { + Built_in_functionsContext + table IExpressionContext + column IExpressionContext +} + +func NewCOL_LENGTHContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *COL_LENGTHContext { + var p = new(COL_LENGTHContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *COL_LENGTHContext) GetTable() IExpressionContext { return s.table } + +func (s *COL_LENGTHContext) GetColumn() IExpressionContext { return s.column } + +func (s *COL_LENGTHContext) SetTable(v IExpressionContext) { s.table = v } + +func (s *COL_LENGTHContext) SetColumn(v IExpressionContext) { s.column = v } + +func (s *COL_LENGTHContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *COL_LENGTHContext) COL_LENGTH() antlr.TerminalNode { + return s.GetToken(TSqlParserCOL_LENGTH, 0) +} + +func (s *COL_LENGTHContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *COL_LENGTHContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *COL_LENGTHContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *COL_LENGTHContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *COL_LENGTHContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *COL_LENGTHContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCOL_LENGTH(s) + } +} + +func (s *COL_LENGTHContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCOL_LENGTH(s) + } +} + +func (s *COL_LENGTHContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCOL_LENGTH(s) + + default: + return t.VisitChildren(s) + } +} + +type DATEFROMPARTSContext struct { + Built_in_functionsContext + year IExpressionContext + month IExpressionContext + day IExpressionContext +} + +func NewDATEFROMPARTSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATEFROMPARTSContext { + var p = new(DATEFROMPARTSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATEFROMPARTSContext) GetYear() IExpressionContext { return s.year } + +func (s *DATEFROMPARTSContext) GetMonth() IExpressionContext { return s.month } + +func (s *DATEFROMPARTSContext) GetDay() IExpressionContext { return s.day } + +func (s *DATEFROMPARTSContext) SetYear(v IExpressionContext) { s.year = v } + +func (s *DATEFROMPARTSContext) SetMonth(v IExpressionContext) { s.month = v } + +func (s *DATEFROMPARTSContext) SetDay(v IExpressionContext) { s.day = v } + +func (s *DATEFROMPARTSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATEFROMPARTSContext) DATEFROMPARTS() antlr.TerminalNode { + return s.GetToken(TSqlParserDATEFROMPARTS, 0) +} + +func (s *DATEFROMPARTSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATEFROMPARTSContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *DATEFROMPARTSContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *DATEFROMPARTSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATEFROMPARTSContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *DATEFROMPARTSContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATEFROMPARTSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATEFROMPARTS(s) + } +} + +func (s *DATEFROMPARTSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATEFROMPARTS(s) + } +} + +func (s *DATEFROMPARTSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATEFROMPARTS(s) + + default: + return t.VisitChildren(s) + } +} + +type NEWIDContext struct { + Built_in_functionsContext +} + +func NewNEWIDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NEWIDContext { + var p = new(NEWIDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *NEWIDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NEWIDContext) NEWID() antlr.TerminalNode { + return s.GetToken(TSqlParserNEWID, 0) +} + +func (s *NEWIDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *NEWIDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *NEWIDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterNEWID(s) + } +} + +func (s *NEWIDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitNEWID(s) + } +} + +func (s *NEWIDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitNEWID(s) + + default: + return t.VisitChildren(s) + } +} + +type DATETRUNCContext struct { + Built_in_functionsContext + datepart IDateparts_datetruncContext + date IExpressionContext +} + +func NewDATETRUNCContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATETRUNCContext { + var p = new(DATETRUNCContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATETRUNCContext) GetDatepart() IDateparts_datetruncContext { return s.datepart } + +func (s *DATETRUNCContext) GetDate() IExpressionContext { return s.date } + +func (s *DATETRUNCContext) SetDatepart(v IDateparts_datetruncContext) { s.datepart = v } + +func (s *DATETRUNCContext) SetDate(v IExpressionContext) { s.date = v } + +func (s *DATETRUNCContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATETRUNCContext) DATETRUNC() antlr.TerminalNode { + return s.GetToken(TSqlParserDATETRUNC, 0) +} + +func (s *DATETRUNCContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATETRUNCContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *DATETRUNCContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATETRUNCContext) Dateparts_datetrunc() IDateparts_datetruncContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDateparts_datetruncContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDateparts_datetruncContext) +} + +func (s *DATETRUNCContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATETRUNCContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATETRUNC(s) + } +} + +func (s *DATETRUNCContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATETRUNC(s) + } +} + +func (s *DATETRUNCContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATETRUNC(s) + + default: + return t.VisitChildren(s) + } +} + +type ISNULLContext struct { + Built_in_functionsContext + left IExpressionContext + right IExpressionContext +} + +func NewISNULLContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ISNULLContext { + var p = new(ISNULLContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ISNULLContext) GetLeft() IExpressionContext { return s.left } + +func (s *ISNULLContext) GetRight() IExpressionContext { return s.right } + +func (s *ISNULLContext) SetLeft(v IExpressionContext) { s.left = v } + +func (s *ISNULLContext) SetRight(v IExpressionContext) { s.right = v } + +func (s *ISNULLContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ISNULLContext) ISNULL() antlr.TerminalNode { + return s.GetToken(TSqlParserISNULL, 0) +} + +func (s *ISNULLContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ISNULLContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *ISNULLContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ISNULLContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *ISNULLContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ISNULLContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterISNULL(s) + } +} + +func (s *ISNULLContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitISNULL(s) + } +} + +func (s *ISNULLContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitISNULL(s) + + default: + return t.VisitChildren(s) + } +} + +type JSON_MODIFYContext struct { + Built_in_functionsContext + expr IExpressionContext + path IExpressionContext + new_value IExpressionContext +} + +func NewJSON_MODIFYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSON_MODIFYContext { + var p = new(JSON_MODIFYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *JSON_MODIFYContext) GetExpr() IExpressionContext { return s.expr } + +func (s *JSON_MODIFYContext) GetPath() IExpressionContext { return s.path } + +func (s *JSON_MODIFYContext) GetNew_value() IExpressionContext { return s.new_value } + +func (s *JSON_MODIFYContext) SetExpr(v IExpressionContext) { s.expr = v } + +func (s *JSON_MODIFYContext) SetPath(v IExpressionContext) { s.path = v } + +func (s *JSON_MODIFYContext) SetNew_value(v IExpressionContext) { s.new_value = v } + +func (s *JSON_MODIFYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JSON_MODIFYContext) JSON_MODIFY() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON_MODIFY, 0) +} + +func (s *JSON_MODIFYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *JSON_MODIFYContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *JSON_MODIFYContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *JSON_MODIFYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *JSON_MODIFYContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *JSON_MODIFYContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *JSON_MODIFYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterJSON_MODIFY(s) + } +} + +func (s *JSON_MODIFYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitJSON_MODIFY(s) + } +} + +func (s *JSON_MODIFYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitJSON_MODIFY(s) + + default: + return t.VisitChildren(s) + } +} + +type CURRENT_REQUEST_IDContext struct { + Built_in_functionsContext +} + +func NewCURRENT_REQUEST_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CURRENT_REQUEST_IDContext { + var p = new(CURRENT_REQUEST_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CURRENT_REQUEST_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CURRENT_REQUEST_IDContext) CURRENT_REQUEST_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT_REQUEST_ID, 0) +} + +func (s *CURRENT_REQUEST_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CURRENT_REQUEST_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CURRENT_REQUEST_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCURRENT_REQUEST_ID(s) + } +} + +func (s *CURRENT_REQUEST_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCURRENT_REQUEST_ID(s) + } +} + +func (s *CURRENT_REQUEST_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCURRENT_REQUEST_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type IS_MEMBERContext struct { + Built_in_functionsContext + group_or_role IExpressionContext +} + +func NewIS_MEMBERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IS_MEMBERContext { + var p = new(IS_MEMBERContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *IS_MEMBERContext) GetGroup_or_role() IExpressionContext { return s.group_or_role } + +func (s *IS_MEMBERContext) SetGroup_or_role(v IExpressionContext) { s.group_or_role = v } + +func (s *IS_MEMBERContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IS_MEMBERContext) IS_MEMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserIS_MEMBER, 0) +} + +func (s *IS_MEMBERContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *IS_MEMBERContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *IS_MEMBERContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IS_MEMBERContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterIS_MEMBER(s) + } +} + +func (s *IS_MEMBERContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitIS_MEMBER(s) + } +} + +func (s *IS_MEMBERContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitIS_MEMBER(s) + + default: + return t.VisitChildren(s) + } +} + +type SERVERPROPERTYContext struct { + Built_in_functionsContext + property IExpressionContext +} + +func NewSERVERPROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SERVERPROPERTYContext { + var p = new(SERVERPROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SERVERPROPERTYContext) GetProperty() IExpressionContext { return s.property } + +func (s *SERVERPROPERTYContext) SetProperty(v IExpressionContext) { s.property = v } + +func (s *SERVERPROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SERVERPROPERTYContext) SERVERPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVERPROPERTY, 0) +} + +func (s *SERVERPROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SERVERPROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SERVERPROPERTYContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SERVERPROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSERVERPROPERTY(s) + } +} + +func (s *SERVERPROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSERVERPROPERTY(s) + } +} + +func (s *SERVERPROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSERVERPROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type SQRTContext struct { + Built_in_functionsContext + float_expression IExpressionContext +} + +func NewSQRTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SQRTContext { + var p = new(SQRTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SQRTContext) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *SQRTContext) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *SQRTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SQRTContext) SQRT() antlr.TerminalNode { + return s.GetToken(TSqlParserSQRT, 0) +} + +func (s *SQRTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SQRTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SQRTContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SQRTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSQRT(s) + } +} + +func (s *SQRTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSQRT(s) + } +} + +func (s *SQRTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSQRT(s) + + default: + return t.VisitChildren(s) + } +} + +type ATN2Context struct { + Built_in_functionsContext + float_expression IExpressionContext +} + +func NewATN2Context(parser antlr.Parser, ctx antlr.ParserRuleContext) *ATN2Context { + var p = new(ATN2Context) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ATN2Context) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *ATN2Context) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *ATN2Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ATN2Context) ATN2() antlr.TerminalNode { + return s.GetToken(TSqlParserATN2, 0) +} + +func (s *ATN2Context) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ATN2Context) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *ATN2Context) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ATN2Context) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *ATN2Context) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ATN2Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterATN2(s) + } +} + +func (s *ATN2Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitATN2(s) + } +} + +func (s *ATN2Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitATN2(s) + + default: + return t.VisitChildren(s) + } +} + +type UNICODEContext struct { + Built_in_functionsContext + ncharacter_expression IExpressionContext +} + +func NewUNICODEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UNICODEContext { + var p = new(UNICODEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *UNICODEContext) GetNcharacter_expression() IExpressionContext { + return s.ncharacter_expression +} + +func (s *UNICODEContext) SetNcharacter_expression(v IExpressionContext) { s.ncharacter_expression = v } + +func (s *UNICODEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UNICODEContext) UNICODE() antlr.TerminalNode { + return s.GetToken(TSqlParserUNICODE, 0) +} + +func (s *UNICODEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *UNICODEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *UNICODEContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *UNICODEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUNICODE(s) + } +} + +func (s *UNICODEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUNICODE(s) + } +} + +func (s *UNICODEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUNICODE(s) + + default: + return t.VisitChildren(s) + } +} + +type NULLIFContext struct { + Built_in_functionsContext + left IExpressionContext + right IExpressionContext +} + +func NewNULLIFContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NULLIFContext { + var p = new(NULLIFContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *NULLIFContext) GetLeft() IExpressionContext { return s.left } + +func (s *NULLIFContext) GetRight() IExpressionContext { return s.right } + +func (s *NULLIFContext) SetLeft(v IExpressionContext) { s.left = v } + +func (s *NULLIFContext) SetRight(v IExpressionContext) { s.right = v } + +func (s *NULLIFContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NULLIFContext) NULLIF() antlr.TerminalNode { + return s.GetToken(TSqlParserNULLIF, 0) +} + +func (s *NULLIFContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *NULLIFContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *NULLIFContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *NULLIFContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *NULLIFContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *NULLIFContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterNULLIF(s) + } +} + +func (s *NULLIFContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitNULLIF(s) + } +} + +func (s *NULLIFContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitNULLIF(s) + + default: + return t.VisitChildren(s) + } +} + +type SESSION_USERContext struct { + Built_in_functionsContext +} + +func NewSESSION_USERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SESSION_USERContext { + var p = new(SESSION_USERContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SESSION_USERContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SESSION_USERContext) SESSION_USER() antlr.TerminalNode { + return s.GetToken(TSqlParserSESSION_USER, 0) +} + +func (s *SESSION_USERContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSESSION_USER(s) + } +} + +func (s *SESSION_USERContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSESSION_USER(s) + } +} + +func (s *SESSION_USERContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSESSION_USER(s) + + default: + return t.VisitChildren(s) + } +} + +type CASTContext struct { + Built_in_functionsContext +} + +func NewCASTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CASTContext { + var p = new(CASTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CASTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CASTContext) CAST() antlr.TerminalNode { + return s.GetToken(TSqlParserCAST, 0) +} + +func (s *CASTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CASTContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CASTContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *CASTContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *CASTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CASTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCAST(s) + } +} + +func (s *CASTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCAST(s) + } +} + +func (s *CASTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCAST(s) + + default: + return t.VisitChildren(s) + } +} + +type DATETIME2FROMPARTSContext struct { + Built_in_functionsContext + year IExpressionContext + month IExpressionContext + day IExpressionContext + hour IExpressionContext + minute IExpressionContext + seconds IExpressionContext + fractions IExpressionContext + precision IExpressionContext +} + +func NewDATETIME2FROMPARTSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATETIME2FROMPARTSContext { + var p = new(DATETIME2FROMPARTSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATETIME2FROMPARTSContext) GetYear() IExpressionContext { return s.year } + +func (s *DATETIME2FROMPARTSContext) GetMonth() IExpressionContext { return s.month } + +func (s *DATETIME2FROMPARTSContext) GetDay() IExpressionContext { return s.day } + +func (s *DATETIME2FROMPARTSContext) GetHour() IExpressionContext { return s.hour } + +func (s *DATETIME2FROMPARTSContext) GetMinute() IExpressionContext { return s.minute } + +func (s *DATETIME2FROMPARTSContext) GetSeconds() IExpressionContext { return s.seconds } + +func (s *DATETIME2FROMPARTSContext) GetFractions() IExpressionContext { return s.fractions } + +func (s *DATETIME2FROMPARTSContext) GetPrecision() IExpressionContext { return s.precision } + +func (s *DATETIME2FROMPARTSContext) SetYear(v IExpressionContext) { s.year = v } + +func (s *DATETIME2FROMPARTSContext) SetMonth(v IExpressionContext) { s.month = v } + +func (s *DATETIME2FROMPARTSContext) SetDay(v IExpressionContext) { s.day = v } + +func (s *DATETIME2FROMPARTSContext) SetHour(v IExpressionContext) { s.hour = v } + +func (s *DATETIME2FROMPARTSContext) SetMinute(v IExpressionContext) { s.minute = v } + +func (s *DATETIME2FROMPARTSContext) SetSeconds(v IExpressionContext) { s.seconds = v } + +func (s *DATETIME2FROMPARTSContext) SetFractions(v IExpressionContext) { s.fractions = v } + +func (s *DATETIME2FROMPARTSContext) SetPrecision(v IExpressionContext) { s.precision = v } + +func (s *DATETIME2FROMPARTSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATETIME2FROMPARTSContext) DATETIME2FROMPARTS() antlr.TerminalNode { + return s.GetToken(TSqlParserDATETIME2FROMPARTS, 0) +} + +func (s *DATETIME2FROMPARTSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATETIME2FROMPARTSContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *DATETIME2FROMPARTSContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *DATETIME2FROMPARTSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATETIME2FROMPARTSContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *DATETIME2FROMPARTSContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATETIME2FROMPARTSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATETIME2FROMPARTS(s) + } +} + +func (s *DATETIME2FROMPARTSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATETIME2FROMPARTS(s) + } +} + +func (s *DATETIME2FROMPARTSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATETIME2FROMPARTS(s) + + default: + return t.VisitChildren(s) + } +} + +type SQUAREContext struct { + Built_in_functionsContext + float_expression IExpressionContext +} + +func NewSQUAREContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SQUAREContext { + var p = new(SQUAREContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SQUAREContext) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *SQUAREContext) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *SQUAREContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SQUAREContext) SQUARE() antlr.TerminalNode { + return s.GetToken(TSqlParserSQUARE, 0) +} + +func (s *SQUAREContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SQUAREContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SQUAREContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SQUAREContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSQUARE(s) + } +} + +func (s *SQUAREContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSQUARE(s) + } +} + +func (s *SQUAREContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSQUARE(s) + + default: + return t.VisitChildren(s) + } +} + +type LOGContext struct { + Built_in_functionsContext + float_expression IExpressionContext + base IExpressionContext +} + +func NewLOGContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LOGContext { + var p = new(LOGContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *LOGContext) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *LOGContext) GetBase() IExpressionContext { return s.base } + +func (s *LOGContext) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *LOGContext) SetBase(v IExpressionContext) { s.base = v } + +func (s *LOGContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LOGContext) LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserLOG, 0) +} + +func (s *LOGContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *LOGContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *LOGContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *LOGContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *LOGContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *LOGContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterLOG(s) + } +} + +func (s *LOGContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitLOG(s) + } +} + +func (s *LOGContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitLOG(s) + + default: + return t.VisitChildren(s) + } +} + +type IIFContext struct { + Built_in_functionsContext + cond ISearch_conditionContext + left IExpressionContext + right IExpressionContext +} + +func NewIIFContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IIFContext { + var p = new(IIFContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *IIFContext) GetCond() ISearch_conditionContext { return s.cond } + +func (s *IIFContext) GetLeft() IExpressionContext { return s.left } + +func (s *IIFContext) GetRight() IExpressionContext { return s.right } + +func (s *IIFContext) SetCond(v ISearch_conditionContext) { s.cond = v } + +func (s *IIFContext) SetLeft(v IExpressionContext) { s.left = v } + +func (s *IIFContext) SetRight(v IExpressionContext) { s.right = v } + +func (s *IIFContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IIFContext) IIF() antlr.TerminalNode { + return s.GetToken(TSqlParserIIF, 0) +} + +func (s *IIFContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *IIFContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *IIFContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *IIFContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *IIFContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *IIFContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *IIFContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IIFContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterIIF(s) + } +} + +func (s *IIFContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitIIF(s) + } +} + +func (s *IIFContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitIIF(s) + + default: + return t.VisitChildren(s) + } +} + +type DATEPARTContext struct { + Built_in_functionsContext + datepart IDateparts_15Context + date IExpressionContext +} + +func NewDATEPARTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATEPARTContext { + var p = new(DATEPARTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATEPARTContext) GetDatepart() IDateparts_15Context { return s.datepart } + +func (s *DATEPARTContext) GetDate() IExpressionContext { return s.date } + +func (s *DATEPARTContext) SetDatepart(v IDateparts_15Context) { s.datepart = v } + +func (s *DATEPARTContext) SetDate(v IExpressionContext) { s.date = v } + +func (s *DATEPARTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATEPARTContext) DATEPART() antlr.TerminalNode { + return s.GetToken(TSqlParserDATEPART, 0) +} + +func (s *DATEPARTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATEPARTContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *DATEPARTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATEPARTContext) Dateparts_15() IDateparts_15Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDateparts_15Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDateparts_15Context) +} + +func (s *DATEPARTContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATEPARTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATEPART(s) + } +} + +func (s *DATEPARTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATEPART(s) + } +} + +func (s *DATEPARTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATEPART(s) + + default: + return t.VisitChildren(s) + } +} + +type CONTEXT_INFOContext struct { + Built_in_functionsContext +} + +func NewCONTEXT_INFOContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CONTEXT_INFOContext { + var p = new(CONTEXT_INFOContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CONTEXT_INFOContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CONTEXT_INFOContext) CONTEXT_INFO() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTEXT_INFO, 0) +} + +func (s *CONTEXT_INFOContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CONTEXT_INFOContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CONTEXT_INFOContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCONTEXT_INFO(s) + } +} + +func (s *CONTEXT_INFOContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCONTEXT_INFO(s) + } +} + +func (s *CONTEXT_INFOContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCONTEXT_INFO(s) + + default: + return t.VisitChildren(s) + } +} + +type DATEDIFFContext struct { + Built_in_functionsContext + datepart IDateparts_12Context + date_first IExpressionContext + date_second IExpressionContext +} + +func NewDATEDIFFContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATEDIFFContext { + var p = new(DATEDIFFContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATEDIFFContext) GetDatepart() IDateparts_12Context { return s.datepart } + +func (s *DATEDIFFContext) GetDate_first() IExpressionContext { return s.date_first } + +func (s *DATEDIFFContext) GetDate_second() IExpressionContext { return s.date_second } + +func (s *DATEDIFFContext) SetDatepart(v IDateparts_12Context) { s.datepart = v } + +func (s *DATEDIFFContext) SetDate_first(v IExpressionContext) { s.date_first = v } + +func (s *DATEDIFFContext) SetDate_second(v IExpressionContext) { s.date_second = v } + +func (s *DATEDIFFContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATEDIFFContext) DATEDIFF() antlr.TerminalNode { + return s.GetToken(TSqlParserDATEDIFF, 0) +} + +func (s *DATEDIFFContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATEDIFFContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *DATEDIFFContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *DATEDIFFContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATEDIFFContext) Dateparts_12() IDateparts_12Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDateparts_12Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDateparts_12Context) +} + +func (s *DATEDIFFContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *DATEDIFFContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATEDIFFContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATEDIFF(s) + } +} + +func (s *DATEDIFFContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATEDIFF(s) + } +} + +func (s *DATEDIFFContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATEDIFF(s) + + default: + return t.VisitChildren(s) + } +} + +type OBJECTPROPERTYContext struct { + Built_in_functionsContext + id IExpressionContext + property IExpressionContext +} + +func NewOBJECTPROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OBJECTPROPERTYContext { + var p = new(OBJECTPROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *OBJECTPROPERTYContext) GetId() IExpressionContext { return s.id } + +func (s *OBJECTPROPERTYContext) GetProperty() IExpressionContext { return s.property } + +func (s *OBJECTPROPERTYContext) SetId(v IExpressionContext) { s.id = v } + +func (s *OBJECTPROPERTYContext) SetProperty(v IExpressionContext) { s.property = v } + +func (s *OBJECTPROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OBJECTPROPERTYContext) OBJECTPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECTPROPERTY, 0) +} + +func (s *OBJECTPROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *OBJECTPROPERTYContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *OBJECTPROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *OBJECTPROPERTYContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *OBJECTPROPERTYContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *OBJECTPROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOBJECTPROPERTY(s) + } +} + +func (s *OBJECTPROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOBJECTPROPERTY(s) + } +} + +func (s *OBJECTPROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOBJECTPROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type CHARContext struct { + Built_in_functionsContext + integer_expression IExpressionContext +} + +func NewCHARContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CHARContext { + var p = new(CHARContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CHARContext) GetInteger_expression() IExpressionContext { return s.integer_expression } + +func (s *CHARContext) SetInteger_expression(v IExpressionContext) { s.integer_expression = v } + +func (s *CHARContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CHARContext) CHAR() antlr.TerminalNode { + return s.GetToken(TSqlParserCHAR, 0) +} + +func (s *CHARContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CHARContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CHARContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CHARContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCHAR(s) + } +} + +func (s *CHARContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCHAR(s) + } +} + +func (s *CHARContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCHAR(s) + + default: + return t.VisitChildren(s) + } +} + +type STRING_ESCAPEContext struct { + Built_in_functionsContext + text_ IExpressionContext + type_ IExpressionContext +} + +func NewSTRING_ESCAPEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *STRING_ESCAPEContext { + var p = new(STRING_ESCAPEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *STRING_ESCAPEContext) GetText_() IExpressionContext { return s.text_ } + +func (s *STRING_ESCAPEContext) GetType_() IExpressionContext { return s.type_ } + +func (s *STRING_ESCAPEContext) SetText_(v IExpressionContext) { s.text_ = v } + +func (s *STRING_ESCAPEContext) SetType_(v IExpressionContext) { s.type_ = v } + +func (s *STRING_ESCAPEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *STRING_ESCAPEContext) STRING_ESCAPE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING_ESCAPE, 0) +} + +func (s *STRING_ESCAPEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *STRING_ESCAPEContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *STRING_ESCAPEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *STRING_ESCAPEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *STRING_ESCAPEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *STRING_ESCAPEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSTRING_ESCAPE(s) + } +} + +func (s *STRING_ESCAPEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSTRING_ESCAPE(s) + } +} + +func (s *STRING_ESCAPEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSTRING_ESCAPE(s) + + default: + return t.VisitChildren(s) + } +} + +type GETANSINULLContext struct { + Built_in_functionsContext + database antlr.Token +} + +func NewGETANSINULLContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GETANSINULLContext { + var p = new(GETANSINULLContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *GETANSINULLContext) GetDatabase() antlr.Token { return s.database } + +func (s *GETANSINULLContext) SetDatabase(v antlr.Token) { s.database = v } + +func (s *GETANSINULLContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GETANSINULLContext) GETANSINULL() antlr.TerminalNode { + return s.GetToken(TSqlParserGETANSINULL, 0) +} + +func (s *GETANSINULLContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *GETANSINULLContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *GETANSINULLContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *GETANSINULLContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterGETANSINULL(s) + } +} + +func (s *GETANSINULLContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitGETANSINULL(s) + } +} + +func (s *GETANSINULLContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitGETANSINULL(s) + + default: + return t.VisitChildren(s) + } +} + +type SYSTEM_USERContext struct { + Built_in_functionsContext +} + +func NewSYSTEM_USERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SYSTEM_USERContext { + var p = new(SYSTEM_USERContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SYSTEM_USERContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SYSTEM_USERContext) SYSTEM_USER() antlr.TerminalNode { + return s.GetToken(TSqlParserSYSTEM_USER, 0) +} + +func (s *SYSTEM_USERContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSYSTEM_USER(s) + } +} + +func (s *SYSTEM_USERContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSYSTEM_USER(s) + } +} + +func (s *SYSTEM_USERContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSYSTEM_USER(s) + + default: + return t.VisitChildren(s) + } +} + +type OBJECT_IDContext struct { + Built_in_functionsContext + object_name IExpressionContext + object_type IExpressionContext +} + +func NewOBJECT_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OBJECT_IDContext { + var p = new(OBJECT_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *OBJECT_IDContext) GetObject_name() IExpressionContext { return s.object_name } + +func (s *OBJECT_IDContext) GetObject_type() IExpressionContext { return s.object_type } + +func (s *OBJECT_IDContext) SetObject_name(v IExpressionContext) { s.object_name = v } + +func (s *OBJECT_IDContext) SetObject_type(v IExpressionContext) { s.object_type = v } + +func (s *OBJECT_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OBJECT_IDContext) OBJECT_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT_ID, 0) +} + +func (s *OBJECT_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *OBJECT_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *OBJECT_IDContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *OBJECT_IDContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *OBJECT_IDContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *OBJECT_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOBJECT_ID(s) + } +} + +func (s *OBJECT_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOBJECT_ID(s) + } +} + +func (s *OBJECT_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOBJECT_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type ERROR_PROCEDUREContext struct { + Built_in_functionsContext +} + +func NewERROR_PROCEDUREContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ERROR_PROCEDUREContext { + var p = new(ERROR_PROCEDUREContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ERROR_PROCEDUREContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ERROR_PROCEDUREContext) ERROR_PROCEDURE() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_PROCEDURE, 0) +} + +func (s *ERROR_PROCEDUREContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ERROR_PROCEDUREContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ERROR_PROCEDUREContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterERROR_PROCEDURE(s) + } +} + +func (s *ERROR_PROCEDUREContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitERROR_PROCEDURE(s) + } +} + +func (s *ERROR_PROCEDUREContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitERROR_PROCEDURE(s) + + default: + return t.VisitChildren(s) + } +} + +type QUOTENAMEContext struct { + Built_in_functionsContext + character_string IExpressionContext + quote_character IExpressionContext +} + +func NewQUOTENAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *QUOTENAMEContext { + var p = new(QUOTENAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *QUOTENAMEContext) GetCharacter_string() IExpressionContext { return s.character_string } + +func (s *QUOTENAMEContext) GetQuote_character() IExpressionContext { return s.quote_character } + +func (s *QUOTENAMEContext) SetCharacter_string(v IExpressionContext) { s.character_string = v } + +func (s *QUOTENAMEContext) SetQuote_character(v IExpressionContext) { s.quote_character = v } + +func (s *QUOTENAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *QUOTENAMEContext) QUOTENAME() antlr.TerminalNode { + return s.GetToken(TSqlParserQUOTENAME, 0) +} + +func (s *QUOTENAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *QUOTENAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *QUOTENAMEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *QUOTENAMEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *QUOTENAMEContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *QUOTENAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterQUOTENAME(s) + } +} + +func (s *QUOTENAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitQUOTENAME(s) + } +} + +func (s *QUOTENAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitQUOTENAME(s) + + default: + return t.VisitChildren(s) + } +} + +type RIGHTContext struct { + Built_in_functionsContext + character_expression IExpressionContext + integer_expression IExpressionContext +} + +func NewRIGHTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RIGHTContext { + var p = new(RIGHTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *RIGHTContext) GetCharacter_expression() IExpressionContext { return s.character_expression } + +func (s *RIGHTContext) GetInteger_expression() IExpressionContext { return s.integer_expression } + +func (s *RIGHTContext) SetCharacter_expression(v IExpressionContext) { s.character_expression = v } + +func (s *RIGHTContext) SetInteger_expression(v IExpressionContext) { s.integer_expression = v } + +func (s *RIGHTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RIGHTContext) RIGHT() antlr.TerminalNode { + return s.GetToken(TSqlParserRIGHT, 0) +} + +func (s *RIGHTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *RIGHTContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *RIGHTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *RIGHTContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *RIGHTContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *RIGHTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRIGHT(s) + } +} + +func (s *RIGHTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRIGHT(s) + } +} + +func (s *RIGHTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRIGHT(s) + + default: + return t.VisitChildren(s) + } +} + +type HOST_IDContext struct { + Built_in_functionsContext +} + +func NewHOST_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HOST_IDContext { + var p = new(HOST_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *HOST_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HOST_IDContext) HOST_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserHOST_ID, 0) +} + +func (s *HOST_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *HOST_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *HOST_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterHOST_ID(s) + } +} + +func (s *HOST_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitHOST_ID(s) + } +} + +func (s *HOST_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitHOST_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type DATETIMEOFFSETFROMPARTSContext struct { + Built_in_functionsContext + year IExpressionContext + month IExpressionContext + day IExpressionContext + hour IExpressionContext + minute IExpressionContext + seconds IExpressionContext + fractions IExpressionContext + hour_offset IExpressionContext + minute_offset IExpressionContext + precision antlr.Token +} + +func NewDATETIMEOFFSETFROMPARTSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATETIMEOFFSETFROMPARTSContext { + var p = new(DATETIMEOFFSETFROMPARTSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATETIMEOFFSETFROMPARTSContext) GetPrecision() antlr.Token { return s.precision } + +func (s *DATETIMEOFFSETFROMPARTSContext) SetPrecision(v antlr.Token) { s.precision = v } + +func (s *DATETIMEOFFSETFROMPARTSContext) GetYear() IExpressionContext { return s.year } + +func (s *DATETIMEOFFSETFROMPARTSContext) GetMonth() IExpressionContext { return s.month } + +func (s *DATETIMEOFFSETFROMPARTSContext) GetDay() IExpressionContext { return s.day } + +func (s *DATETIMEOFFSETFROMPARTSContext) GetHour() IExpressionContext { return s.hour } + +func (s *DATETIMEOFFSETFROMPARTSContext) GetMinute() IExpressionContext { return s.minute } + +func (s *DATETIMEOFFSETFROMPARTSContext) GetSeconds() IExpressionContext { return s.seconds } + +func (s *DATETIMEOFFSETFROMPARTSContext) GetFractions() IExpressionContext { return s.fractions } + +func (s *DATETIMEOFFSETFROMPARTSContext) GetHour_offset() IExpressionContext { return s.hour_offset } + +func (s *DATETIMEOFFSETFROMPARTSContext) GetMinute_offset() IExpressionContext { + return s.minute_offset +} + +func (s *DATETIMEOFFSETFROMPARTSContext) SetYear(v IExpressionContext) { s.year = v } + +func (s *DATETIMEOFFSETFROMPARTSContext) SetMonth(v IExpressionContext) { s.month = v } + +func (s *DATETIMEOFFSETFROMPARTSContext) SetDay(v IExpressionContext) { s.day = v } + +func (s *DATETIMEOFFSETFROMPARTSContext) SetHour(v IExpressionContext) { s.hour = v } + +func (s *DATETIMEOFFSETFROMPARTSContext) SetMinute(v IExpressionContext) { s.minute = v } + +func (s *DATETIMEOFFSETFROMPARTSContext) SetSeconds(v IExpressionContext) { s.seconds = v } + +func (s *DATETIMEOFFSETFROMPARTSContext) SetFractions(v IExpressionContext) { s.fractions = v } + +func (s *DATETIMEOFFSETFROMPARTSContext) SetHour_offset(v IExpressionContext) { s.hour_offset = v } + +func (s *DATETIMEOFFSETFROMPARTSContext) SetMinute_offset(v IExpressionContext) { s.minute_offset = v } + +func (s *DATETIMEOFFSETFROMPARTSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATETIMEOFFSETFROMPARTSContext) DATETIMEOFFSETFROMPARTS() antlr.TerminalNode { + return s.GetToken(TSqlParserDATETIMEOFFSETFROMPARTS, 0) +} + +func (s *DATETIMEOFFSETFROMPARTSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATETIMEOFFSETFROMPARTSContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *DATETIMEOFFSETFROMPARTSContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *DATETIMEOFFSETFROMPARTSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATETIMEOFFSETFROMPARTSContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *DATETIMEOFFSETFROMPARTSContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATETIMEOFFSETFROMPARTSContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *DATETIMEOFFSETFROMPARTSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATETIMEOFFSETFROMPARTS(s) + } +} + +func (s *DATETIMEOFFSETFROMPARTSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATETIMEOFFSETFROMPARTS(s) + } +} + +func (s *DATETIMEOFFSETFROMPARTSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATETIMEOFFSETFROMPARTS(s) + + default: + return t.VisitChildren(s) + } +} + +type COSContext struct { + Built_in_functionsContext + float_expression IExpressionContext +} + +func NewCOSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *COSContext { + var p = new(COSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *COSContext) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *COSContext) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *COSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *COSContext) COS() antlr.TerminalNode { + return s.GetToken(TSqlParserCOS, 0) +} + +func (s *COSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *COSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *COSContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *COSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCOS(s) + } +} + +func (s *COSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCOS(s) + } +} + +func (s *COSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCOS(s) + + default: + return t.VisitChildren(s) + } +} + +type COTContext struct { + Built_in_functionsContext + float_expression IExpressionContext +} + +func NewCOTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *COTContext { + var p = new(COTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *COTContext) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *COTContext) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *COTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *COTContext) COT() antlr.TerminalNode { + return s.GetToken(TSqlParserCOT, 0) +} + +func (s *COTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *COTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *COTContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *COTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCOT(s) + } +} + +func (s *COTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCOT(s) + } +} + +func (s *COTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCOT(s) + + default: + return t.VisitChildren(s) + } +} + +type FILE_IDContext struct { + Built_in_functionsContext + file_name IExpressionContext +} + +func NewFILE_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FILE_IDContext { + var p = new(FILE_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FILE_IDContext) GetFile_name() IExpressionContext { return s.file_name } + +func (s *FILE_IDContext) SetFile_name(v IExpressionContext) { s.file_name = v } + +func (s *FILE_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FILE_IDContext) FILE_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE_ID, 0) +} + +func (s *FILE_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FILE_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FILE_IDContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FILE_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFILE_ID(s) + } +} + +func (s *FILE_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFILE_ID(s) + } +} + +func (s *FILE_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFILE_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type ASSEMBLYPROPERTYContext struct { + Built_in_functionsContext + assembly_name IExpressionContext + property_name IExpressionContext +} + +func NewASSEMBLYPROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ASSEMBLYPROPERTYContext { + var p = new(ASSEMBLYPROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ASSEMBLYPROPERTYContext) GetAssembly_name() IExpressionContext { return s.assembly_name } + +func (s *ASSEMBLYPROPERTYContext) GetProperty_name() IExpressionContext { return s.property_name } + +func (s *ASSEMBLYPROPERTYContext) SetAssembly_name(v IExpressionContext) { s.assembly_name = v } + +func (s *ASSEMBLYPROPERTYContext) SetProperty_name(v IExpressionContext) { s.property_name = v } + +func (s *ASSEMBLYPROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ASSEMBLYPROPERTYContext) ASSEMBLYPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserASSEMBLYPROPERTY, 0) +} + +func (s *ASSEMBLYPROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ASSEMBLYPROPERTYContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *ASSEMBLYPROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ASSEMBLYPROPERTYContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *ASSEMBLYPROPERTYContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ASSEMBLYPROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterASSEMBLYPROPERTY(s) + } +} + +func (s *ASSEMBLYPROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitASSEMBLYPROPERTY(s) + } +} + +func (s *ASSEMBLYPROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitASSEMBLYPROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type STUFFContext struct { + Built_in_functionsContext + str IExpressionContext + from IExpressionContext + to IExpressionContext + str_with IExpressionContext +} + +func NewSTUFFContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *STUFFContext { + var p = new(STUFFContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *STUFFContext) GetStr() IExpressionContext { return s.str } + +func (s *STUFFContext) GetFrom() IExpressionContext { return s.from } + +func (s *STUFFContext) GetTo() IExpressionContext { return s.to } + +func (s *STUFFContext) GetStr_with() IExpressionContext { return s.str_with } + +func (s *STUFFContext) SetStr(v IExpressionContext) { s.str = v } + +func (s *STUFFContext) SetFrom(v IExpressionContext) { s.from = v } + +func (s *STUFFContext) SetTo(v IExpressionContext) { s.to = v } + +func (s *STUFFContext) SetStr_with(v IExpressionContext) { s.str_with = v } + +func (s *STUFFContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *STUFFContext) STUFF() antlr.TerminalNode { + return s.GetToken(TSqlParserSTUFF, 0) +} + +func (s *STUFFContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *STUFFContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *STUFFContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *STUFFContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *STUFFContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *STUFFContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *STUFFContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSTUFF(s) + } +} + +func (s *STUFFContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSTUFF(s) + } +} + +func (s *STUFFContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSTUFF(s) + + default: + return t.VisitChildren(s) + } +} + +type IS_ROLEMEMBERContext struct { + Built_in_functionsContext + role IExpressionContext + database_principal IExpressionContext +} + +func NewIS_ROLEMEMBERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IS_ROLEMEMBERContext { + var p = new(IS_ROLEMEMBERContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *IS_ROLEMEMBERContext) GetRole() IExpressionContext { return s.role } + +func (s *IS_ROLEMEMBERContext) GetDatabase_principal() IExpressionContext { + return s.database_principal +} + +func (s *IS_ROLEMEMBERContext) SetRole(v IExpressionContext) { s.role = v } + +func (s *IS_ROLEMEMBERContext) SetDatabase_principal(v IExpressionContext) { s.database_principal = v } + +func (s *IS_ROLEMEMBERContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IS_ROLEMEMBERContext) IS_ROLEMEMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserIS_ROLEMEMBER, 0) +} + +func (s *IS_ROLEMEMBERContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *IS_ROLEMEMBERContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *IS_ROLEMEMBERContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *IS_ROLEMEMBERContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *IS_ROLEMEMBERContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *IS_ROLEMEMBERContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterIS_ROLEMEMBER(s) + } +} + +func (s *IS_ROLEMEMBERContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitIS_ROLEMEMBER(s) + } +} + +func (s *IS_ROLEMEMBERContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitIS_ROLEMEMBER(s) + + default: + return t.VisitChildren(s) + } +} + +type SQL_VARIANT_PROPERTYContext struct { + Built_in_functionsContext + expr IExpressionContext + property antlr.Token +} + +func NewSQL_VARIANT_PROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SQL_VARIANT_PROPERTYContext { + var p = new(SQL_VARIANT_PROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SQL_VARIANT_PROPERTYContext) GetProperty() antlr.Token { return s.property } + +func (s *SQL_VARIANT_PROPERTYContext) SetProperty(v antlr.Token) { s.property = v } + +func (s *SQL_VARIANT_PROPERTYContext) GetExpr() IExpressionContext { return s.expr } + +func (s *SQL_VARIANT_PROPERTYContext) SetExpr(v IExpressionContext) { s.expr = v } + +func (s *SQL_VARIANT_PROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SQL_VARIANT_PROPERTYContext) SQL_VARIANT_PROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserSQL_VARIANT_PROPERTY, 0) +} + +func (s *SQL_VARIANT_PROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SQL_VARIANT_PROPERTYContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *SQL_VARIANT_PROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SQL_VARIANT_PROPERTYContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SQL_VARIANT_PROPERTYContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *SQL_VARIANT_PROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSQL_VARIANT_PROPERTY(s) + } +} + +func (s *SQL_VARIANT_PROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSQL_VARIANT_PROPERTY(s) + } +} + +func (s *SQL_VARIANT_PROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSQL_VARIANT_PROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type GREATESTContext struct { + Built_in_functionsContext +} + +func NewGREATESTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GREATESTContext { + var p = new(GREATESTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *GREATESTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GREATESTContext) GREATEST() antlr.TerminalNode { + return s.GetToken(TSqlParserGREATEST, 0) +} + +func (s *GREATESTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *GREATESTContext) Expression_list_() IExpression_list_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_list_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_list_Context) +} + +func (s *GREATESTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *GREATESTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterGREATEST(s) + } +} + +func (s *GREATESTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitGREATEST(s) + } +} + +func (s *GREATESTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitGREATEST(s) + + default: + return t.VisitChildren(s) + } +} + +type GETUTCDATEContext struct { + Built_in_functionsContext +} + +func NewGETUTCDATEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GETUTCDATEContext { + var p = new(GETUTCDATEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *GETUTCDATEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GETUTCDATEContext) GETUTCDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserGETUTCDATE, 0) +} + +func (s *GETUTCDATEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *GETUTCDATEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *GETUTCDATEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterGETUTCDATE(s) + } +} + +func (s *GETUTCDATEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitGETUTCDATE(s) + } +} + +func (s *GETUTCDATEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitGETUTCDATE(s) + + default: + return t.VisitChildren(s) + } +} + +type LOGINPROPERTYContext struct { + Built_in_functionsContext + login_name IExpressionContext + property_name IExpressionContext +} + +func NewLOGINPROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LOGINPROPERTYContext { + var p = new(LOGINPROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *LOGINPROPERTYContext) GetLogin_name() IExpressionContext { return s.login_name } + +func (s *LOGINPROPERTYContext) GetProperty_name() IExpressionContext { return s.property_name } + +func (s *LOGINPROPERTYContext) SetLogin_name(v IExpressionContext) { s.login_name = v } + +func (s *LOGINPROPERTYContext) SetProperty_name(v IExpressionContext) { s.property_name = v } + +func (s *LOGINPROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LOGINPROPERTYContext) LOGINPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGINPROPERTY, 0) +} + +func (s *LOGINPROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *LOGINPROPERTYContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *LOGINPROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *LOGINPROPERTYContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *LOGINPROPERTYContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *LOGINPROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterLOGINPROPERTY(s) + } +} + +func (s *LOGINPROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitLOGINPROPERTY(s) + } +} + +func (s *LOGINPROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitLOGINPROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type CONCAT_WSContext struct { + Built_in_functionsContext + separator IExpressionContext + argument_1 IExpressionContext + argument_2 IExpressionContext + _expression IExpressionContext + argument_n []IExpressionContext +} + +func NewCONCAT_WSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CONCAT_WSContext { + var p = new(CONCAT_WSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CONCAT_WSContext) GetSeparator() IExpressionContext { return s.separator } + +func (s *CONCAT_WSContext) GetArgument_1() IExpressionContext { return s.argument_1 } + +func (s *CONCAT_WSContext) GetArgument_2() IExpressionContext { return s.argument_2 } + +func (s *CONCAT_WSContext) Get_expression() IExpressionContext { return s._expression } + +func (s *CONCAT_WSContext) SetSeparator(v IExpressionContext) { s.separator = v } + +func (s *CONCAT_WSContext) SetArgument_1(v IExpressionContext) { s.argument_1 = v } + +func (s *CONCAT_WSContext) SetArgument_2(v IExpressionContext) { s.argument_2 = v } + +func (s *CONCAT_WSContext) Set_expression(v IExpressionContext) { s._expression = v } + +func (s *CONCAT_WSContext) GetArgument_n() []IExpressionContext { return s.argument_n } + +func (s *CONCAT_WSContext) SetArgument_n(v []IExpressionContext) { s.argument_n = v } + +func (s *CONCAT_WSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CONCAT_WSContext) CONCAT_WS() antlr.TerminalNode { + return s.GetToken(TSqlParserCONCAT_WS, 0) +} + +func (s *CONCAT_WSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CONCAT_WSContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *CONCAT_WSContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *CONCAT_WSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CONCAT_WSContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *CONCAT_WSContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CONCAT_WSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCONCAT_WS(s) + } +} + +func (s *CONCAT_WSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCONCAT_WS(s) + } +} + +func (s *CONCAT_WSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCONCAT_WS(s) + + default: + return t.VisitChildren(s) + } +} + +type ERROR_STATEContext struct { + Built_in_functionsContext +} + +func NewERROR_STATEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ERROR_STATEContext { + var p = new(ERROR_STATEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ERROR_STATEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ERROR_STATEContext) ERROR_STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_STATE, 0) +} + +func (s *ERROR_STATEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ERROR_STATEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ERROR_STATEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterERROR_STATE(s) + } +} + +func (s *ERROR_STATEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitERROR_STATE(s) + } +} + +func (s *ERROR_STATEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitERROR_STATE(s) + + default: + return t.VisitChildren(s) + } +} + +type DAYContext struct { + Built_in_functionsContext + date IExpressionContext +} + +func NewDAYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DAYContext { + var p = new(DAYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DAYContext) GetDate() IExpressionContext { return s.date } + +func (s *DAYContext) SetDate(v IExpressionContext) { s.date = v } + +func (s *DAYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DAYContext) DAY() antlr.TerminalNode { + return s.GetToken(TSqlParserDAY, 0) +} + +func (s *DAYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DAYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DAYContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DAYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDAY(s) + } +} + +func (s *DAYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDAY(s) + } +} + +func (s *DAYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDAY(s) + + default: + return t.VisitChildren(s) + } +} + +type PARSENAMEContext struct { + Built_in_functionsContext + object_name IExpressionContext + object_piece IExpressionContext +} + +func NewPARSENAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PARSENAMEContext { + var p = new(PARSENAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *PARSENAMEContext) GetObject_name() IExpressionContext { return s.object_name } + +func (s *PARSENAMEContext) GetObject_piece() IExpressionContext { return s.object_piece } + +func (s *PARSENAMEContext) SetObject_name(v IExpressionContext) { s.object_name = v } + +func (s *PARSENAMEContext) SetObject_piece(v IExpressionContext) { s.object_piece = v } + +func (s *PARSENAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PARSENAMEContext) PARSENAME() antlr.TerminalNode { + return s.GetToken(TSqlParserPARSENAME, 0) +} + +func (s *PARSENAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *PARSENAMEContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *PARSENAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *PARSENAMEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *PARSENAMEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PARSENAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPARSENAME(s) + } +} + +func (s *PARSENAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPARSENAME(s) + } +} + +func (s *PARSENAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPARSENAME(s) + + default: + return t.VisitChildren(s) + } +} + +type TANContext struct { + Built_in_functionsContext + float_expression IExpressionContext +} + +func NewTANContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TANContext { + var p = new(TANContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *TANContext) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *TANContext) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *TANContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TANContext) TAN() antlr.TerminalNode { + return s.GetToken(TSqlParserTAN, 0) +} + +func (s *TANContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *TANContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *TANContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *TANContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTAN(s) + } +} + +func (s *TANContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTAN(s) + } +} + +func (s *TANContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTAN(s) + + default: + return t.VisitChildren(s) + } +} + +type CURRENT_USERContext struct { + Built_in_functionsContext +} + +func NewCURRENT_USERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CURRENT_USERContext { + var p = new(CURRENT_USERContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CURRENT_USERContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CURRENT_USERContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT_USER, 0) +} + +func (s *CURRENT_USERContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCURRENT_USER(s) + } +} + +func (s *CURRENT_USERContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCURRENT_USER(s) + } +} + +func (s *CURRENT_USERContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCURRENT_USER(s) + + default: + return t.VisitChildren(s) + } +} + +type PERMISSIONSContext struct { + Built_in_functionsContext + object_id IExpressionContext + column IExpressionContext +} + +func NewPERMISSIONSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PERMISSIONSContext { + var p = new(PERMISSIONSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *PERMISSIONSContext) GetObject_id() IExpressionContext { return s.object_id } + +func (s *PERMISSIONSContext) GetColumn() IExpressionContext { return s.column } + +func (s *PERMISSIONSContext) SetObject_id(v IExpressionContext) { s.object_id = v } + +func (s *PERMISSIONSContext) SetColumn(v IExpressionContext) { s.column = v } + +func (s *PERMISSIONSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PERMISSIONSContext) PERMISSIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserPERMISSIONS, 0) +} + +func (s *PERMISSIONSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *PERMISSIONSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *PERMISSIONSContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *PERMISSIONSContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PERMISSIONSContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *PERMISSIONSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPERMISSIONS(s) + } +} + +func (s *PERMISSIONSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPERMISSIONS(s) + } +} + +func (s *PERMISSIONSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPERMISSIONS(s) + + default: + return t.VisitChildren(s) + } +} + +type SYSDATETIMEOFFSETContext struct { + Built_in_functionsContext +} + +func NewSYSDATETIMEOFFSETContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SYSDATETIMEOFFSETContext { + var p = new(SYSDATETIMEOFFSETContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SYSDATETIMEOFFSETContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SYSDATETIMEOFFSETContext) SYSDATETIMEOFFSET() antlr.TerminalNode { + return s.GetToken(TSqlParserSYSDATETIMEOFFSET, 0) +} + +func (s *SYSDATETIMEOFFSETContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SYSDATETIMEOFFSETContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SYSDATETIMEOFFSETContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSYSDATETIMEOFFSET(s) + } +} + +func (s *SYSDATETIMEOFFSETContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSYSDATETIMEOFFSET(s) + } +} + +func (s *SYSDATETIMEOFFSETContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSYSDATETIMEOFFSET(s) + + default: + return t.VisitChildren(s) + } +} + +type INDEXPROPERTYContext struct { + Built_in_functionsContext + object_id IExpressionContext + index_or_statistics_name IExpressionContext + property IExpressionContext +} + +func NewINDEXPROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *INDEXPROPERTYContext { + var p = new(INDEXPROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *INDEXPROPERTYContext) GetObject_id() IExpressionContext { return s.object_id } + +func (s *INDEXPROPERTYContext) GetIndex_or_statistics_name() IExpressionContext { + return s.index_or_statistics_name +} + +func (s *INDEXPROPERTYContext) GetProperty() IExpressionContext { return s.property } + +func (s *INDEXPROPERTYContext) SetObject_id(v IExpressionContext) { s.object_id = v } + +func (s *INDEXPROPERTYContext) SetIndex_or_statistics_name(v IExpressionContext) { + s.index_or_statistics_name = v +} + +func (s *INDEXPROPERTYContext) SetProperty(v IExpressionContext) { s.property = v } + +func (s *INDEXPROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *INDEXPROPERTYContext) INDEXPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEXPROPERTY, 0) +} + +func (s *INDEXPROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *INDEXPROPERTYContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *INDEXPROPERTYContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *INDEXPROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *INDEXPROPERTYContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *INDEXPROPERTYContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *INDEXPROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterINDEXPROPERTY(s) + } +} + +func (s *INDEXPROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitINDEXPROPERTY(s) + } +} + +func (s *INDEXPROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitINDEXPROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type OBJECTPROPERTYEXContext struct { + Built_in_functionsContext + id IExpressionContext + property IExpressionContext +} + +func NewOBJECTPROPERTYEXContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OBJECTPROPERTYEXContext { + var p = new(OBJECTPROPERTYEXContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *OBJECTPROPERTYEXContext) GetId() IExpressionContext { return s.id } + +func (s *OBJECTPROPERTYEXContext) GetProperty() IExpressionContext { return s.property } + +func (s *OBJECTPROPERTYEXContext) SetId(v IExpressionContext) { s.id = v } + +func (s *OBJECTPROPERTYEXContext) SetProperty(v IExpressionContext) { s.property = v } + +func (s *OBJECTPROPERTYEXContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OBJECTPROPERTYEXContext) OBJECTPROPERTYEX() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECTPROPERTYEX, 0) +} + +func (s *OBJECTPROPERTYEXContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *OBJECTPROPERTYEXContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *OBJECTPROPERTYEXContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *OBJECTPROPERTYEXContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *OBJECTPROPERTYEXContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *OBJECTPROPERTYEXContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOBJECTPROPERTYEX(s) + } +} + +func (s *OBJECTPROPERTYEXContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOBJECTPROPERTYEX(s) + } +} + +func (s *OBJECTPROPERTYEXContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOBJECTPROPERTYEX(s) + + default: + return t.VisitChildren(s) + } +} + +type SUBSTRINGContext struct { + Built_in_functionsContext + string_expression IExpressionContext + start_ IExpressionContext + length IExpressionContext +} + +func NewSUBSTRINGContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SUBSTRINGContext { + var p = new(SUBSTRINGContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SUBSTRINGContext) GetString_expression() IExpressionContext { return s.string_expression } + +func (s *SUBSTRINGContext) GetStart_() IExpressionContext { return s.start_ } + +func (s *SUBSTRINGContext) GetLength() IExpressionContext { return s.length } + +func (s *SUBSTRINGContext) SetString_expression(v IExpressionContext) { s.string_expression = v } + +func (s *SUBSTRINGContext) SetStart_(v IExpressionContext) { s.start_ = v } + +func (s *SUBSTRINGContext) SetLength(v IExpressionContext) { s.length = v } + +func (s *SUBSTRINGContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SUBSTRINGContext) SUBSTRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSUBSTRING, 0) +} + +func (s *SUBSTRINGContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SUBSTRINGContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *SUBSTRINGContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *SUBSTRINGContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SUBSTRINGContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *SUBSTRINGContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SUBSTRINGContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSUBSTRING(s) + } +} + +func (s *SUBSTRINGContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSUBSTRING(s) + } +} + +func (s *SUBSTRINGContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSUBSTRING(s) + + default: + return t.VisitChildren(s) + } +} + +type BINARY_CHECKSUMContext struct { + Built_in_functionsContext + star antlr.Token +} + +func NewBINARY_CHECKSUMContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BINARY_CHECKSUMContext { + var p = new(BINARY_CHECKSUMContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *BINARY_CHECKSUMContext) GetStar() antlr.Token { return s.star } + +func (s *BINARY_CHECKSUMContext) SetStar(v antlr.Token) { s.star = v } + +func (s *BINARY_CHECKSUMContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BINARY_CHECKSUMContext) BINARY_CHECKSUM() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY_CHECKSUM, 0) +} + +func (s *BINARY_CHECKSUMContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *BINARY_CHECKSUMContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *BINARY_CHECKSUMContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *BINARY_CHECKSUMContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *BINARY_CHECKSUMContext) STAR() antlr.TerminalNode { + return s.GetToken(TSqlParserSTAR, 0) +} + +func (s *BINARY_CHECKSUMContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *BINARY_CHECKSUMContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *BINARY_CHECKSUMContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBINARY_CHECKSUM(s) + } +} + +func (s *BINARY_CHECKSUMContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBINARY_CHECKSUM(s) + } +} + +func (s *BINARY_CHECKSUMContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBINARY_CHECKSUM(s) + + default: + return t.VisitChildren(s) + } +} + +type INDEXKEY_PROPERTYContext struct { + Built_in_functionsContext + object_id IExpressionContext + index_id IExpressionContext + key_id IExpressionContext + property IExpressionContext +} + +func NewINDEXKEY_PROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *INDEXKEY_PROPERTYContext { + var p = new(INDEXKEY_PROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *INDEXKEY_PROPERTYContext) GetObject_id() IExpressionContext { return s.object_id } + +func (s *INDEXKEY_PROPERTYContext) GetIndex_id() IExpressionContext { return s.index_id } + +func (s *INDEXKEY_PROPERTYContext) GetKey_id() IExpressionContext { return s.key_id } + +func (s *INDEXKEY_PROPERTYContext) GetProperty() IExpressionContext { return s.property } + +func (s *INDEXKEY_PROPERTYContext) SetObject_id(v IExpressionContext) { s.object_id = v } + +func (s *INDEXKEY_PROPERTYContext) SetIndex_id(v IExpressionContext) { s.index_id = v } + +func (s *INDEXKEY_PROPERTYContext) SetKey_id(v IExpressionContext) { s.key_id = v } + +func (s *INDEXKEY_PROPERTYContext) SetProperty(v IExpressionContext) { s.property = v } + +func (s *INDEXKEY_PROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *INDEXKEY_PROPERTYContext) INDEXKEY_PROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEXKEY_PROPERTY, 0) +} + +func (s *INDEXKEY_PROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *INDEXKEY_PROPERTYContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *INDEXKEY_PROPERTYContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *INDEXKEY_PROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *INDEXKEY_PROPERTYContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *INDEXKEY_PROPERTYContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *INDEXKEY_PROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterINDEXKEY_PROPERTY(s) + } +} + +func (s *INDEXKEY_PROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitINDEXKEY_PROPERTY(s) + } +} + +func (s *INDEXKEY_PROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitINDEXKEY_PROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type PWDENCRYPTContext struct { + Built_in_functionsContext + password IExpressionContext +} + +func NewPWDENCRYPTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PWDENCRYPTContext { + var p = new(PWDENCRYPTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *PWDENCRYPTContext) GetPassword() IExpressionContext { return s.password } + +func (s *PWDENCRYPTContext) SetPassword(v IExpressionContext) { s.password = v } + +func (s *PWDENCRYPTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PWDENCRYPTContext) PWDENCRYPT() antlr.TerminalNode { + return s.GetToken(TSqlParserPWDENCRYPT, 0) +} + +func (s *PWDENCRYPTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *PWDENCRYPTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *PWDENCRYPTContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *PWDENCRYPTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPWDENCRYPT(s) + } +} + +func (s *PWDENCRYPTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPWDENCRYPT(s) + } +} + +func (s *PWDENCRYPTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPWDENCRYPT(s) + + default: + return t.VisitChildren(s) + } +} + +type COMPRESSContext struct { + Built_in_functionsContext + expr IExpressionContext +} + +func NewCOMPRESSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *COMPRESSContext { + var p = new(COMPRESSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *COMPRESSContext) GetExpr() IExpressionContext { return s.expr } + +func (s *COMPRESSContext) SetExpr(v IExpressionContext) { s.expr = v } + +func (s *COMPRESSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *COMPRESSContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPRESS, 0) +} + +func (s *COMPRESSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *COMPRESSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *COMPRESSContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *COMPRESSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCOMPRESS(s) + } +} + +func (s *COMPRESSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCOMPRESS(s) + } +} + +func (s *COMPRESSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCOMPRESS(s) + + default: + return t.VisitChildren(s) + } +} + +type COALESCEContext struct { + Built_in_functionsContext +} + +func NewCOALESCEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *COALESCEContext { + var p = new(COALESCEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *COALESCEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *COALESCEContext) COALESCE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOALESCE, 0) +} + +func (s *COALESCEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *COALESCEContext) Expression_list_() IExpression_list_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_list_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_list_Context) +} + +func (s *COALESCEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *COALESCEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCOALESCE(s) + } +} + +func (s *COALESCEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCOALESCE(s) + } +} + +func (s *COALESCEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCOALESCE(s) + + default: + return t.VisitChildren(s) + } +} + +type STATS_DATEContext struct { + Built_in_functionsContext + object_id IExpressionContext + stats_id IExpressionContext +} + +func NewSTATS_DATEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *STATS_DATEContext { + var p = new(STATS_DATEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *STATS_DATEContext) GetObject_id() IExpressionContext { return s.object_id } + +func (s *STATS_DATEContext) GetStats_id() IExpressionContext { return s.stats_id } + +func (s *STATS_DATEContext) SetObject_id(v IExpressionContext) { s.object_id = v } + +func (s *STATS_DATEContext) SetStats_id(v IExpressionContext) { s.stats_id = v } + +func (s *STATS_DATEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *STATS_DATEContext) STATS_DATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATS_DATE, 0) +} + +func (s *STATS_DATEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *STATS_DATEContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *STATS_DATEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *STATS_DATEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *STATS_DATEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *STATS_DATEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSTATS_DATE(s) + } +} + +func (s *STATS_DATEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSTATS_DATE(s) + } +} + +func (s *STATS_DATEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSTATS_DATE(s) + + default: + return t.VisitChildren(s) + } +} + +type ISNUMERICContext struct { + Built_in_functionsContext +} + +func NewISNUMERICContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ISNUMERICContext { + var p = new(ISNUMERICContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ISNUMERICContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ISNUMERICContext) ISNUMERIC() antlr.TerminalNode { + return s.GetToken(TSqlParserISNUMERIC, 0) +} + +func (s *ISNUMERICContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ISNUMERICContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ISNUMERICContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ISNUMERICContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterISNUMERIC(s) + } +} + +func (s *ISNUMERICContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitISNUMERIC(s) + } +} + +func (s *ISNUMERICContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitISNUMERIC(s) + + default: + return t.VisitChildren(s) + } +} + +type ACOSContext struct { + Built_in_functionsContext + float_expression IExpressionContext +} + +func NewACOSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACOSContext { + var p = new(ACOSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ACOSContext) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *ACOSContext) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *ACOSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ACOSContext) ACOS() antlr.TerminalNode { + return s.GetToken(TSqlParserACOS, 0) +} + +func (s *ACOSContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ACOSContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ACOSContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ACOSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterACOS(s) + } +} + +func (s *ACOSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitACOS(s) + } +} + +func (s *ACOSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitACOS(s) + + default: + return t.VisitChildren(s) + } +} + +type FILEGROUP_NAMEContext struct { + Built_in_functionsContext + filegroup_id IExpressionContext +} + +func NewFILEGROUP_NAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FILEGROUP_NAMEContext { + var p = new(FILEGROUP_NAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FILEGROUP_NAMEContext) GetFilegroup_id() IExpressionContext { return s.filegroup_id } + +func (s *FILEGROUP_NAMEContext) SetFilegroup_id(v IExpressionContext) { s.filegroup_id = v } + +func (s *FILEGROUP_NAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FILEGROUP_NAMEContext) FILEGROUP_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROUP_NAME, 0) +} + +func (s *FILEGROUP_NAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FILEGROUP_NAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FILEGROUP_NAMEContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FILEGROUP_NAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFILEGROUP_NAME(s) + } +} + +func (s *FILEGROUP_NAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFILEGROUP_NAME(s) + } +} + +func (s *FILEGROUP_NAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFILEGROUP_NAME(s) + + default: + return t.VisitChildren(s) + } +} + +type COLUMNPROPERTYContext struct { + Built_in_functionsContext + id IExpressionContext + column IExpressionContext + property IExpressionContext +} + +func NewCOLUMNPROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *COLUMNPROPERTYContext { + var p = new(COLUMNPROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *COLUMNPROPERTYContext) GetId() IExpressionContext { return s.id } + +func (s *COLUMNPROPERTYContext) GetColumn() IExpressionContext { return s.column } + +func (s *COLUMNPROPERTYContext) GetProperty() IExpressionContext { return s.property } + +func (s *COLUMNPROPERTYContext) SetId(v IExpressionContext) { s.id = v } + +func (s *COLUMNPROPERTYContext) SetColumn(v IExpressionContext) { s.column = v } + +func (s *COLUMNPROPERTYContext) SetProperty(v IExpressionContext) { s.property = v } + +func (s *COLUMNPROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *COLUMNPROPERTYContext) COLUMNPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNPROPERTY, 0) +} + +func (s *COLUMNPROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *COLUMNPROPERTYContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *COLUMNPROPERTYContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *COLUMNPROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *COLUMNPROPERTYContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *COLUMNPROPERTYContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *COLUMNPROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCOLUMNPROPERTY(s) + } +} + +func (s *COLUMNPROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCOLUMNPROPERTY(s) + } +} + +func (s *COLUMNPROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCOLUMNPROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type DB_IDContext struct { + Built_in_functionsContext + database_name IExpressionContext +} + +func NewDB_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DB_IDContext { + var p = new(DB_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DB_IDContext) GetDatabase_name() IExpressionContext { return s.database_name } + +func (s *DB_IDContext) SetDatabase_name(v IExpressionContext) { s.database_name = v } + +func (s *DB_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DB_IDContext) DB_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserDB_ID, 0) +} + +func (s *DB_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DB_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DB_IDContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DB_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDB_ID(s) + } +} + +func (s *DB_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDB_ID(s) + } +} + +func (s *DB_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDB_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type SOUNDEXContext struct { + Built_in_functionsContext + character_expression IExpressionContext +} + +func NewSOUNDEXContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SOUNDEXContext { + var p = new(SOUNDEXContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SOUNDEXContext) GetCharacter_expression() IExpressionContext { return s.character_expression } + +func (s *SOUNDEXContext) SetCharacter_expression(v IExpressionContext) { s.character_expression = v } + +func (s *SOUNDEXContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SOUNDEXContext) SOUNDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserSOUNDEX, 0) +} + +func (s *SOUNDEXContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SOUNDEXContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SOUNDEXContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SOUNDEXContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSOUNDEX(s) + } +} + +func (s *SOUNDEXContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSOUNDEX(s) + } +} + +func (s *SOUNDEXContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSOUNDEX(s) + + default: + return t.VisitChildren(s) + } +} + +type CURSOR_ROWSContext struct { + Built_in_functionsContext +} + +func NewCURSOR_ROWSContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CURSOR_ROWSContext { + var p = new(CURSOR_ROWSContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CURSOR_ROWSContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CURSOR_ROWSContext) CURSOR_ROWS() antlr.TerminalNode { + return s.GetToken(TSqlParserCURSOR_ROWS, 0) +} + +func (s *CURSOR_ROWSContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCURSOR_ROWS(s) + } +} + +func (s *CURSOR_ROWSContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCURSOR_ROWS(s) + } +} + +func (s *CURSOR_ROWSContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCURSOR_ROWS(s) + + default: + return t.VisitChildren(s) + } +} + +type FULLTEXTCATALOGPROPERTYContext struct { + Built_in_functionsContext + catalog_name IExpressionContext + property IExpressionContext +} + +func NewFULLTEXTCATALOGPROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FULLTEXTCATALOGPROPERTYContext { + var p = new(FULLTEXTCATALOGPROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FULLTEXTCATALOGPROPERTYContext) GetCatalog_name() IExpressionContext { return s.catalog_name } + +func (s *FULLTEXTCATALOGPROPERTYContext) GetProperty() IExpressionContext { return s.property } + +func (s *FULLTEXTCATALOGPROPERTYContext) SetCatalog_name(v IExpressionContext) { s.catalog_name = v } + +func (s *FULLTEXTCATALOGPROPERTYContext) SetProperty(v IExpressionContext) { s.property = v } + +func (s *FULLTEXTCATALOGPROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FULLTEXTCATALOGPROPERTYContext) FULLTEXTCATALOGPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXTCATALOGPROPERTY, 0) +} + +func (s *FULLTEXTCATALOGPROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FULLTEXTCATALOGPROPERTYContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *FULLTEXTCATALOGPROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FULLTEXTCATALOGPROPERTYContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *FULLTEXTCATALOGPROPERTYContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FULLTEXTCATALOGPROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFULLTEXTCATALOGPROPERTY(s) + } +} + +func (s *FULLTEXTCATALOGPROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFULLTEXTCATALOGPROPERTY(s) + } +} + +func (s *FULLTEXTCATALOGPROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFULLTEXTCATALOGPROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type TYPEPROPERTYContext struct { + Built_in_functionsContext + type_ IExpressionContext + property IExpressionContext +} + +func NewTYPEPROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TYPEPROPERTYContext { + var p = new(TYPEPROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *TYPEPROPERTYContext) GetType_() IExpressionContext { return s.type_ } + +func (s *TYPEPROPERTYContext) GetProperty() IExpressionContext { return s.property } + +func (s *TYPEPROPERTYContext) SetType_(v IExpressionContext) { s.type_ = v } + +func (s *TYPEPROPERTYContext) SetProperty(v IExpressionContext) { s.property = v } + +func (s *TYPEPROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TYPEPROPERTYContext) TYPEPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPEPROPERTY, 0) +} + +func (s *TYPEPROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *TYPEPROPERTYContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *TYPEPROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *TYPEPROPERTYContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *TYPEPROPERTYContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *TYPEPROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTYPEPROPERTY(s) + } +} + +func (s *TYPEPROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTYPEPROPERTY(s) + } +} + +func (s *TYPEPROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTYPEPROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type SCHEMA_NAMEContext struct { + Built_in_functionsContext + schema_id IExpressionContext +} + +func NewSCHEMA_NAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SCHEMA_NAMEContext { + var p = new(SCHEMA_NAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SCHEMA_NAMEContext) GetSchema_id() IExpressionContext { return s.schema_id } + +func (s *SCHEMA_NAMEContext) SetSchema_id(v IExpressionContext) { s.schema_id = v } + +func (s *SCHEMA_NAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SCHEMA_NAMEContext) SCHEMA_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA_NAME, 0) +} + +func (s *SCHEMA_NAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SCHEMA_NAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SCHEMA_NAMEContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SCHEMA_NAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSCHEMA_NAME(s) + } +} + +func (s *SCHEMA_NAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSCHEMA_NAME(s) + } +} + +func (s *SCHEMA_NAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSCHEMA_NAME(s) + + default: + return t.VisitChildren(s) + } +} + +type TYPE_IDContext struct { + Built_in_functionsContext + type_name IExpressionContext +} + +func NewTYPE_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TYPE_IDContext { + var p = new(TYPE_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *TYPE_IDContext) GetType_name() IExpressionContext { return s.type_name } + +func (s *TYPE_IDContext) SetType_name(v IExpressionContext) { s.type_name = v } + +func (s *TYPE_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TYPE_IDContext) TYPE_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE_ID, 0) +} + +func (s *TYPE_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *TYPE_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *TYPE_IDContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *TYPE_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTYPE_ID(s) + } +} + +func (s *TYPE_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTYPE_ID(s) + } +} + +func (s *TYPE_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTYPE_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type TRY_CASTContext struct { + Built_in_functionsContext +} + +func NewTRY_CASTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TRY_CASTContext { + var p = new(TRY_CASTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *TRY_CASTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TRY_CASTContext) TRY_CAST() antlr.TerminalNode { + return s.GetToken(TSqlParserTRY_CAST, 0) +} + +func (s *TRY_CASTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *TRY_CASTContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *TRY_CASTContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *TRY_CASTContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *TRY_CASTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *TRY_CASTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTRY_CAST(s) + } +} + +func (s *TRY_CASTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTRY_CAST(s) + } +} + +func (s *TRY_CASTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTRY_CAST(s) + + default: + return t.VisitChildren(s) + } +} + +type APPLOCK_MODEContext struct { + Built_in_functionsContext + database_principal IExpressionContext + resource_name IExpressionContext + lock_owner IExpressionContext +} + +func NewAPPLOCK_MODEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *APPLOCK_MODEContext { + var p = new(APPLOCK_MODEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *APPLOCK_MODEContext) GetDatabase_principal() IExpressionContext { return s.database_principal } + +func (s *APPLOCK_MODEContext) GetResource_name() IExpressionContext { return s.resource_name } + +func (s *APPLOCK_MODEContext) GetLock_owner() IExpressionContext { return s.lock_owner } + +func (s *APPLOCK_MODEContext) SetDatabase_principal(v IExpressionContext) { s.database_principal = v } + +func (s *APPLOCK_MODEContext) SetResource_name(v IExpressionContext) { s.resource_name = v } + +func (s *APPLOCK_MODEContext) SetLock_owner(v IExpressionContext) { s.lock_owner = v } + +func (s *APPLOCK_MODEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *APPLOCK_MODEContext) APPLOCK_MODE() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLOCK_MODE, 0) +} + +func (s *APPLOCK_MODEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *APPLOCK_MODEContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *APPLOCK_MODEContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *APPLOCK_MODEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *APPLOCK_MODEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *APPLOCK_MODEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *APPLOCK_MODEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAPPLOCK_MODE(s) + } +} + +func (s *APPLOCK_MODEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAPPLOCK_MODE(s) + } +} + +func (s *APPLOCK_MODEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAPPLOCK_MODE(s) + + default: + return t.VisitChildren(s) + } +} + +type CURRENT_DATEContext struct { + Built_in_functionsContext +} + +func NewCURRENT_DATEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CURRENT_DATEContext { + var p = new(CURRENT_DATEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CURRENT_DATEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CURRENT_DATEContext) CURRENT_DATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT_DATE, 0) +} + +func (s *CURRENT_DATEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CURRENT_DATEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CURRENT_DATEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCURRENT_DATE(s) + } +} + +func (s *CURRENT_DATEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCURRENT_DATE(s) + } +} + +func (s *CURRENT_DATEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCURRENT_DATE(s) + + default: + return t.VisitChildren(s) + } +} + +type GETDATEContext struct { + Built_in_functionsContext +} + +func NewGETDATEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GETDATEContext { + var p = new(GETDATEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *GETDATEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GETDATEContext) GETDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserGETDATE, 0) +} + +func (s *GETDATEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *GETDATEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *GETDATEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterGETDATE(s) + } +} + +func (s *GETDATEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitGETDATE(s) + } +} + +func (s *GETDATEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitGETDATE(s) + + default: + return t.VisitChildren(s) + } +} + +type CERT_IDContext struct { + Built_in_functionsContext + cert_name IExpressionContext +} + +func NewCERT_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CERT_IDContext { + var p = new(CERT_IDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CERT_IDContext) GetCert_name() IExpressionContext { return s.cert_name } + +func (s *CERT_IDContext) SetCert_name(v IExpressionContext) { s.cert_name = v } + +func (s *CERT_IDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CERT_IDContext) CERT_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserCERT_ID, 0) +} + +func (s *CERT_IDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CERT_IDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CERT_IDContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CERT_IDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCERT_ID(s) + } +} + +func (s *CERT_IDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCERT_ID(s) + } +} + +func (s *CERT_IDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCERT_ID(s) + + default: + return t.VisitChildren(s) + } +} + +type ATANContext struct { + Built_in_functionsContext + float_expression IExpressionContext +} + +func NewATANContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ATANContext { + var p = new(ATANContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ATANContext) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *ATANContext) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *ATANContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ATANContext) ATAN() antlr.TerminalNode { + return s.GetToken(TSqlParserATAN, 0) +} + +func (s *ATANContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ATANContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ATANContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ATANContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterATAN(s) + } +} + +func (s *ATANContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitATAN(s) + } +} + +func (s *ATANContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitATAN(s) + + default: + return t.VisitChildren(s) + } +} + +type CONNECTIONPROPERTYContext struct { + Built_in_functionsContext + property antlr.Token +} + +func NewCONNECTIONPROPERTYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CONNECTIONPROPERTYContext { + var p = new(CONNECTIONPROPERTYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CONNECTIONPROPERTYContext) GetProperty() antlr.Token { return s.property } + +func (s *CONNECTIONPROPERTYContext) SetProperty(v antlr.Token) { s.property = v } + +func (s *CONNECTIONPROPERTYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CONNECTIONPROPERTYContext) CONNECTIONPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserCONNECTIONPROPERTY, 0) +} + +func (s *CONNECTIONPROPERTYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CONNECTIONPROPERTYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CONNECTIONPROPERTYContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *CONNECTIONPROPERTYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCONNECTIONPROPERTY(s) + } +} + +func (s *CONNECTIONPROPERTYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCONNECTIONPROPERTY(s) + } +} + +func (s *CONNECTIONPROPERTYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCONNECTIONPROPERTY(s) + + default: + return t.VisitChildren(s) + } +} + +type ERROR_NUMBERContext struct { + Built_in_functionsContext +} + +func NewERROR_NUMBERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ERROR_NUMBERContext { + var p = new(ERROR_NUMBERContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ERROR_NUMBERContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ERROR_NUMBERContext) ERROR_NUMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_NUMBER, 0) +} + +func (s *ERROR_NUMBERContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ERROR_NUMBERContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ERROR_NUMBERContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterERROR_NUMBER(s) + } +} + +func (s *ERROR_NUMBERContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitERROR_NUMBER(s) + } +} + +func (s *ERROR_NUMBERContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitERROR_NUMBER(s) + + default: + return t.VisitChildren(s) + } +} + +type ERROR_LINEContext struct { + Built_in_functionsContext +} + +func NewERROR_LINEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ERROR_LINEContext { + var p = new(ERROR_LINEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ERROR_LINEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ERROR_LINEContext) ERROR_LINE() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_LINE, 0) +} + +func (s *ERROR_LINEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ERROR_LINEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ERROR_LINEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterERROR_LINE(s) + } +} + +func (s *ERROR_LINEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitERROR_LINE(s) + } +} + +func (s *ERROR_LINEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitERROR_LINE(s) + + default: + return t.VisitChildren(s) + } +} + +type CURRENT_TIMESTAMPContext struct { + Built_in_functionsContext +} + +func NewCURRENT_TIMESTAMPContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CURRENT_TIMESTAMPContext { + var p = new(CURRENT_TIMESTAMPContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CURRENT_TIMESTAMPContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CURRENT_TIMESTAMPContext) CURRENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT_TIMESTAMP, 0) +} + +func (s *CURRENT_TIMESTAMPContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCURRENT_TIMESTAMP(s) + } +} + +func (s *CURRENT_TIMESTAMPContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCURRENT_TIMESTAMP(s) + } +} + +func (s *CURRENT_TIMESTAMPContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCURRENT_TIMESTAMP(s) + + default: + return t.VisitChildren(s) + } +} + +type CONCATContext struct { + Built_in_functionsContext + string_value_1 IExpressionContext + string_value_2 IExpressionContext + _expression IExpressionContext + string_value_n []IExpressionContext +} + +func NewCONCATContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CONCATContext { + var p = new(CONCATContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *CONCATContext) GetString_value_1() IExpressionContext { return s.string_value_1 } + +func (s *CONCATContext) GetString_value_2() IExpressionContext { return s.string_value_2 } + +func (s *CONCATContext) Get_expression() IExpressionContext { return s._expression } + +func (s *CONCATContext) SetString_value_1(v IExpressionContext) { s.string_value_1 = v } + +func (s *CONCATContext) SetString_value_2(v IExpressionContext) { s.string_value_2 = v } + +func (s *CONCATContext) Set_expression(v IExpressionContext) { s._expression = v } + +func (s *CONCATContext) GetString_value_n() []IExpressionContext { return s.string_value_n } + +func (s *CONCATContext) SetString_value_n(v []IExpressionContext) { s.string_value_n = v } + +func (s *CONCATContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CONCATContext) CONCAT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONCAT, 0) +} + +func (s *CONCATContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *CONCATContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *CONCATContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *CONCATContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *CONCATContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *CONCATContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *CONCATContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCONCAT(s) + } +} + +func (s *CONCATContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCONCAT(s) + } +} + +func (s *CONCATContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCONCAT(s) + + default: + return t.VisitChildren(s) + } +} + +type JSON_ARRAYContext struct { + Built_in_functionsContext +} + +func NewJSON_ARRAYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSON_ARRAYContext { + var p = new(JSON_ARRAYContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *JSON_ARRAYContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JSON_ARRAYContext) JSON_ARRAY() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON_ARRAY, 0) +} + +func (s *JSON_ARRAYContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *JSON_ARRAYContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *JSON_ARRAYContext) Expression_list_() IExpression_list_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_list_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_list_Context) +} + +func (s *JSON_ARRAYContext) Json_null_clause() IJson_null_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_null_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_null_clauseContext) +} + +func (s *JSON_ARRAYContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterJSON_ARRAY(s) + } +} + +func (s *JSON_ARRAYContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitJSON_ARRAY(s) + } +} + +func (s *JSON_ARRAYContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitJSON_ARRAY(s) + + default: + return t.VisitChildren(s) + } +} + +type ROUNDContext struct { + Built_in_functionsContext + numeric_expression IExpressionContext + length IExpressionContext + function IExpressionContext +} + +func NewROUNDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ROUNDContext { + var p = new(ROUNDContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ROUNDContext) GetNumeric_expression() IExpressionContext { return s.numeric_expression } + +func (s *ROUNDContext) GetLength() IExpressionContext { return s.length } + +func (s *ROUNDContext) GetFunction() IExpressionContext { return s.function } + +func (s *ROUNDContext) SetNumeric_expression(v IExpressionContext) { s.numeric_expression = v } + +func (s *ROUNDContext) SetLength(v IExpressionContext) { s.length = v } + +func (s *ROUNDContext) SetFunction(v IExpressionContext) { s.function = v } + +func (s *ROUNDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ROUNDContext) ROUND() antlr.TerminalNode { + return s.GetToken(TSqlParserROUND, 0) +} + +func (s *ROUNDContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ROUNDContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *ROUNDContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *ROUNDContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ROUNDContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *ROUNDContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ROUNDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterROUND(s) + } +} + +func (s *ROUNDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitROUND(s) + } +} + +func (s *ROUNDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitROUND(s) + + default: + return t.VisitChildren(s) + } +} + +type DATALENGTHContext struct { + Built_in_functionsContext +} + +func NewDATALENGTHContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATALENGTHContext { + var p = new(DATALENGTHContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATALENGTHContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATALENGTHContext) DATALENGTH() antlr.TerminalNode { + return s.GetToken(TSqlParserDATALENGTH, 0) +} + +func (s *DATALENGTHContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATALENGTHContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATALENGTHContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATALENGTHContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATALENGTH(s) + } +} + +func (s *DATALENGTHContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATALENGTH(s) + } +} + +func (s *DATALENGTHContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATALENGTH(s) + + default: + return t.VisitChildren(s) + } +} + +type HOST_NAMEContext struct { + Built_in_functionsContext +} + +func NewHOST_NAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *HOST_NAMEContext { + var p = new(HOST_NAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *HOST_NAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HOST_NAMEContext) HOST_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserHOST_NAME, 0) +} + +func (s *HOST_NAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *HOST_NAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *HOST_NAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterHOST_NAME(s) + } +} + +func (s *HOST_NAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitHOST_NAME(s) + } +} + +func (s *HOST_NAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitHOST_NAME(s) + + default: + return t.VisitChildren(s) + } +} + +type DATABASEPROPERTYEXContext struct { + Built_in_functionsContext + database IExpressionContext + property IExpressionContext +} + +func NewDATABASEPROPERTYEXContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATABASEPROPERTYEXContext { + var p = new(DATABASEPROPERTYEXContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATABASEPROPERTYEXContext) GetDatabase() IExpressionContext { return s.database } + +func (s *DATABASEPROPERTYEXContext) GetProperty() IExpressionContext { return s.property } + +func (s *DATABASEPROPERTYEXContext) SetDatabase(v IExpressionContext) { s.database = v } + +func (s *DATABASEPROPERTYEXContext) SetProperty(v IExpressionContext) { s.property = v } + +func (s *DATABASEPROPERTYEXContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATABASEPROPERTYEXContext) DATABASEPROPERTYEX() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASEPROPERTYEX, 0) +} + +func (s *DATABASEPROPERTYEXContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATABASEPROPERTYEXContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *DATABASEPROPERTYEXContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATABASEPROPERTYEXContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *DATABASEPROPERTYEXContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATABASEPROPERTYEXContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATABASEPROPERTYEX(s) + } +} + +func (s *DATABASEPROPERTYEXContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATABASEPROPERTYEX(s) + } +} + +func (s *DATABASEPROPERTYEXContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATABASEPROPERTYEX(s) + + default: + return t.VisitChildren(s) + } +} + +type ORIGINAL_DB_NAMEContext struct { + Built_in_functionsContext +} + +func NewORIGINAL_DB_NAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ORIGINAL_DB_NAMEContext { + var p = new(ORIGINAL_DB_NAMEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *ORIGINAL_DB_NAMEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ORIGINAL_DB_NAMEContext) ORIGINAL_DB_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserORIGINAL_DB_NAME, 0) +} + +func (s *ORIGINAL_DB_NAMEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *ORIGINAL_DB_NAMEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *ORIGINAL_DB_NAMEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterORIGINAL_DB_NAME(s) + } +} + +func (s *ORIGINAL_DB_NAMEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitORIGINAL_DB_NAME(s) + } +} + +func (s *ORIGINAL_DB_NAMEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitORIGINAL_DB_NAME(s) + + default: + return t.VisitChildren(s) + } +} + +type FILEPROPERTYEXContext struct { + Built_in_functionsContext + name IExpressionContext + property IExpressionContext +} + +func NewFILEPROPERTYEXContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FILEPROPERTYEXContext { + var p = new(FILEPROPERTYEXContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FILEPROPERTYEXContext) GetName() IExpressionContext { return s.name } + +func (s *FILEPROPERTYEXContext) GetProperty() IExpressionContext { return s.property } + +func (s *FILEPROPERTYEXContext) SetName(v IExpressionContext) { s.name = v } + +func (s *FILEPROPERTYEXContext) SetProperty(v IExpressionContext) { s.property = v } + +func (s *FILEPROPERTYEXContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FILEPROPERTYEXContext) FILEPROPERTYEX() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEPROPERTYEX, 0) +} + +func (s *FILEPROPERTYEXContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FILEPROPERTYEXContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *FILEPROPERTYEXContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FILEPROPERTYEXContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *FILEPROPERTYEXContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FILEPROPERTYEXContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFILEPROPERTYEX(s) + } +} + +func (s *FILEPROPERTYEXContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFILEPROPERTYEX(s) + } +} + +func (s *FILEPROPERTYEXContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFILEPROPERTYEX(s) + + default: + return t.VisitChildren(s) + } +} + +type RTRIMContext struct { + Built_in_functionsContext + character_expression IExpressionContext +} + +func NewRTRIMContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RTRIMContext { + var p = new(RTRIMContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *RTRIMContext) GetCharacter_expression() IExpressionContext { return s.character_expression } + +func (s *RTRIMContext) SetCharacter_expression(v IExpressionContext) { s.character_expression = v } + +func (s *RTRIMContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RTRIMContext) RTRIM() antlr.TerminalNode { + return s.GetToken(TSqlParserRTRIM, 0) +} + +func (s *RTRIMContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *RTRIMContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *RTRIMContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *RTRIMContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRTRIM(s) + } +} + +func (s *RTRIMContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRTRIM(s) + } +} + +func (s *RTRIMContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRTRIM(s) + + default: + return t.VisitChildren(s) + } +} + +type JSON_OBJECTContext struct { + Built_in_functionsContext + key_value IJson_key_valueContext +} + +func NewJSON_OBJECTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *JSON_OBJECTContext { + var p = new(JSON_OBJECTContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *JSON_OBJECTContext) GetKey_value() IJson_key_valueContext { return s.key_value } + +func (s *JSON_OBJECTContext) SetKey_value(v IJson_key_valueContext) { s.key_value = v } + +func (s *JSON_OBJECTContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *JSON_OBJECTContext) JSON_OBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON_OBJECT, 0) +} + +func (s *JSON_OBJECTContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *JSON_OBJECTContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *JSON_OBJECTContext) Json_null_clause() IJson_null_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_null_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_null_clauseContext) +} + +func (s *JSON_OBJECTContext) AllJson_key_value() []IJson_key_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJson_key_valueContext); ok { + len++ + } + } + + tst := make([]IJson_key_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJson_key_valueContext); ok { + tst[i] = t.(IJson_key_valueContext) + i++ + } + } + + return tst +} + +func (s *JSON_OBJECTContext) Json_key_value(i int) IJson_key_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_key_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJson_key_valueContext) +} + +func (s *JSON_OBJECTContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *JSON_OBJECTContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *JSON_OBJECTContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterJSON_OBJECT(s) + } +} + +func (s *JSON_OBJECTContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitJSON_OBJECT(s) + } +} + +func (s *JSON_OBJECTContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitJSON_OBJECT(s) + + default: + return t.VisitChildren(s) + } +} + +type XACT_STATEContext struct { + Built_in_functionsContext +} + +func NewXACT_STATEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *XACT_STATEContext { + var p = new(XACT_STATEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *XACT_STATEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XACT_STATEContext) XACT_STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserXACT_STATE, 0) +} + +func (s *XACT_STATEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *XACT_STATEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *XACT_STATEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterXACT_STATE(s) + } +} + +func (s *XACT_STATEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitXACT_STATE(s) + } +} + +func (s *XACT_STATEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitXACT_STATE(s) + + default: + return t.VisitChildren(s) + } +} + +type FORMATMESSAGEContext struct { + Built_in_functionsContext + msg_number antlr.Token + msg_string antlr.Token + msg_variable antlr.Token +} + +func NewFORMATMESSAGEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *FORMATMESSAGEContext { + var p = new(FORMATMESSAGEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *FORMATMESSAGEContext) GetMsg_number() antlr.Token { return s.msg_number } + +func (s *FORMATMESSAGEContext) GetMsg_string() antlr.Token { return s.msg_string } + +func (s *FORMATMESSAGEContext) GetMsg_variable() antlr.Token { return s.msg_variable } + +func (s *FORMATMESSAGEContext) SetMsg_number(v antlr.Token) { s.msg_number = v } + +func (s *FORMATMESSAGEContext) SetMsg_string(v antlr.Token) { s.msg_string = v } + +func (s *FORMATMESSAGEContext) SetMsg_variable(v antlr.Token) { s.msg_variable = v } + +func (s *FORMATMESSAGEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FORMATMESSAGEContext) FORMATMESSAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserFORMATMESSAGE, 0) +} + +func (s *FORMATMESSAGEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *FORMATMESSAGEContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *FORMATMESSAGEContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *FORMATMESSAGEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *FORMATMESSAGEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *FORMATMESSAGEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *FORMATMESSAGEContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *FORMATMESSAGEContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *FORMATMESSAGEContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *FORMATMESSAGEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFORMATMESSAGE(s) + } +} + +func (s *FORMATMESSAGEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFORMATMESSAGE(s) + } +} + +func (s *FORMATMESSAGEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFORMATMESSAGE(s) + + default: + return t.VisitChildren(s) + } +} + +type DATEDIFF_BIGContext struct { + Built_in_functionsContext + datepart IDateparts_12Context + startdate IExpressionContext + enddate IExpressionContext +} + +func NewDATEDIFF_BIGContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATEDIFF_BIGContext { + var p = new(DATEDIFF_BIGContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATEDIFF_BIGContext) GetDatepart() IDateparts_12Context { return s.datepart } + +func (s *DATEDIFF_BIGContext) GetStartdate() IExpressionContext { return s.startdate } + +func (s *DATEDIFF_BIGContext) GetEnddate() IExpressionContext { return s.enddate } + +func (s *DATEDIFF_BIGContext) SetDatepart(v IDateparts_12Context) { s.datepart = v } + +func (s *DATEDIFF_BIGContext) SetStartdate(v IExpressionContext) { s.startdate = v } + +func (s *DATEDIFF_BIGContext) SetEnddate(v IExpressionContext) { s.enddate = v } + +func (s *DATEDIFF_BIGContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATEDIFF_BIGContext) DATEDIFF_BIG() antlr.TerminalNode { + return s.GetToken(TSqlParserDATEDIFF_BIG, 0) +} + +func (s *DATEDIFF_BIGContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATEDIFF_BIGContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *DATEDIFF_BIGContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *DATEDIFF_BIGContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATEDIFF_BIGContext) Dateparts_12() IDateparts_12Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDateparts_12Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDateparts_12Context) +} + +func (s *DATEDIFF_BIGContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *DATEDIFF_BIGContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATEDIFF_BIGContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATEDIFF_BIG(s) + } +} + +func (s *DATEDIFF_BIGContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATEDIFF_BIG(s) + } +} + +func (s *DATEDIFF_BIGContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATEDIFF_BIG(s) + + default: + return t.VisitChildren(s) + } +} + +type USERContext struct { + Built_in_functionsContext +} + +func NewUSERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *USERContext { + var p = new(USERContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *USERContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *USERContext) USER() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER, 0) +} + +func (s *USERContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterUSER(s) + } +} + +func (s *USERContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitUSER(s) + } +} + +func (s *USERContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitUSER(s) + + default: + return t.VisitChildren(s) + } +} + +type DEGREESContext struct { + Built_in_functionsContext + numeric_expression IExpressionContext +} + +func NewDEGREESContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DEGREESContext { + var p = new(DEGREESContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DEGREESContext) GetNumeric_expression() IExpressionContext { return s.numeric_expression } + +func (s *DEGREESContext) SetNumeric_expression(v IExpressionContext) { s.numeric_expression = v } + +func (s *DEGREESContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DEGREESContext) DEGREES() antlr.TerminalNode { + return s.GetToken(TSqlParserDEGREES, 0) +} + +func (s *DEGREESContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DEGREESContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DEGREESContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DEGREESContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDEGREES(s) + } +} + +func (s *DEGREESContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDEGREES(s) + } +} + +func (s *DEGREESContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDEGREES(s) + + default: + return t.VisitChildren(s) + } +} + +type LENContext struct { + Built_in_functionsContext + string_expression IExpressionContext +} + +func NewLENContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LENContext { + var p = new(LENContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *LENContext) GetString_expression() IExpressionContext { return s.string_expression } + +func (s *LENContext) SetString_expression(v IExpressionContext) { s.string_expression = v } + +func (s *LENContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LENContext) LEN() antlr.TerminalNode { + return s.GetToken(TSqlParserLEN, 0) +} + +func (s *LENContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *LENContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *LENContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *LENContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterLEN(s) + } +} + +func (s *LENContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitLEN(s) + } +} + +func (s *LENContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitLEN(s) + + default: + return t.VisitChildren(s) + } +} + +type TRANSLATEContext struct { + Built_in_functionsContext + inputString IExpressionContext + characters IExpressionContext + translations IExpressionContext +} + +func NewTRANSLATEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TRANSLATEContext { + var p = new(TRANSLATEContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *TRANSLATEContext) GetInputString() IExpressionContext { return s.inputString } + +func (s *TRANSLATEContext) GetCharacters() IExpressionContext { return s.characters } + +func (s *TRANSLATEContext) GetTranslations() IExpressionContext { return s.translations } + +func (s *TRANSLATEContext) SetInputString(v IExpressionContext) { s.inputString = v } + +func (s *TRANSLATEContext) SetCharacters(v IExpressionContext) { s.characters = v } + +func (s *TRANSLATEContext) SetTranslations(v IExpressionContext) { s.translations = v } + +func (s *TRANSLATEContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TRANSLATEContext) TRANSLATE() antlr.TerminalNode { + return s.GetToken(TSqlParserTRANSLATE, 0) +} + +func (s *TRANSLATEContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *TRANSLATEContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *TRANSLATEContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *TRANSLATEContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *TRANSLATEContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *TRANSLATEContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *TRANSLATEContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTRANSLATE(s) + } +} + +func (s *TRANSLATEContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTRANSLATE(s) + } +} + +func (s *TRANSLATEContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTRANSLATE(s) + + default: + return t.VisitChildren(s) + } +} + +type SWITCHOFFSETContext struct { + Built_in_functionsContext + datetimeoffset_expression IExpressionContext + timezoneoffset_expression IExpressionContext +} + +func NewSWITCHOFFSETContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SWITCHOFFSETContext { + var p = new(SWITCHOFFSETContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *SWITCHOFFSETContext) GetDatetimeoffset_expression() IExpressionContext { + return s.datetimeoffset_expression +} + +func (s *SWITCHOFFSETContext) GetTimezoneoffset_expression() IExpressionContext { + return s.timezoneoffset_expression +} + +func (s *SWITCHOFFSETContext) SetDatetimeoffset_expression(v IExpressionContext) { + s.datetimeoffset_expression = v +} + +func (s *SWITCHOFFSETContext) SetTimezoneoffset_expression(v IExpressionContext) { + s.timezoneoffset_expression = v +} + +func (s *SWITCHOFFSETContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SWITCHOFFSETContext) SWITCHOFFSET() antlr.TerminalNode { + return s.GetToken(TSqlParserSWITCHOFFSET, 0) +} + +func (s *SWITCHOFFSETContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *SWITCHOFFSETContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *SWITCHOFFSETContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *SWITCHOFFSETContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *SWITCHOFFSETContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *SWITCHOFFSETContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSWITCHOFFSET(s) + } +} + +func (s *SWITCHOFFSETContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSWITCHOFFSET(s) + } +} + +func (s *SWITCHOFFSETContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSWITCHOFFSET(s) + + default: + return t.VisitChildren(s) + } +} + +type PIContext struct { + Built_in_functionsContext +} + +func NewPIContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PIContext { + var p = new(PIContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *PIContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PIContext) PI() antlr.TerminalNode { + return s.GetToken(TSqlParserPI, 0) +} + +func (s *PIContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *PIContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *PIContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPI(s) + } +} + +func (s *PIContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPI(s) + } +} + +func (s *PIContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPI(s) + + default: + return t.VisitChildren(s) + } +} + +type DATE_BUCKETContext struct { + Built_in_functionsContext + datepart IDateparts_9Context + number IExpressionContext + date IExpressionContext + origin IExpressionContext +} + +func NewDATE_BUCKETContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATE_BUCKETContext { + var p = new(DATE_BUCKETContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *DATE_BUCKETContext) GetDatepart() IDateparts_9Context { return s.datepart } + +func (s *DATE_BUCKETContext) GetNumber() IExpressionContext { return s.number } + +func (s *DATE_BUCKETContext) GetDate() IExpressionContext { return s.date } + +func (s *DATE_BUCKETContext) GetOrigin() IExpressionContext { return s.origin } + +func (s *DATE_BUCKETContext) SetDatepart(v IDateparts_9Context) { s.datepart = v } + +func (s *DATE_BUCKETContext) SetNumber(v IExpressionContext) { s.number = v } + +func (s *DATE_BUCKETContext) SetDate(v IExpressionContext) { s.date = v } + +func (s *DATE_BUCKETContext) SetOrigin(v IExpressionContext) { s.origin = v } + +func (s *DATE_BUCKETContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DATE_BUCKETContext) DATE_BUCKET() antlr.TerminalNode { + return s.GetToken(TSqlParserDATE_BUCKET, 0) +} + +func (s *DATE_BUCKETContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *DATE_BUCKETContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *DATE_BUCKETContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *DATE_BUCKETContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *DATE_BUCKETContext) Dateparts_9() IDateparts_9Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDateparts_9Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDateparts_9Context) +} + +func (s *DATE_BUCKETContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *DATE_BUCKETContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DATE_BUCKETContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDATE_BUCKET(s) + } +} + +func (s *DATE_BUCKETContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDATE_BUCKET(s) + } +} + +func (s *DATE_BUCKETContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDATE_BUCKET(s) + + default: + return t.VisitChildren(s) + } +} + +type EXPContext struct { + Built_in_functionsContext + float_expression IExpressionContext +} + +func NewEXPContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *EXPContext { + var p = new(EXPContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *EXPContext) GetFloat_expression() IExpressionContext { return s.float_expression } + +func (s *EXPContext) SetFloat_expression(v IExpressionContext) { s.float_expression = v } + +func (s *EXPContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EXPContext) EXP() antlr.TerminalNode { + return s.GetToken(TSqlParserEXP, 0) +} + +func (s *EXPContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *EXPContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *EXPContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *EXPContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEXP(s) + } +} + +func (s *EXPContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEXP(s) + } +} + +func (s *EXPContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEXP(s) + + default: + return t.VisitChildren(s) + } +} + +type STRINGAGGContext struct { + Built_in_functionsContext + expr IExpressionContext + separator IExpressionContext +} + +func NewSTRINGAGGContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *STRINGAGGContext { + var p = new(STRINGAGGContext) + + InitEmptyBuilt_in_functionsContext(&p.Built_in_functionsContext) + p.parser = parser + p.CopyAll(ctx.(*Built_in_functionsContext)) + + return p +} + +func (s *STRINGAGGContext) GetExpr() IExpressionContext { return s.expr } + +func (s *STRINGAGGContext) GetSeparator() IExpressionContext { return s.separator } + +func (s *STRINGAGGContext) SetExpr(v IExpressionContext) { s.expr = v } + +func (s *STRINGAGGContext) SetSeparator(v IExpressionContext) { s.separator = v } + +func (s *STRINGAGGContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *STRINGAGGContext) STRING_AGG() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING_AGG, 0) +} + +func (s *STRINGAGGContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *STRINGAGGContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *STRINGAGGContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *STRINGAGGContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *STRINGAGGContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *STRINGAGGContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *STRINGAGGContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *STRINGAGGContext) WITHIN() antlr.TerminalNode { + return s.GetToken(TSqlParserWITHIN, 0) +} + +func (s *STRINGAGGContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *STRINGAGGContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *STRINGAGGContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSTRINGAGG(s) + } +} + +func (s *STRINGAGGContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSTRINGAGG(s) + } +} + +func (s *STRINGAGGContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSTRINGAGG(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Built_in_functions() (localctx IBuilt_in_functionsContext) { + localctx = NewBuilt_in_functionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1064, TSqlParserRULE_built_in_functions) + var _la int + + p.SetState(13610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1714, p.GetParserRuleContext()) { + case 1: + localctx = NewAPP_NAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12264) + p.Match(TSqlParserAPP_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12265) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12266) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + localctx = NewAPPLOCK_MODEContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12267) + p.Match(TSqlParserAPPLOCK_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12268) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12269) + + var _x = p.expression(0) + + localctx.(*APPLOCK_MODEContext).database_principal = _x + } + { + p.SetState(12270) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12271) + + var _x = p.expression(0) + + localctx.(*APPLOCK_MODEContext).resource_name = _x + } + { + p.SetState(12272) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12273) + + var _x = p.expression(0) + + localctx.(*APPLOCK_MODEContext).lock_owner = _x + } + { + p.SetState(12274) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + localctx = NewAPPLOCK_TESTContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12276) + p.Match(TSqlParserAPPLOCK_TEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12277) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12278) + + var _x = p.expression(0) + + localctx.(*APPLOCK_TESTContext).database_principal = _x + } + { + p.SetState(12279) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12280) + + var _x = p.expression(0) + + localctx.(*APPLOCK_TESTContext).resource_name = _x + } + { + p.SetState(12281) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12282) + + var _x = p.expression(0) + + localctx.(*APPLOCK_TESTContext).lock_mode = _x + } + { + p.SetState(12283) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12284) + + var _x = p.expression(0) + + localctx.(*APPLOCK_TESTContext).lock_owner = _x + } + { + p.SetState(12285) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + localctx = NewASSEMBLYPROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12287) + p.Match(TSqlParserASSEMBLYPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12288) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12289) + + var _x = p.expression(0) + + localctx.(*ASSEMBLYPROPERTYContext).assembly_name = _x + } + { + p.SetState(12290) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12291) + + var _x = p.expression(0) + + localctx.(*ASSEMBLYPROPERTYContext).property_name = _x + } + { + p.SetState(12292) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + localctx = NewCOL_LENGTHContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(12294) + p.Match(TSqlParserCOL_LENGTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12295) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12296) + + var _x = p.expression(0) + + localctx.(*COL_LENGTHContext).table = _x + } + { + p.SetState(12297) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12298) + + var _x = p.expression(0) + + localctx.(*COL_LENGTHContext).column = _x + } + { + p.SetState(12299) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + localctx = NewCOL_NAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(12301) + p.Match(TSqlParserCOL_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12302) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12303) + + var _x = p.expression(0) + + localctx.(*COL_NAMEContext).table_id = _x + } + { + p.SetState(12304) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12305) + + var _x = p.expression(0) + + localctx.(*COL_NAMEContext).column_id = _x + } + { + p.SetState(12306) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + localctx = NewCOLUMNPROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(12308) + p.Match(TSqlParserCOLUMNPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12309) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12310) + + var _x = p.expression(0) + + localctx.(*COLUMNPROPERTYContext).id = _x + } + { + p.SetState(12311) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12312) + + var _x = p.expression(0) + + localctx.(*COLUMNPROPERTYContext).column = _x + } + { + p.SetState(12313) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12314) + + var _x = p.expression(0) + + localctx.(*COLUMNPROPERTYContext).property = _x + } + { + p.SetState(12315) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + localctx = NewDATABASEPROPERTYEXContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(12317) + p.Match(TSqlParserDATABASEPROPERTYEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12318) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12319) + + var _x = p.expression(0) + + localctx.(*DATABASEPROPERTYEXContext).database = _x + } + { + p.SetState(12320) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12321) + + var _x = p.expression(0) + + localctx.(*DATABASEPROPERTYEXContext).property = _x + } + { + p.SetState(12322) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + localctx = NewDB_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(12324) + p.Match(TSqlParserDB_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12325) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12327) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(12326) + + var _x = p.expression(0) + + localctx.(*DB_IDContext).database_name = _x + } + + } + { + p.SetState(12329) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + localctx = NewDB_NAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(12330) + p.Match(TSqlParserDB_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12331) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12333) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(12332) + + var _x = p.expression(0) + + localctx.(*DB_NAMEContext).database_id = _x + } + + } + { + p.SetState(12335) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + localctx = NewFILE_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(12336) + p.Match(TSqlParserFILE_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12337) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12338) + + var _x = p.expression(0) + + localctx.(*FILE_IDContext).file_name = _x + } + { + p.SetState(12339) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + localctx = NewFILE_IDEXContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(12341) + p.Match(TSqlParserFILE_IDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12342) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12343) + + var _x = p.expression(0) + + localctx.(*FILE_IDEXContext).file_name = _x + } + { + p.SetState(12344) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + localctx = NewFILE_NAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(12346) + p.Match(TSqlParserFILE_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12347) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12348) + + var _x = p.expression(0) + + localctx.(*FILE_NAMEContext).file_id = _x + } + { + p.SetState(12349) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + localctx = NewFILEGROUP_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(12351) + p.Match(TSqlParserFILEGROUP_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12352) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12353) + + var _x = p.expression(0) + + localctx.(*FILEGROUP_IDContext).filegroup_name = _x + } + { + p.SetState(12354) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + localctx = NewFILEGROUP_NAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(12356) + p.Match(TSqlParserFILEGROUP_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12357) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12358) + + var _x = p.expression(0) + + localctx.(*FILEGROUP_NAMEContext).filegroup_id = _x + } + { + p.SetState(12359) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + localctx = NewFILEGROUPPROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 16) + { + p.SetState(12361) + p.Match(TSqlParserFILEGROUPPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12362) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12363) + + var _x = p.expression(0) + + localctx.(*FILEGROUPPROPERTYContext).filegroup_name = _x + } + { + p.SetState(12364) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12365) + + var _x = p.expression(0) + + localctx.(*FILEGROUPPROPERTYContext).property = _x + } + { + p.SetState(12366) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + localctx = NewFILEPROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 17) + { + p.SetState(12368) + p.Match(TSqlParserFILEPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12369) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12370) + + var _x = p.expression(0) + + localctx.(*FILEPROPERTYContext).file_name = _x + } + { + p.SetState(12371) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12372) + + var _x = p.expression(0) + + localctx.(*FILEPROPERTYContext).property = _x + } + { + p.SetState(12373) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + localctx = NewFILEPROPERTYEXContext(p, localctx) + p.EnterOuterAlt(localctx, 18) + { + p.SetState(12375) + p.Match(TSqlParserFILEPROPERTYEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12376) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12377) + + var _x = p.expression(0) + + localctx.(*FILEPROPERTYEXContext).name = _x + } + { + p.SetState(12378) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12379) + + var _x = p.expression(0) + + localctx.(*FILEPROPERTYEXContext).property = _x + } + { + p.SetState(12380) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + localctx = NewFULLTEXTCATALOGPROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 19) + { + p.SetState(12382) + p.Match(TSqlParserFULLTEXTCATALOGPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12383) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12384) + + var _x = p.expression(0) + + localctx.(*FULLTEXTCATALOGPROPERTYContext).catalog_name = _x + } + { + p.SetState(12385) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12386) + + var _x = p.expression(0) + + localctx.(*FULLTEXTCATALOGPROPERTYContext).property = _x + } + { + p.SetState(12387) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + localctx = NewFULLTEXTSERVICEPROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 20) + { + p.SetState(12389) + p.Match(TSqlParserFULLTEXTSERVICEPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12390) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12391) + + var _x = p.expression(0) + + localctx.(*FULLTEXTSERVICEPROPERTYContext).property = _x + } + { + p.SetState(12392) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + localctx = NewINDEX_COLContext(p, localctx) + p.EnterOuterAlt(localctx, 21) + { + p.SetState(12394) + p.Match(TSqlParserINDEX_COL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12395) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12396) + + var _x = p.expression(0) + + localctx.(*INDEX_COLContext).table_or_view_name = _x + } + { + p.SetState(12397) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12398) + + var _x = p.expression(0) + + localctx.(*INDEX_COLContext).index_id = _x + } + { + p.SetState(12399) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12400) + + var _x = p.expression(0) + + localctx.(*INDEX_COLContext).key_id = _x + } + { + p.SetState(12401) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 22: + localctx = NewINDEXKEY_PROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 22) + { + p.SetState(12403) + p.Match(TSqlParserINDEXKEY_PROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12404) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12405) + + var _x = p.expression(0) + + localctx.(*INDEXKEY_PROPERTYContext).object_id = _x + } + { + p.SetState(12406) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12407) + + var _x = p.expression(0) + + localctx.(*INDEXKEY_PROPERTYContext).index_id = _x + } + { + p.SetState(12408) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12409) + + var _x = p.expression(0) + + localctx.(*INDEXKEY_PROPERTYContext).key_id = _x + } + { + p.SetState(12410) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12411) + + var _x = p.expression(0) + + localctx.(*INDEXKEY_PROPERTYContext).property = _x + } + { + p.SetState(12412) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 23: + localctx = NewINDEXPROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 23) + { + p.SetState(12414) + p.Match(TSqlParserINDEXPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12415) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12416) + + var _x = p.expression(0) + + localctx.(*INDEXPROPERTYContext).object_id = _x + } + { + p.SetState(12417) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12418) + + var _x = p.expression(0) + + localctx.(*INDEXPROPERTYContext).index_or_statistics_name = _x + } + { + p.SetState(12419) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12420) + + var _x = p.expression(0) + + localctx.(*INDEXPROPERTYContext).property = _x + } + { + p.SetState(12421) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 24: + localctx = NewNEXT_VALUE_FORContext(p, localctx) + p.EnterOuterAlt(localctx, 24) + { + p.SetState(12423) + p.Match(TSqlParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12424) + p.Match(TSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12425) + p.Match(TSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12426) + + var _x = p.Table_name() + + localctx.(*NEXT_VALUE_FORContext).sequence_name = _x + } + p.SetState(12432) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1659, p.GetParserRuleContext()) == 1 { + { + p.SetState(12427) + p.Match(TSqlParserOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12428) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12429) + p.Order_by_clause() + } + { + p.SetState(12430) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 25: + localctx = NewOBJECT_DEFINITIONContext(p, localctx) + p.EnterOuterAlt(localctx, 25) + { + p.SetState(12434) + p.Match(TSqlParserOBJECT_DEFINITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12435) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12436) + + var _x = p.expression(0) + + localctx.(*OBJECT_DEFINITIONContext).object_id = _x + } + { + p.SetState(12437) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 26: + localctx = NewOBJECT_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 26) + { + p.SetState(12439) + p.Match(TSqlParserOBJECT_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12440) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12441) + + var _x = p.expression(0) + + localctx.(*OBJECT_IDContext).object_name = _x + } + p.SetState(12444) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(12442) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12443) + + var _x = p.expression(0) + + localctx.(*OBJECT_IDContext).object_type = _x + } + + } + { + p.SetState(12446) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + localctx = NewOBJECT_NAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 27) + { + p.SetState(12448) + p.Match(TSqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12449) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12450) + + var _x = p.expression(0) + + localctx.(*OBJECT_NAMEContext).object_id = _x + } + p.SetState(12453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(12451) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12452) + + var _x = p.expression(0) + + localctx.(*OBJECT_NAMEContext).database_id = _x + } + + } + { + p.SetState(12455) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 28: + localctx = NewOBJECT_SCHEMA_NAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 28) + { + p.SetState(12457) + p.Match(TSqlParserOBJECT_SCHEMA_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12458) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12459) + + var _x = p.expression(0) + + localctx.(*OBJECT_SCHEMA_NAMEContext).object_id = _x + } + p.SetState(12462) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(12460) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12461) + + var _x = p.expression(0) + + localctx.(*OBJECT_SCHEMA_NAMEContext).database_id = _x + } + + } + { + p.SetState(12464) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 29: + localctx = NewOBJECTPROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 29) + { + p.SetState(12466) + p.Match(TSqlParserOBJECTPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12467) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12468) + + var _x = p.expression(0) + + localctx.(*OBJECTPROPERTYContext).id = _x + } + { + p.SetState(12469) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12470) + + var _x = p.expression(0) + + localctx.(*OBJECTPROPERTYContext).property = _x + } + { + p.SetState(12471) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 30: + localctx = NewOBJECTPROPERTYEXContext(p, localctx) + p.EnterOuterAlt(localctx, 30) + { + p.SetState(12473) + p.Match(TSqlParserOBJECTPROPERTYEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12474) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12475) + + var _x = p.expression(0) + + localctx.(*OBJECTPROPERTYEXContext).id = _x + } + { + p.SetState(12476) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12477) + + var _x = p.expression(0) + + localctx.(*OBJECTPROPERTYEXContext).property = _x + } + { + p.SetState(12478) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 31: + localctx = NewORIGINAL_DB_NAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 31) + { + p.SetState(12480) + p.Match(TSqlParserORIGINAL_DB_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12481) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12482) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 32: + localctx = NewPARSENAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 32) + { + p.SetState(12483) + p.Match(TSqlParserPARSENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12484) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12485) + + var _x = p.expression(0) + + localctx.(*PARSENAMEContext).object_name = _x + } + { + p.SetState(12486) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12487) + + var _x = p.expression(0) + + localctx.(*PARSENAMEContext).object_piece = _x + } + { + p.SetState(12488) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + localctx = NewSCHEMA_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 33) + { + p.SetState(12490) + p.Match(TSqlParserSCHEMA_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12491) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(12492) + + var _x = p.expression(0) + + localctx.(*SCHEMA_IDContext).schema_name = _x + } + + } + { + p.SetState(12495) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 34: + localctx = NewSCHEMA_NAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 34) + { + p.SetState(12496) + p.Match(TSqlParserSCHEMA_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12497) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(12498) + + var _x = p.expression(0) + + localctx.(*SCHEMA_NAMEContext).schema_id = _x + } + + } + { + p.SetState(12501) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 35: + localctx = NewSCOPE_IDENTITYContext(p, localctx) + p.EnterOuterAlt(localctx, 35) + { + p.SetState(12502) + p.Match(TSqlParserSCOPE_IDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12503) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12504) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 36: + localctx = NewSERVERPROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 36) + { + p.SetState(12505) + p.Match(TSqlParserSERVERPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12506) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12507) + + var _x = p.expression(0) + + localctx.(*SERVERPROPERTYContext).property = _x + } + { + p.SetState(12508) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 37: + localctx = NewSTATS_DATEContext(p, localctx) + p.EnterOuterAlt(localctx, 37) + { + p.SetState(12510) + p.Match(TSqlParserSTATS_DATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12511) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12512) + + var _x = p.expression(0) + + localctx.(*STATS_DATEContext).object_id = _x + } + { + p.SetState(12513) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12514) + + var _x = p.expression(0) + + localctx.(*STATS_DATEContext).stats_id = _x + } + { + p.SetState(12515) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 38: + localctx = NewTYPE_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 38) + { + p.SetState(12517) + p.Match(TSqlParserTYPE_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12518) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12519) + + var _x = p.expression(0) + + localctx.(*TYPE_IDContext).type_name = _x + } + { + p.SetState(12520) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 39: + localctx = NewTYPE_NAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 39) + { + p.SetState(12522) + p.Match(TSqlParserTYPE_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12523) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12524) + + var _x = p.expression(0) + + localctx.(*TYPE_NAMEContext).type_id = _x + } + { + p.SetState(12525) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 40: + localctx = NewTYPEPROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 40) + { + p.SetState(12527) + p.Match(TSqlParserTYPEPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12528) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12529) + + var _x = p.expression(0) + + localctx.(*TYPEPROPERTYContext).type_ = _x + } + { + p.SetState(12530) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12531) + + var _x = p.expression(0) + + localctx.(*TYPEPROPERTYContext).property = _x + } + { + p.SetState(12532) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 41: + localctx = NewASCIIContext(p, localctx) + p.EnterOuterAlt(localctx, 41) + { + p.SetState(12534) + p.Match(TSqlParserASCII) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12535) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12536) + + var _x = p.expression(0) + + localctx.(*ASCIIContext).character_expression = _x + } + { + p.SetState(12537) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 42: + localctx = NewCHARContext(p, localctx) + p.EnterOuterAlt(localctx, 42) + { + p.SetState(12539) + p.Match(TSqlParserCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12540) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12541) + + var _x = p.expression(0) + + localctx.(*CHARContext).integer_expression = _x + } + { + p.SetState(12542) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 43: + localctx = NewCHARINDEXContext(p, localctx) + p.EnterOuterAlt(localctx, 43) + { + p.SetState(12544) + p.Match(TSqlParserCHARINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12545) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12546) + + var _x = p.expression(0) + + localctx.(*CHARINDEXContext).expressionToFind = _x + } + { + p.SetState(12547) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12548) + + var _x = p.expression(0) + + localctx.(*CHARINDEXContext).expressionToSearch = _x + } + p.SetState(12551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(12549) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12550) + + var _x = p.expression(0) + + localctx.(*CHARINDEXContext).start_location = _x + } + + } + { + p.SetState(12553) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 44: + localctx = NewCONCATContext(p, localctx) + p.EnterOuterAlt(localctx, 44) + { + p.SetState(12555) + p.Match(TSqlParserCONCAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12556) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12557) + + var _x = p.expression(0) + + localctx.(*CONCATContext).string_value_1 = _x + } + { + p.SetState(12558) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12559) + + var _x = p.expression(0) + + localctx.(*CONCATContext).string_value_2 = _x + } + p.SetState(12564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(12560) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12561) + + var _x = p.expression(0) + + localctx.(*CONCATContext)._expression = _x + } + localctx.(*CONCATContext).string_value_n = append(localctx.(*CONCATContext).string_value_n, localctx.(*CONCATContext)._expression) + + p.SetState(12566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12567) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 45: + localctx = NewCONCAT_WSContext(p, localctx) + p.EnterOuterAlt(localctx, 45) + { + p.SetState(12569) + p.Match(TSqlParserCONCAT_WS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12570) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12571) + + var _x = p.expression(0) + + localctx.(*CONCAT_WSContext).separator = _x + } + { + p.SetState(12572) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12573) + + var _x = p.expression(0) + + localctx.(*CONCAT_WSContext).argument_1 = _x + } + { + p.SetState(12574) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12575) + + var _x = p.expression(0) + + localctx.(*CONCAT_WSContext).argument_2 = _x + } + p.SetState(12580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(12576) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12577) + + var _x = p.expression(0) + + localctx.(*CONCAT_WSContext)._expression = _x + } + localctx.(*CONCAT_WSContext).argument_n = append(localctx.(*CONCAT_WSContext).argument_n, localctx.(*CONCAT_WSContext)._expression) + + p.SetState(12582) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12583) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 46: + localctx = NewDIFFERENCEContext(p, localctx) + p.EnterOuterAlt(localctx, 46) + { + p.SetState(12585) + p.Match(TSqlParserDIFFERENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12586) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12587) + + var _x = p.expression(0) + + localctx.(*DIFFERENCEContext).character_expression_1 = _x + } + { + p.SetState(12588) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12589) + + var _x = p.expression(0) + + localctx.(*DIFFERENCEContext).character_expression_2 = _x + } + { + p.SetState(12590) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 47: + localctx = NewFORMATContext(p, localctx) + p.EnterOuterAlt(localctx, 47) + { + p.SetState(12592) + p.Match(TSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12593) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12594) + + var _x = p.expression(0) + + localctx.(*FORMATContext).value = _x + } + { + p.SetState(12595) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12596) + + var _x = p.expression(0) + + localctx.(*FORMATContext).format = _x + } + p.SetState(12599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(12597) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12598) + + var _x = p.expression(0) + + localctx.(*FORMATContext).culture = _x + } + + } + { + p.SetState(12601) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 48: + localctx = NewLEFTContext(p, localctx) + p.EnterOuterAlt(localctx, 48) + { + p.SetState(12603) + p.Match(TSqlParserLEFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12604) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12605) + + var _x = p.expression(0) + + localctx.(*LEFTContext).character_expression = _x + } + { + p.SetState(12606) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12607) + + var _x = p.expression(0) + + localctx.(*LEFTContext).integer_expression = _x + } + { + p.SetState(12608) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 49: + localctx = NewLENContext(p, localctx) + p.EnterOuterAlt(localctx, 49) + { + p.SetState(12610) + p.Match(TSqlParserLEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12611) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12612) + + var _x = p.expression(0) + + localctx.(*LENContext).string_expression = _x + } + { + p.SetState(12613) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 50: + localctx = NewLOWERContext(p, localctx) + p.EnterOuterAlt(localctx, 50) + { + p.SetState(12615) + p.Match(TSqlParserLOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12616) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12617) + + var _x = p.expression(0) + + localctx.(*LOWERContext).character_expression = _x + } + { + p.SetState(12618) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 51: + localctx = NewLTRIMContext(p, localctx) + p.EnterOuterAlt(localctx, 51) + { + p.SetState(12620) + p.Match(TSqlParserLTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12621) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12622) + + var _x = p.expression(0) + + localctx.(*LTRIMContext).character_expression = _x + } + { + p.SetState(12623) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 52: + localctx = NewNCHARContext(p, localctx) + p.EnterOuterAlt(localctx, 52) + { + p.SetState(12625) + p.Match(TSqlParserNCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12626) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12627) + + var _x = p.expression(0) + + localctx.(*NCHARContext).integer_expression = _x + } + { + p.SetState(12628) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 53: + localctx = NewPATINDEXContext(p, localctx) + p.EnterOuterAlt(localctx, 53) + { + p.SetState(12630) + p.Match(TSqlParserPATINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12631) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12632) + + var _x = p.expression(0) + + localctx.(*PATINDEXContext).pattern = _x + } + { + p.SetState(12633) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12634) + + var _x = p.expression(0) + + localctx.(*PATINDEXContext).string_expression = _x + } + { + p.SetState(12635) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 54: + localctx = NewQUOTENAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 54) + { + p.SetState(12637) + p.Match(TSqlParserQUOTENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12638) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12639) + + var _x = p.expression(0) + + localctx.(*QUOTENAMEContext).character_string = _x + } + p.SetState(12642) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(12640) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12641) + + var _x = p.expression(0) + + localctx.(*QUOTENAMEContext).quote_character = _x + } + + } + { + p.SetState(12644) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 55: + localctx = NewREPLACEContext(p, localctx) + p.EnterOuterAlt(localctx, 55) + { + p.SetState(12646) + p.Match(TSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12647) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12648) + + var _x = p.expression(0) + + localctx.(*REPLACEContext).input = _x + } + { + p.SetState(12649) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12650) + + var _x = p.expression(0) + + localctx.(*REPLACEContext).replacing = _x + } + { + p.SetState(12651) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12652) + + var _x = p.expression(0) + + localctx.(*REPLACEContext).with = _x + } + { + p.SetState(12653) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 56: + localctx = NewREPLICATEContext(p, localctx) + p.EnterOuterAlt(localctx, 56) + { + p.SetState(12655) + p.Match(TSqlParserREPLICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12656) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12657) + + var _x = p.expression(0) + + localctx.(*REPLICATEContext).string_expression = _x + } + { + p.SetState(12658) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12659) + + var _x = p.expression(0) + + localctx.(*REPLICATEContext).integer_expression = _x + } + { + p.SetState(12660) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 57: + localctx = NewREVERSEContext(p, localctx) + p.EnterOuterAlt(localctx, 57) + { + p.SetState(12662) + p.Match(TSqlParserREVERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12663) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12664) + + var _x = p.expression(0) + + localctx.(*REVERSEContext).string_expression = _x + } + { + p.SetState(12665) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 58: + localctx = NewRIGHTContext(p, localctx) + p.EnterOuterAlt(localctx, 58) + { + p.SetState(12667) + p.Match(TSqlParserRIGHT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12668) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12669) + + var _x = p.expression(0) + + localctx.(*RIGHTContext).character_expression = _x + } + { + p.SetState(12670) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12671) + + var _x = p.expression(0) + + localctx.(*RIGHTContext).integer_expression = _x + } + { + p.SetState(12672) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 59: + localctx = NewRTRIMContext(p, localctx) + p.EnterOuterAlt(localctx, 59) + { + p.SetState(12674) + p.Match(TSqlParserRTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12675) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12676) + + var _x = p.expression(0) + + localctx.(*RTRIMContext).character_expression = _x + } + { + p.SetState(12677) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 60: + localctx = NewSOUNDEXContext(p, localctx) + p.EnterOuterAlt(localctx, 60) + { + p.SetState(12679) + p.Match(TSqlParserSOUNDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12680) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12681) + + var _x = p.expression(0) + + localctx.(*SOUNDEXContext).character_expression = _x + } + { + p.SetState(12682) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 61: + localctx = NewSPACEContext(p, localctx) + p.EnterOuterAlt(localctx, 61) + { + p.SetState(12684) + p.Match(TSqlParserSPACE_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12685) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12686) + + var _x = p.expression(0) + + localctx.(*SPACEContext).integer_expression = _x + } + { + p.SetState(12687) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 62: + localctx = NewSTRContext(p, localctx) + p.EnterOuterAlt(localctx, 62) + { + p.SetState(12689) + p.Match(TSqlParserSTR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12690) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12691) + + var _x = p.expression(0) + + localctx.(*STRContext).float_expression = _x + } + p.SetState(12698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(12692) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12693) + + var _x = p.expression(0) + + localctx.(*STRContext).length_expression = _x + } + p.SetState(12696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(12694) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12695) + + var _x = p.expression(0) + + localctx.(*STRContext).decimal = _x + } + + } + + } + { + p.SetState(12700) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 63: + localctx = NewSTRINGAGGContext(p, localctx) + p.EnterOuterAlt(localctx, 63) + { + p.SetState(12702) + p.Match(TSqlParserSTRING_AGG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12703) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12704) + + var _x = p.expression(0) + + localctx.(*STRINGAGGContext).expr = _x + } + { + p.SetState(12705) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12706) + + var _x = p.expression(0) + + localctx.(*STRINGAGGContext).separator = _x + } + { + p.SetState(12707) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12714) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1672, p.GetParserRuleContext()) == 1 { + { + p.SetState(12708) + p.Match(TSqlParserWITHIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12709) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12710) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12711) + p.Order_by_clause() + } + { + p.SetState(12712) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 64: + localctx = NewSTRING_ESCAPEContext(p, localctx) + p.EnterOuterAlt(localctx, 64) + { + p.SetState(12716) + p.Match(TSqlParserSTRING_ESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12717) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12718) + + var _x = p.expression(0) + + localctx.(*STRING_ESCAPEContext).text_ = _x + } + { + p.SetState(12719) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12720) + + var _x = p.expression(0) + + localctx.(*STRING_ESCAPEContext).type_ = _x + } + { + p.SetState(12721) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 65: + localctx = NewSTUFFContext(p, localctx) + p.EnterOuterAlt(localctx, 65) + { + p.SetState(12723) + p.Match(TSqlParserSTUFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12724) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12725) + + var _x = p.expression(0) + + localctx.(*STUFFContext).str = _x + } + { + p.SetState(12726) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12727) + + var _x = p.expression(0) + + localctx.(*STUFFContext).from = _x + } + { + p.SetState(12728) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12729) + + var _x = p.expression(0) + + localctx.(*STUFFContext).to = _x + } + { + p.SetState(12730) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12731) + + var _x = p.expression(0) + + localctx.(*STUFFContext).str_with = _x + } + { + p.SetState(12732) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 66: + localctx = NewSUBSTRINGContext(p, localctx) + p.EnterOuterAlt(localctx, 66) + { + p.SetState(12734) + p.Match(TSqlParserSUBSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12735) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12736) + + var _x = p.expression(0) + + localctx.(*SUBSTRINGContext).string_expression = _x + } + { + p.SetState(12737) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12738) + + var _x = p.expression(0) + + localctx.(*SUBSTRINGContext).start_ = _x + } + { + p.SetState(12739) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12740) + + var _x = p.expression(0) + + localctx.(*SUBSTRINGContext).length = _x + } + { + p.SetState(12741) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 67: + localctx = NewTRANSLATEContext(p, localctx) + p.EnterOuterAlt(localctx, 67) + { + p.SetState(12743) + p.Match(TSqlParserTRANSLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12744) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12745) + + var _x = p.expression(0) + + localctx.(*TRANSLATEContext).inputString = _x + } + { + p.SetState(12746) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12747) + + var _x = p.expression(0) + + localctx.(*TRANSLATEContext).characters = _x + } + { + p.SetState(12748) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12749) + + var _x = p.expression(0) + + localctx.(*TRANSLATEContext).translations = _x + } + { + p.SetState(12750) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 68: + localctx = NewTRIMContext(p, localctx) + p.EnterOuterAlt(localctx, 68) + { + p.SetState(12752) + p.Match(TSqlParserTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12753) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12757) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1673, p.GetParserRuleContext()) == 1 { + { + p.SetState(12754) + + var _x = p.expression(0) + + localctx.(*TRIMContext).characters = _x + } + { + p.SetState(12755) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12759) + + var _x = p.expression(0) + + localctx.(*TRIMContext).string_ = _x + } + { + p.SetState(12760) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 69: + localctx = NewUNICODEContext(p, localctx) + p.EnterOuterAlt(localctx, 69) + { + p.SetState(12762) + p.Match(TSqlParserUNICODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12763) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12764) + + var _x = p.expression(0) + + localctx.(*UNICODEContext).ncharacter_expression = _x + } + { + p.SetState(12765) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 70: + localctx = NewUPPERContext(p, localctx) + p.EnterOuterAlt(localctx, 70) + { + p.SetState(12767) + p.Match(TSqlParserUPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12768) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12769) + + var _x = p.expression(0) + + localctx.(*UPPERContext).character_expression = _x + } + { + p.SetState(12770) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 71: + localctx = NewBINARY_CHECKSUMContext(p, localctx) + p.EnterOuterAlt(localctx, 71) + { + p.SetState(12772) + p.Match(TSqlParserBINARY_CHECKSUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12773) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12783) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTAR: + { + p.SetState(12774) + + var _m = p.Match(TSqlParserSTAR) + + localctx.(*BINARY_CHECKSUMContext).star = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCASE, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOALESCE, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTAINSTABLE, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCONVERT, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_DATE, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TIMESTAMP, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURRENT_USER, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDOLLAR_PARTITION, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFREETEXTTABLE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEFT, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULLIF, TSqlParserNULL_, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVER, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserRIGHT, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMANTICKEYPHRASETABLE, TSqlParserSEMANTICSIMILARITYDETAILSTABLE, TSqlParserSEMANTICSIMILARITYTABLE, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSESSION_USER, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserSYSTEM_USER, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOLLAR_ACTION, TSqlParserCURSOR_ROWS, TSqlParserFETCH_STATUS, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserLOCAL_ID, TSqlParserTEMP_ID, TSqlParserDECIMAL, TSqlParserID, TSqlParserSTRING, TSqlParserBINARY, TSqlParserFLOAT, TSqlParserREAL, TSqlParserDOT, TSqlParserDOLLAR, TSqlParserLR_BRACKET, TSqlParserPLUS, TSqlParserMINUS, TSqlParserBIT_NOT, TSqlParserPLACEHOLDER: + { + p.SetState(12775) + p.expression(0) + } + p.SetState(12780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(12776) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12777) + p.expression(0) + } + + p.SetState(12782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(12785) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 72: + localctx = NewCHECKSUMContext(p, localctx) + p.EnterOuterAlt(localctx, 72) + { + p.SetState(12786) + p.Match(TSqlParserCHECKSUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12787) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTAR: + { + p.SetState(12788) + + var _m = p.Match(TSqlParserSTAR) + + localctx.(*CHECKSUMContext).star = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCASE, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOALESCE, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTAINSTABLE, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCONVERT, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_DATE, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TIMESTAMP, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURRENT_USER, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDOLLAR_PARTITION, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFREETEXTTABLE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEFT, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULLIF, TSqlParserNULL_, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVER, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserRIGHT, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMANTICKEYPHRASETABLE, TSqlParserSEMANTICSIMILARITYDETAILSTABLE, TSqlParserSEMANTICSIMILARITYTABLE, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSESSION_USER, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserSYSTEM_USER, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOLLAR_ACTION, TSqlParserCURSOR_ROWS, TSqlParserFETCH_STATUS, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserLOCAL_ID, TSqlParserTEMP_ID, TSqlParserDECIMAL, TSqlParserID, TSqlParserSTRING, TSqlParserBINARY, TSqlParserFLOAT, TSqlParserREAL, TSqlParserDOT, TSqlParserDOLLAR, TSqlParserLR_BRACKET, TSqlParserPLUS, TSqlParserMINUS, TSqlParserBIT_NOT, TSqlParserPLACEHOLDER: + { + p.SetState(12789) + p.expression(0) + } + p.SetState(12794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(12790) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12791) + p.expression(0) + } + + p.SetState(12796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(12799) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 73: + localctx = NewCOMPRESSContext(p, localctx) + p.EnterOuterAlt(localctx, 73) + { + p.SetState(12800) + p.Match(TSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12801) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12802) + + var _x = p.expression(0) + + localctx.(*COMPRESSContext).expr = _x + } + { + p.SetState(12803) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 74: + localctx = NewCONNECTIONPROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 74) + { + p.SetState(12805) + p.Match(TSqlParserCONNECTIONPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12806) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12807) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*CONNECTIONPROPERTYContext).property = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12808) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 75: + localctx = NewCONTEXT_INFOContext(p, localctx) + p.EnterOuterAlt(localctx, 75) + { + p.SetState(12809) + p.Match(TSqlParserCONTEXT_INFO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12810) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12811) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 76: + localctx = NewCURRENT_REQUEST_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 76) + { + p.SetState(12812) + p.Match(TSqlParserCURRENT_REQUEST_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12813) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12814) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 77: + localctx = NewCURRENT_TRANSACTION_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 77) + { + p.SetState(12815) + p.Match(TSqlParserCURRENT_TRANSACTION_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12816) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12817) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 78: + localctx = NewDECOMPRESSContext(p, localctx) + p.EnterOuterAlt(localctx, 78) + { + p.SetState(12818) + p.Match(TSqlParserDECOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12819) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12820) + + var _x = p.expression(0) + + localctx.(*DECOMPRESSContext).expr = _x + } + { + p.SetState(12821) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 79: + localctx = NewERROR_LINEContext(p, localctx) + p.EnterOuterAlt(localctx, 79) + { + p.SetState(12823) + p.Match(TSqlParserERROR_LINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12824) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12825) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 80: + localctx = NewERROR_MESSAGEContext(p, localctx) + p.EnterOuterAlt(localctx, 80) + { + p.SetState(12826) + p.Match(TSqlParserERROR_MESSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12827) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12828) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 81: + localctx = NewERROR_NUMBERContext(p, localctx) + p.EnterOuterAlt(localctx, 81) + { + p.SetState(12829) + p.Match(TSqlParserERROR_NUMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12830) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12831) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 82: + localctx = NewERROR_PROCEDUREContext(p, localctx) + p.EnterOuterAlt(localctx, 82) + { + p.SetState(12832) + p.Match(TSqlParserERROR_PROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12833) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12834) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 83: + localctx = NewERROR_SEVERITYContext(p, localctx) + p.EnterOuterAlt(localctx, 83) + { + p.SetState(12835) + p.Match(TSqlParserERROR_SEVERITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12836) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12837) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 84: + localctx = NewERROR_STATEContext(p, localctx) + p.EnterOuterAlt(localctx, 84) + { + p.SetState(12838) + p.Match(TSqlParserERROR_STATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12839) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12840) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 85: + localctx = NewFORMATMESSAGEContext(p, localctx) + p.EnterOuterAlt(localctx, 85) + { + p.SetState(12841) + p.Match(TSqlParserFORMATMESSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12842) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(12843) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*FORMATMESSAGEContext).msg_number = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSTRING: + { + p.SetState(12844) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*FORMATMESSAGEContext).msg_string = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserLOCAL_ID: + { + p.SetState(12845) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*FORMATMESSAGEContext).msg_variable = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(12848) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12849) + p.expression(0) + } + p.SetState(12854) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(12850) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12851) + p.expression(0) + } + + p.SetState(12856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12857) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 86: + localctx = NewGET_FILESTREAM_TRANSACTION_CONTEXTContext(p, localctx) + p.EnterOuterAlt(localctx, 86) + { + p.SetState(12859) + p.Match(TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12860) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12861) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 87: + localctx = NewGETANSINULLContext(p, localctx) + p.EnterOuterAlt(localctx, 87) + { + p.SetState(12862) + p.Match(TSqlParserGETANSINULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12863) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSTRING { + { + p.SetState(12864) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*GETANSINULLContext).database = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12867) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 88: + localctx = NewHOST_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 88) + { + p.SetState(12868) + p.Match(TSqlParserHOST_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12869) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12870) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 89: + localctx = NewHOST_NAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 89) + { + p.SetState(12871) + p.Match(TSqlParserHOST_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12872) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12873) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 90: + localctx = NewISNULLContext(p, localctx) + p.EnterOuterAlt(localctx, 90) + { + p.SetState(12874) + p.Match(TSqlParserISNULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12875) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12876) + + var _x = p.expression(0) + + localctx.(*ISNULLContext).left = _x + } + { + p.SetState(12877) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12878) + + var _x = p.expression(0) + + localctx.(*ISNULLContext).right = _x + } + { + p.SetState(12879) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 91: + localctx = NewISNUMERICContext(p, localctx) + p.EnterOuterAlt(localctx, 91) + { + p.SetState(12881) + p.Match(TSqlParserISNUMERIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12882) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12883) + p.expression(0) + } + { + p.SetState(12884) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 92: + localctx = NewMIN_ACTIVE_ROWVERSIONContext(p, localctx) + p.EnterOuterAlt(localctx, 92) + { + p.SetState(12886) + p.Match(TSqlParserMIN_ACTIVE_ROWVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12887) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12888) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 93: + localctx = NewNEWIDContext(p, localctx) + p.EnterOuterAlt(localctx, 93) + { + p.SetState(12889) + p.Match(TSqlParserNEWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12890) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12891) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 94: + localctx = NewNEWSEQUENTIALIDContext(p, localctx) + p.EnterOuterAlt(localctx, 94) + { + p.SetState(12892) + p.Match(TSqlParserNEWSEQUENTIALID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12893) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12894) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 95: + localctx = NewROWCOUNT_BIGContext(p, localctx) + p.EnterOuterAlt(localctx, 95) + { + p.SetState(12895) + p.Match(TSqlParserROWCOUNT_BIG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12896) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12897) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 96: + localctx = NewSESSION_CONTEXTContext(p, localctx) + p.EnterOuterAlt(localctx, 96) + { + p.SetState(12898) + p.Match(TSqlParserSESSION_CONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12899) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12900) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*SESSION_CONTEXTContext).key = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12901) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 97: + localctx = NewXACT_STATEContext(p, localctx) + p.EnterOuterAlt(localctx, 97) + { + p.SetState(12902) + p.Match(TSqlParserXACT_STATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12903) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12904) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 98: + localctx = NewCASTContext(p, localctx) + p.EnterOuterAlt(localctx, 98) + { + p.SetState(12905) + p.Match(TSqlParserCAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12906) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12907) + p.expression(0) + } + { + p.SetState(12908) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12909) + p.Data_type() + } + { + p.SetState(12910) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 99: + localctx = NewTRY_CASTContext(p, localctx) + p.EnterOuterAlt(localctx, 99) + { + p.SetState(12912) + p.Match(TSqlParserTRY_CAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12913) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12914) + p.expression(0) + } + { + p.SetState(12915) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12916) + p.Data_type() + } + { + p.SetState(12917) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 100: + localctx = NewCONVERTContext(p, localctx) + p.EnterOuterAlt(localctx, 100) + { + p.SetState(12919) + p.Match(TSqlParserCONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12920) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12921) + + var _x = p.Data_type() + + localctx.(*CONVERTContext).convert_data_type = _x + } + { + p.SetState(12922) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12923) + + var _x = p.expression(0) + + localctx.(*CONVERTContext).convert_expression = _x + } + p.SetState(12926) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(12924) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12925) + + var _x = p.expression(0) + + localctx.(*CONVERTContext).style = _x + } + + } + { + p.SetState(12928) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 101: + localctx = NewCOALESCEContext(p, localctx) + p.EnterOuterAlt(localctx, 101) + { + p.SetState(12930) + p.Match(TSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12931) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12932) + p.Expression_list_() + } + { + p.SetState(12933) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 102: + localctx = NewCURSOR_ROWSContext(p, localctx) + p.EnterOuterAlt(localctx, 102) + { + p.SetState(12935) + p.Match(TSqlParserCURSOR_ROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 103: + localctx = NewFETCH_STATUSContext(p, localctx) + p.EnterOuterAlt(localctx, 103) + { + p.SetState(12936) + p.Match(TSqlParserFETCH_STATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 104: + localctx = NewCURSOR_STATUSContext(p, localctx) + p.EnterOuterAlt(localctx, 104) + { + p.SetState(12937) + p.Match(TSqlParserCURSOR_STATUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12938) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12939) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*CURSOR_STATUSContext).scope = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12940) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12941) + + var _x = p.expression(0) + + localctx.(*CURSOR_STATUSContext).cursor = _x + } + { + p.SetState(12942) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 105: + localctx = NewCERT_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 105) + { + p.SetState(12944) + p.Match(TSqlParserCERT_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12945) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12946) + + var _x = p.expression(0) + + localctx.(*CERT_IDContext).cert_name = _x + } + { + p.SetState(12947) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 106: + localctx = NewDATALENGTHContext(p, localctx) + p.EnterOuterAlt(localctx, 106) + { + p.SetState(12949) + p.Match(TSqlParserDATALENGTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12950) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12951) + p.expression(0) + } + { + p.SetState(12952) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 107: + localctx = NewIDENT_CURRENTContext(p, localctx) + p.EnterOuterAlt(localctx, 107) + { + p.SetState(12954) + p.Match(TSqlParserIDENT_CURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12955) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12956) + + var _x = p.expression(0) + + localctx.(*IDENT_CURRENTContext).table_or_view = _x + } + { + p.SetState(12957) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 108: + localctx = NewIDENT_INCRContext(p, localctx) + p.EnterOuterAlt(localctx, 108) + { + p.SetState(12959) + p.Match(TSqlParserIDENT_INCR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12960) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12961) + + var _x = p.expression(0) + + localctx.(*IDENT_INCRContext).table_or_view = _x + } + { + p.SetState(12962) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 109: + localctx = NewIDENT_SEEDContext(p, localctx) + p.EnterOuterAlt(localctx, 109) + { + p.SetState(12964) + p.Match(TSqlParserIDENT_SEED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12965) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12966) + + var _x = p.expression(0) + + localctx.(*IDENT_SEEDContext).table_or_view = _x + } + { + p.SetState(12967) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 110: + localctx = NewIDENTITYContext(p, localctx) + p.EnterOuterAlt(localctx, 110) + { + p.SetState(12969) + p.Match(TSqlParserIDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12970) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12971) + + var _x = p.Data_type() + + localctx.(*IDENTITYContext).datatype = _x + } + p.SetState(12976) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(12972) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12973) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*IDENTITYContext).seed = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12974) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12975) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*IDENTITYContext).increment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12978) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 111: + localctx = NewSQL_VARIANT_PROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 111) + { + p.SetState(12980) + p.Match(TSqlParserSQL_VARIANT_PROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12981) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12982) + + var _x = p.expression(0) + + localctx.(*SQL_VARIANT_PROPERTYContext).expr = _x + } + { + p.SetState(12983) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12984) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*SQL_VARIANT_PROPERTYContext).property = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12985) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 112: + localctx = NewCURRENT_DATEContext(p, localctx) + p.EnterOuterAlt(localctx, 112) + { + p.SetState(12987) + p.Match(TSqlParserCURRENT_DATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12988) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12989) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 113: + localctx = NewCURRENT_TIMESTAMPContext(p, localctx) + p.EnterOuterAlt(localctx, 113) + { + p.SetState(12990) + p.Match(TSqlParserCURRENT_TIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 114: + localctx = NewCURRENT_TIMEZONEContext(p, localctx) + p.EnterOuterAlt(localctx, 114) + { + p.SetState(12991) + p.Match(TSqlParserCURRENT_TIMEZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12992) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12993) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 115: + localctx = NewCURRENT_TIMEZONE_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 115) + { + p.SetState(12994) + p.Match(TSqlParserCURRENT_TIMEZONE_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12995) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12996) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 116: + localctx = NewDATE_BUCKETContext(p, localctx) + p.EnterOuterAlt(localctx, 116) + { + p.SetState(12997) + p.Match(TSqlParserDATE_BUCKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12998) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12999) + + var _x = p.Dateparts_9() + + localctx.(*DATE_BUCKETContext).datepart = _x + } + { + p.SetState(13000) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13001) + + var _x = p.expression(0) + + localctx.(*DATE_BUCKETContext).number = _x + } + { + p.SetState(13002) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13003) + + var _x = p.expression(0) + + localctx.(*DATE_BUCKETContext).date = _x + } + p.SetState(13006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13004) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13005) + + var _x = p.expression(0) + + localctx.(*DATE_BUCKETContext).origin = _x + } + + } + { + p.SetState(13008) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 117: + localctx = NewDATEADDContext(p, localctx) + p.EnterOuterAlt(localctx, 117) + { + p.SetState(13010) + p.Match(TSqlParserDATEADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13011) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13012) + + var _x = p.Dateparts_12() + + localctx.(*DATEADDContext).datepart = _x + } + { + p.SetState(13013) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13014) + + var _x = p.expression(0) + + localctx.(*DATEADDContext).number = _x + } + { + p.SetState(13015) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13016) + + var _x = p.expression(0) + + localctx.(*DATEADDContext).date = _x + } + { + p.SetState(13017) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 118: + localctx = NewDATEDIFFContext(p, localctx) + p.EnterOuterAlt(localctx, 118) + { + p.SetState(13019) + p.Match(TSqlParserDATEDIFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13020) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13021) + + var _x = p.Dateparts_12() + + localctx.(*DATEDIFFContext).datepart = _x + } + { + p.SetState(13022) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13023) + + var _x = p.expression(0) + + localctx.(*DATEDIFFContext).date_first = _x + } + { + p.SetState(13024) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13025) + + var _x = p.expression(0) + + localctx.(*DATEDIFFContext).date_second = _x + } + { + p.SetState(13026) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 119: + localctx = NewDATEDIFF_BIGContext(p, localctx) + p.EnterOuterAlt(localctx, 119) + { + p.SetState(13028) + p.Match(TSqlParserDATEDIFF_BIG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13029) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13030) + + var _x = p.Dateparts_12() + + localctx.(*DATEDIFF_BIGContext).datepart = _x + } + { + p.SetState(13031) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13032) + + var _x = p.expression(0) + + localctx.(*DATEDIFF_BIGContext).startdate = _x + } + { + p.SetState(13033) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13034) + + var _x = p.expression(0) + + localctx.(*DATEDIFF_BIGContext).enddate = _x + } + { + p.SetState(13035) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 120: + localctx = NewDATEFROMPARTSContext(p, localctx) + p.EnterOuterAlt(localctx, 120) + { + p.SetState(13037) + p.Match(TSqlParserDATEFROMPARTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13038) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13039) + + var _x = p.expression(0) + + localctx.(*DATEFROMPARTSContext).year = _x + } + { + p.SetState(13040) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13041) + + var _x = p.expression(0) + + localctx.(*DATEFROMPARTSContext).month = _x + } + { + p.SetState(13042) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13043) + + var _x = p.expression(0) + + localctx.(*DATEFROMPARTSContext).day = _x + } + { + p.SetState(13044) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 121: + localctx = NewDATENAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 121) + { + p.SetState(13046) + p.Match(TSqlParserDATENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13047) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13048) + + var _x = p.Dateparts_15() + + localctx.(*DATENAMEContext).datepart = _x + } + { + p.SetState(13049) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13050) + + var _x = p.expression(0) + + localctx.(*DATENAMEContext).date = _x + } + { + p.SetState(13051) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 122: + localctx = NewDATEPARTContext(p, localctx) + p.EnterOuterAlt(localctx, 122) + { + p.SetState(13053) + p.Match(TSqlParserDATEPART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13054) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13055) + + var _x = p.Dateparts_15() + + localctx.(*DATEPARTContext).datepart = _x + } + { + p.SetState(13056) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13057) + + var _x = p.expression(0) + + localctx.(*DATEPARTContext).date = _x + } + { + p.SetState(13058) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 123: + localctx = NewDATETIME2FROMPARTSContext(p, localctx) + p.EnterOuterAlt(localctx, 123) + { + p.SetState(13060) + p.Match(TSqlParserDATETIME2FROMPARTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13061) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13062) + + var _x = p.expression(0) + + localctx.(*DATETIME2FROMPARTSContext).year = _x + } + { + p.SetState(13063) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13064) + + var _x = p.expression(0) + + localctx.(*DATETIME2FROMPARTSContext).month = _x + } + { + p.SetState(13065) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13066) + + var _x = p.expression(0) + + localctx.(*DATETIME2FROMPARTSContext).day = _x + } + { + p.SetState(13067) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13068) + + var _x = p.expression(0) + + localctx.(*DATETIME2FROMPARTSContext).hour = _x + } + { + p.SetState(13069) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13070) + + var _x = p.expression(0) + + localctx.(*DATETIME2FROMPARTSContext).minute = _x + } + { + p.SetState(13071) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13072) + + var _x = p.expression(0) + + localctx.(*DATETIME2FROMPARTSContext).seconds = _x + } + { + p.SetState(13073) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13074) + + var _x = p.expression(0) + + localctx.(*DATETIME2FROMPARTSContext).fractions = _x + } + { + p.SetState(13075) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13076) + + var _x = p.expression(0) + + localctx.(*DATETIME2FROMPARTSContext).precision = _x + } + { + p.SetState(13077) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 124: + localctx = NewDATETIMEFROMPARTSContext(p, localctx) + p.EnterOuterAlt(localctx, 124) + { + p.SetState(13079) + p.Match(TSqlParserDATETIMEFROMPARTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13080) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13081) + + var _x = p.expression(0) + + localctx.(*DATETIMEFROMPARTSContext).year = _x + } + { + p.SetState(13082) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13083) + + var _x = p.expression(0) + + localctx.(*DATETIMEFROMPARTSContext).month = _x + } + { + p.SetState(13084) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13085) + + var _x = p.expression(0) + + localctx.(*DATETIMEFROMPARTSContext).day = _x + } + { + p.SetState(13086) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13087) + + var _x = p.expression(0) + + localctx.(*DATETIMEFROMPARTSContext).hour = _x + } + { + p.SetState(13088) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13089) + + var _x = p.expression(0) + + localctx.(*DATETIMEFROMPARTSContext).minute = _x + } + { + p.SetState(13090) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13091) + + var _x = p.expression(0) + + localctx.(*DATETIMEFROMPARTSContext).seconds = _x + } + { + p.SetState(13092) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13093) + + var _x = p.expression(0) + + localctx.(*DATETIMEFROMPARTSContext).milliseconds = _x + } + { + p.SetState(13094) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 125: + localctx = NewDATETIMEOFFSETFROMPARTSContext(p, localctx) + p.EnterOuterAlt(localctx, 125) + { + p.SetState(13096) + p.Match(TSqlParserDATETIMEOFFSETFROMPARTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13097) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13098) + + var _x = p.expression(0) + + localctx.(*DATETIMEOFFSETFROMPARTSContext).year = _x + } + { + p.SetState(13099) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13100) + + var _x = p.expression(0) + + localctx.(*DATETIMEOFFSETFROMPARTSContext).month = _x + } + { + p.SetState(13101) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13102) + + var _x = p.expression(0) + + localctx.(*DATETIMEOFFSETFROMPARTSContext).day = _x + } + { + p.SetState(13103) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13104) + + var _x = p.expression(0) + + localctx.(*DATETIMEOFFSETFROMPARTSContext).hour = _x + } + { + p.SetState(13105) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13106) + + var _x = p.expression(0) + + localctx.(*DATETIMEOFFSETFROMPARTSContext).minute = _x + } + { + p.SetState(13107) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13108) + + var _x = p.expression(0) + + localctx.(*DATETIMEOFFSETFROMPARTSContext).seconds = _x + } + { + p.SetState(13109) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13110) + + var _x = p.expression(0) + + localctx.(*DATETIMEOFFSETFROMPARTSContext).fractions = _x + } + { + p.SetState(13111) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13112) + + var _x = p.expression(0) + + localctx.(*DATETIMEOFFSETFROMPARTSContext).hour_offset = _x + } + { + p.SetState(13113) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13114) + + var _x = p.expression(0) + + localctx.(*DATETIMEOFFSETFROMPARTSContext).minute_offset = _x + } + { + p.SetState(13115) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13116) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*DATETIMEOFFSETFROMPARTSContext).precision = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13117) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 126: + localctx = NewDATETRUNCContext(p, localctx) + p.EnterOuterAlt(localctx, 126) + { + p.SetState(13119) + p.Match(TSqlParserDATETRUNC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13120) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13121) + + var _x = p.Dateparts_datetrunc() + + localctx.(*DATETRUNCContext).datepart = _x + } + { + p.SetState(13122) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13123) + + var _x = p.expression(0) + + localctx.(*DATETRUNCContext).date = _x + } + { + p.SetState(13124) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 127: + localctx = NewDAYContext(p, localctx) + p.EnterOuterAlt(localctx, 127) + { + p.SetState(13126) + p.Match(TSqlParserDAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13127) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13128) + + var _x = p.expression(0) + + localctx.(*DAYContext).date = _x + } + { + p.SetState(13129) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 128: + localctx = NewEOMONTHContext(p, localctx) + p.EnterOuterAlt(localctx, 128) + { + p.SetState(13131) + p.Match(TSqlParserEOMONTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13132) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13133) + + var _x = p.expression(0) + + localctx.(*EOMONTHContext).start_date = _x + } + p.SetState(13136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13134) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13135) + + var _x = p.expression(0) + + localctx.(*EOMONTHContext).month_to_add = _x + } + + } + { + p.SetState(13138) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 129: + localctx = NewGETDATEContext(p, localctx) + p.EnterOuterAlt(localctx, 129) + { + p.SetState(13140) + p.Match(TSqlParserGETDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13141) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13142) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 130: + localctx = NewGETUTCDATEContext(p, localctx) + p.EnterOuterAlt(localctx, 130) + { + p.SetState(13143) + p.Match(TSqlParserGETUTCDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13144) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13145) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 131: + localctx = NewISDATEContext(p, localctx) + p.EnterOuterAlt(localctx, 131) + { + p.SetState(13146) + p.Match(TSqlParserISDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13147) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13148) + p.expression(0) + } + { + p.SetState(13149) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 132: + localctx = NewMONTHContext(p, localctx) + p.EnterOuterAlt(localctx, 132) + { + p.SetState(13151) + p.Match(TSqlParserMONTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13152) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13153) + + var _x = p.expression(0) + + localctx.(*MONTHContext).date = _x + } + { + p.SetState(13154) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 133: + localctx = NewSMALLDATETIMEFROMPARTSContext(p, localctx) + p.EnterOuterAlt(localctx, 133) + { + p.SetState(13156) + p.Match(TSqlParserSMALLDATETIMEFROMPARTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13157) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13158) + + var _x = p.expression(0) + + localctx.(*SMALLDATETIMEFROMPARTSContext).year = _x + } + { + p.SetState(13159) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13160) + + var _x = p.expression(0) + + localctx.(*SMALLDATETIMEFROMPARTSContext).month = _x + } + { + p.SetState(13161) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13162) + + var _x = p.expression(0) + + localctx.(*SMALLDATETIMEFROMPARTSContext).day = _x + } + { + p.SetState(13163) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13164) + + var _x = p.expression(0) + + localctx.(*SMALLDATETIMEFROMPARTSContext).hour = _x + } + { + p.SetState(13165) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13166) + + var _x = p.expression(0) + + localctx.(*SMALLDATETIMEFROMPARTSContext).minute = _x + } + { + p.SetState(13167) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 134: + localctx = NewSWITCHOFFSETContext(p, localctx) + p.EnterOuterAlt(localctx, 134) + { + p.SetState(13169) + p.Match(TSqlParserSWITCHOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13170) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13171) + + var _x = p.expression(0) + + localctx.(*SWITCHOFFSETContext).datetimeoffset_expression = _x + } + { + p.SetState(13172) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13173) + + var _x = p.expression(0) + + localctx.(*SWITCHOFFSETContext).timezoneoffset_expression = _x + } + { + p.SetState(13174) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 135: + localctx = NewSYSDATETIMEContext(p, localctx) + p.EnterOuterAlt(localctx, 135) + { + p.SetState(13176) + p.Match(TSqlParserSYSDATETIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13177) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13178) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 136: + localctx = NewSYSDATETIMEOFFSETContext(p, localctx) + p.EnterOuterAlt(localctx, 136) + { + p.SetState(13179) + p.Match(TSqlParserSYSDATETIMEOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13180) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13181) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 137: + localctx = NewSYSUTCDATETIMEContext(p, localctx) + p.EnterOuterAlt(localctx, 137) + { + p.SetState(13182) + p.Match(TSqlParserSYSUTCDATETIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13183) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13184) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 138: + localctx = NewTIMEFROMPARTSContext(p, localctx) + p.EnterOuterAlt(localctx, 138) + { + p.SetState(13185) + p.Match(TSqlParserTIMEFROMPARTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13186) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13187) + + var _x = p.expression(0) + + localctx.(*TIMEFROMPARTSContext).hour = _x + } + { + p.SetState(13188) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13189) + + var _x = p.expression(0) + + localctx.(*TIMEFROMPARTSContext).minute = _x + } + { + p.SetState(13190) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13191) + + var _x = p.expression(0) + + localctx.(*TIMEFROMPARTSContext).seconds = _x + } + { + p.SetState(13192) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13193) + + var _x = p.expression(0) + + localctx.(*TIMEFROMPARTSContext).fractions = _x + } + { + p.SetState(13194) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13195) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*TIMEFROMPARTSContext).precision = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13196) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 139: + localctx = NewTODATETIMEOFFSETContext(p, localctx) + p.EnterOuterAlt(localctx, 139) + { + p.SetState(13198) + p.Match(TSqlParserTODATETIMEOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13199) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13200) + + var _x = p.expression(0) + + localctx.(*TODATETIMEOFFSETContext).datetime_expression = _x + } + { + p.SetState(13201) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13202) + + var _x = p.expression(0) + + localctx.(*TODATETIMEOFFSETContext).timezoneoffset_expression = _x + } + { + p.SetState(13203) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 140: + localctx = NewYEARContext(p, localctx) + p.EnterOuterAlt(localctx, 140) + { + p.SetState(13205) + p.Match(TSqlParserYEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13206) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13207) + + var _x = p.expression(0) + + localctx.(*YEARContext).date = _x + } + { + p.SetState(13208) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 141: + localctx = NewIDENTITYContext(p, localctx) + p.EnterOuterAlt(localctx, 141) + { + p.SetState(13210) + p.Match(TSqlParserIDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13211) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13212) + p.Data_type() + } + p.SetState(13215) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1685, p.GetParserRuleContext()) == 1 { + { + p.SetState(13213) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13214) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*IDENTITYContext).seed = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13219) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13217) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13218) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*IDENTITYContext).increment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13221) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 142: + localctx = NewMIN_ACTIVE_ROWVERSIONContext(p, localctx) + p.EnterOuterAlt(localctx, 142) + { + p.SetState(13223) + p.Match(TSqlParserMIN_ACTIVE_ROWVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13224) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13225) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 143: + localctx = NewNULLIFContext(p, localctx) + p.EnterOuterAlt(localctx, 143) + { + p.SetState(13226) + p.Match(TSqlParserNULLIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13227) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13228) + + var _x = p.expression(0) + + localctx.(*NULLIFContext).left = _x + } + { + p.SetState(13229) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13230) + + var _x = p.expression(0) + + localctx.(*NULLIFContext).right = _x + } + { + p.SetState(13231) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 144: + localctx = NewPARSEContext(p, localctx) + p.EnterOuterAlt(localctx, 144) + { + p.SetState(13233) + p.Match(TSqlParserPARSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13234) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13235) + + var _x = p.expression(0) + + localctx.(*PARSEContext).str = _x + } + { + p.SetState(13236) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13237) + p.Data_type() + } + p.SetState(13240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserUSING { + { + p.SetState(13238) + p.Match(TSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13239) + + var _x = p.expression(0) + + localctx.(*PARSEContext).culture = _x + } + + } + { + p.SetState(13242) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 145: + localctx = NewXML_DATA_TYPE_FUNCContext(p, localctx) + p.EnterOuterAlt(localctx, 145) + { + p.SetState(13244) + p.Xml_data_type_methods() + } + + case 146: + localctx = NewIIFContext(p, localctx) + p.EnterOuterAlt(localctx, 146) + { + p.SetState(13245) + p.Match(TSqlParserIIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13246) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13247) + + var _x = p.search_condition(0) + + localctx.(*IIFContext).cond = _x + } + { + p.SetState(13248) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13249) + + var _x = p.expression(0) + + localctx.(*IIFContext).left = _x + } + { + p.SetState(13250) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13251) + + var _x = p.expression(0) + + localctx.(*IIFContext).right = _x + } + { + p.SetState(13252) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 147: + localctx = NewISJSONContext(p, localctx) + p.EnterOuterAlt(localctx, 147) + { + p.SetState(13254) + p.Match(TSqlParserISJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13255) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13256) + + var _x = p.expression(0) + + localctx.(*ISJSONContext).json_expr = _x + } + p.SetState(13259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13257) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13258) + + var _x = p.expression(0) + + localctx.(*ISJSONContext).json_type_constraint = _x + } + + } + { + p.SetState(13261) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 148: + localctx = NewJSON_OBJECTContext(p, localctx) + p.EnterOuterAlt(localctx, 148) + { + p.SetState(13263) + p.Match(TSqlParserJSON_OBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13264) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13273) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1690, p.GetParserRuleContext()) == 1 { + { + p.SetState(13265) + + var _x = p.Json_key_value() + + localctx.(*JSON_OBJECTContext).key_value = _x + } + p.SetState(13270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(13266) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13267) + + var _x = p.Json_key_value() + + localctx.(*JSON_OBJECTContext).key_value = _x + } + + p.SetState(13272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserABSENT || _la == TSqlParserNULL_ { + { + p.SetState(13275) + p.Json_null_clause() + } + + } + { + p.SetState(13278) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 149: + localctx = NewJSON_ARRAYContext(p, localctx) + p.EnterOuterAlt(localctx, 149) + { + p.SetState(13279) + p.Match(TSqlParserJSON_ARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13280) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13282) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1692, p.GetParserRuleContext()) == 1 { + { + p.SetState(13281) + p.Expression_list_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13285) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserABSENT || _la == TSqlParserNULL_ { + { + p.SetState(13284) + p.Json_null_clause() + } + + } + { + p.SetState(13287) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 150: + localctx = NewJSON_VALUEContext(p, localctx) + p.EnterOuterAlt(localctx, 150) + { + p.SetState(13288) + p.Match(TSqlParserJSON_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13289) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13290) + + var _x = p.expression(0) + + localctx.(*JSON_VALUEContext).expr = _x + } + { + p.SetState(13291) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13292) + + var _x = p.expression(0) + + localctx.(*JSON_VALUEContext).path = _x + } + { + p.SetState(13293) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 151: + localctx = NewJSON_QUERYContext(p, localctx) + p.EnterOuterAlt(localctx, 151) + { + p.SetState(13295) + p.Match(TSqlParserJSON_QUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13296) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13297) + + var _x = p.expression(0) + + localctx.(*JSON_QUERYContext).expr = _x + } + p.SetState(13300) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13298) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13299) + + var _x = p.expression(0) + + localctx.(*JSON_QUERYContext).path = _x + } + + } + { + p.SetState(13302) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 152: + localctx = NewJSON_MODIFYContext(p, localctx) + p.EnterOuterAlt(localctx, 152) + { + p.SetState(13304) + p.Match(TSqlParserJSON_MODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13305) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13306) + + var _x = p.expression(0) + + localctx.(*JSON_MODIFYContext).expr = _x + } + { + p.SetState(13307) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13308) + + var _x = p.expression(0) + + localctx.(*JSON_MODIFYContext).path = _x + } + { + p.SetState(13309) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13310) + + var _x = p.expression(0) + + localctx.(*JSON_MODIFYContext).new_value = _x + } + { + p.SetState(13311) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 153: + localctx = NewJSON_PATH_EXISTSContext(p, localctx) + p.EnterOuterAlt(localctx, 153) + { + p.SetState(13313) + p.Match(TSqlParserJSON_PATH_EXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13314) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13315) + + var _x = p.expression(0) + + localctx.(*JSON_PATH_EXISTSContext).value_expression = _x + } + { + p.SetState(13316) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13317) + + var _x = p.expression(0) + + localctx.(*JSON_PATH_EXISTSContext).sql_json_path = _x + } + { + p.SetState(13318) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 154: + localctx = NewABSContext(p, localctx) + p.EnterOuterAlt(localctx, 154) + { + p.SetState(13320) + p.Match(TSqlParserABS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13321) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13322) + + var _x = p.expression(0) + + localctx.(*ABSContext).numeric_expression = _x + } + { + p.SetState(13323) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 155: + localctx = NewACOSContext(p, localctx) + p.EnterOuterAlt(localctx, 155) + { + p.SetState(13325) + p.Match(TSqlParserACOS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13326) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13327) + + var _x = p.expression(0) + + localctx.(*ACOSContext).float_expression = _x + } + { + p.SetState(13328) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 156: + localctx = NewASINContext(p, localctx) + p.EnterOuterAlt(localctx, 156) + { + p.SetState(13330) + p.Match(TSqlParserASIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13331) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13332) + + var _x = p.expression(0) + + localctx.(*ASINContext).float_expression = _x + } + { + p.SetState(13333) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 157: + localctx = NewATANContext(p, localctx) + p.EnterOuterAlt(localctx, 157) + { + p.SetState(13335) + p.Match(TSqlParserATAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13336) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13337) + + var _x = p.expression(0) + + localctx.(*ATANContext).float_expression = _x + } + { + p.SetState(13338) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 158: + localctx = NewATN2Context(p, localctx) + p.EnterOuterAlt(localctx, 158) + { + p.SetState(13340) + p.Match(TSqlParserATN2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13341) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13342) + + var _x = p.expression(0) + + localctx.(*ATN2Context).float_expression = _x + } + { + p.SetState(13343) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13344) + + var _x = p.expression(0) + + localctx.(*ATN2Context).float_expression = _x + } + { + p.SetState(13345) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 159: + localctx = NewCEILINGContext(p, localctx) + p.EnterOuterAlt(localctx, 159) + { + p.SetState(13347) + p.Match(TSqlParserCEILING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13348) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13349) + + var _x = p.expression(0) + + localctx.(*CEILINGContext).numeric_expression = _x + } + { + p.SetState(13350) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 160: + localctx = NewCOSContext(p, localctx) + p.EnterOuterAlt(localctx, 160) + { + p.SetState(13352) + p.Match(TSqlParserCOS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13353) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13354) + + var _x = p.expression(0) + + localctx.(*COSContext).float_expression = _x + } + { + p.SetState(13355) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 161: + localctx = NewCOTContext(p, localctx) + p.EnterOuterAlt(localctx, 161) + { + p.SetState(13357) + p.Match(TSqlParserCOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13358) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13359) + + var _x = p.expression(0) + + localctx.(*COTContext).float_expression = _x + } + { + p.SetState(13360) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 162: + localctx = NewDEGREESContext(p, localctx) + p.EnterOuterAlt(localctx, 162) + { + p.SetState(13362) + p.Match(TSqlParserDEGREES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13363) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13364) + + var _x = p.expression(0) + + localctx.(*DEGREESContext).numeric_expression = _x + } + { + p.SetState(13365) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 163: + localctx = NewEXPContext(p, localctx) + p.EnterOuterAlt(localctx, 163) + { + p.SetState(13367) + p.Match(TSqlParserEXP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13368) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13369) + + var _x = p.expression(0) + + localctx.(*EXPContext).float_expression = _x + } + { + p.SetState(13370) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 164: + localctx = NewFLOORContext(p, localctx) + p.EnterOuterAlt(localctx, 164) + { + p.SetState(13372) + p.Match(TSqlParserFLOOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13373) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13374) + + var _x = p.expression(0) + + localctx.(*FLOORContext).numeric_expression = _x + } + { + p.SetState(13375) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 165: + localctx = NewLOGContext(p, localctx) + p.EnterOuterAlt(localctx, 165) + { + p.SetState(13377) + p.Match(TSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13378) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13379) + + var _x = p.expression(0) + + localctx.(*LOGContext).float_expression = _x + } + p.SetState(13382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13380) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13381) + + var _x = p.expression(0) + + localctx.(*LOGContext).base = _x + } + + } + { + p.SetState(13384) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 166: + localctx = NewLOG10Context(p, localctx) + p.EnterOuterAlt(localctx, 166) + { + p.SetState(13386) + p.Match(TSqlParserLOG10) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13387) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13388) + + var _x = p.expression(0) + + localctx.(*LOG10Context).float_expression = _x + } + { + p.SetState(13389) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 167: + localctx = NewPIContext(p, localctx) + p.EnterOuterAlt(localctx, 167) + { + p.SetState(13391) + p.Match(TSqlParserPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13392) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13393) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 168: + localctx = NewPOWERContext(p, localctx) + p.EnterOuterAlt(localctx, 168) + { + p.SetState(13394) + p.Match(TSqlParserPOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13395) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13396) + + var _x = p.expression(0) + + localctx.(*POWERContext).float_expression = _x + } + { + p.SetState(13397) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13398) + + var _x = p.expression(0) + + localctx.(*POWERContext).y = _x + } + { + p.SetState(13399) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 169: + localctx = NewRADIANSContext(p, localctx) + p.EnterOuterAlt(localctx, 169) + { + p.SetState(13401) + p.Match(TSqlParserRADIANS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13402) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13403) + + var _x = p.expression(0) + + localctx.(*RADIANSContext).numeric_expression = _x + } + { + p.SetState(13404) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 170: + localctx = NewRANDContext(p, localctx) + p.EnterOuterAlt(localctx, 170) + { + p.SetState(13406) + p.Match(TSqlParserRAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13407) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(13408) + + var _x = p.expression(0) + + localctx.(*RANDContext).seed = _x + } + + } + { + p.SetState(13411) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 171: + localctx = NewROUNDContext(p, localctx) + p.EnterOuterAlt(localctx, 171) + { + p.SetState(13412) + p.Match(TSqlParserROUND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13413) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13414) + + var _x = p.expression(0) + + localctx.(*ROUNDContext).numeric_expression = _x + } + { + p.SetState(13415) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13416) + + var _x = p.expression(0) + + localctx.(*ROUNDContext).length = _x + } + p.SetState(13419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13417) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13418) + + var _x = p.expression(0) + + localctx.(*ROUNDContext).function = _x + } + + } + { + p.SetState(13421) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 172: + localctx = NewMATH_SIGNContext(p, localctx) + p.EnterOuterAlt(localctx, 172) + { + p.SetState(13423) + p.Match(TSqlParserSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13424) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13425) + + var _x = p.expression(0) + + localctx.(*MATH_SIGNContext).numeric_expression = _x + } + { + p.SetState(13426) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 173: + localctx = NewSINContext(p, localctx) + p.EnterOuterAlt(localctx, 173) + { + p.SetState(13428) + p.Match(TSqlParserSIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13429) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13430) + + var _x = p.expression(0) + + localctx.(*SINContext).float_expression = _x + } + { + p.SetState(13431) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 174: + localctx = NewSQRTContext(p, localctx) + p.EnterOuterAlt(localctx, 174) + { + p.SetState(13433) + p.Match(TSqlParserSQRT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13434) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13435) + + var _x = p.expression(0) + + localctx.(*SQRTContext).float_expression = _x + } + { + p.SetState(13436) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 175: + localctx = NewSQUAREContext(p, localctx) + p.EnterOuterAlt(localctx, 175) + { + p.SetState(13438) + p.Match(TSqlParserSQUARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13439) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13440) + + var _x = p.expression(0) + + localctx.(*SQUAREContext).float_expression = _x + } + { + p.SetState(13441) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 176: + localctx = NewTANContext(p, localctx) + p.EnterOuterAlt(localctx, 176) + { + p.SetState(13443) + p.Match(TSqlParserTAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13444) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13445) + + var _x = p.expression(0) + + localctx.(*TANContext).float_expression = _x + } + { + p.SetState(13446) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 177: + localctx = NewGREATESTContext(p, localctx) + p.EnterOuterAlt(localctx, 177) + { + p.SetState(13448) + p.Match(TSqlParserGREATEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13449) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13450) + p.Expression_list_() + } + { + p.SetState(13451) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 178: + localctx = NewLEASTContext(p, localctx) + p.EnterOuterAlt(localctx, 178) + { + p.SetState(13453) + p.Match(TSqlParserLEAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13454) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13455) + p.Expression_list_() + } + { + p.SetState(13456) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 179: + localctx = NewCERTENCODEDContext(p, localctx) + p.EnterOuterAlt(localctx, 179) + { + p.SetState(13458) + p.Match(TSqlParserCERTENCODED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13459) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13460) + + var _x = p.expression(0) + + localctx.(*CERTENCODEDContext).certid = _x + } + { + p.SetState(13461) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 180: + localctx = NewCERTPRIVATEKEYContext(p, localctx) + p.EnterOuterAlt(localctx, 180) + { + p.SetState(13463) + p.Match(TSqlParserCERTPRIVATEKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13464) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13465) + + var _x = p.expression(0) + + localctx.(*CERTPRIVATEKEYContext).certid = _x + } + { + p.SetState(13466) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13467) + + var _x = p.expression(0) + + localctx.(*CERTPRIVATEKEYContext).encryption_password = _x + } + p.SetState(13470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13468) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13469) + + var _x = p.expression(0) + + localctx.(*CERTPRIVATEKEYContext).decryption_pasword = _x + } + + } + { + p.SetState(13472) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 181: + localctx = NewCURRENT_USERContext(p, localctx) + p.EnterOuterAlt(localctx, 181) + { + p.SetState(13474) + p.Match(TSqlParserCURRENT_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 182: + localctx = NewDATABASE_PRINCIPAL_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 182) + { + p.SetState(13475) + p.Match(TSqlParserDATABASE_PRINCIPAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13476) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13478) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(13477) + + var _x = p.expression(0) + + localctx.(*DATABASE_PRINCIPAL_IDContext).principal_name = _x + } + + } + { + p.SetState(13480) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 183: + localctx = NewHAS_DBACCESSContext(p, localctx) + p.EnterOuterAlt(localctx, 183) + { + p.SetState(13481) + p.Match(TSqlParserHAS_DBACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13482) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13483) + + var _x = p.expression(0) + + localctx.(*HAS_DBACCESSContext).database_name = _x + } + { + p.SetState(13484) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 184: + localctx = NewHAS_PERMS_BY_NAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 184) + { + p.SetState(13486) + p.Match(TSqlParserHAS_PERMS_BY_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13487) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13488) + + var _x = p.expression(0) + + localctx.(*HAS_PERMS_BY_NAMEContext).securable = _x + } + { + p.SetState(13489) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13490) + + var _x = p.expression(0) + + localctx.(*HAS_PERMS_BY_NAMEContext).securable_class = _x + } + { + p.SetState(13491) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13492) + + var _x = p.expression(0) + + localctx.(*HAS_PERMS_BY_NAMEContext).permission = _x + } + p.SetState(13499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13493) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13494) + + var _x = p.expression(0) + + localctx.(*HAS_PERMS_BY_NAMEContext).sub_securable = _x + } + p.SetState(13497) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13495) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13496) + + var _x = p.expression(0) + + localctx.(*HAS_PERMS_BY_NAMEContext).sub_securable_class = _x + } + + } + + } + { + p.SetState(13501) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 185: + localctx = NewIS_MEMBERContext(p, localctx) + p.EnterOuterAlt(localctx, 185) + { + p.SetState(13503) + p.Match(TSqlParserIS_MEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13504) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13505) + + var _x = p.expression(0) + + localctx.(*IS_MEMBERContext).group_or_role = _x + } + { + p.SetState(13506) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 186: + localctx = NewIS_ROLEMEMBERContext(p, localctx) + p.EnterOuterAlt(localctx, 186) + { + p.SetState(13508) + p.Match(TSqlParserIS_ROLEMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13509) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13510) + + var _x = p.expression(0) + + localctx.(*IS_ROLEMEMBERContext).role = _x + } + p.SetState(13513) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13511) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13512) + + var _x = p.expression(0) + + localctx.(*IS_ROLEMEMBERContext).database_principal = _x + } + + } + { + p.SetState(13515) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 187: + localctx = NewIS_SRVROLEMEMBERContext(p, localctx) + p.EnterOuterAlt(localctx, 187) + { + p.SetState(13517) + p.Match(TSqlParserIS_SRVROLEMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13518) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13519) + + var _x = p.expression(0) + + localctx.(*IS_SRVROLEMEMBERContext).role = _x + } + p.SetState(13522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13520) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13521) + + var _x = p.expression(0) + + localctx.(*IS_SRVROLEMEMBERContext).login = _x + } + + } + { + p.SetState(13524) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 188: + localctx = NewLOGINPROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 188) + { + p.SetState(13526) + p.Match(TSqlParserLOGINPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13527) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13528) + + var _x = p.expression(0) + + localctx.(*LOGINPROPERTYContext).login_name = _x + } + { + p.SetState(13529) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13530) + + var _x = p.expression(0) + + localctx.(*LOGINPROPERTYContext).property_name = _x + } + { + p.SetState(13531) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 189: + localctx = NewORIGINAL_LOGINContext(p, localctx) + p.EnterOuterAlt(localctx, 189) + { + p.SetState(13533) + p.Match(TSqlParserORIGINAL_LOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13534) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13535) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 190: + localctx = NewPERMISSIONSContext(p, localctx) + p.EnterOuterAlt(localctx, 190) + { + p.SetState(13536) + p.Match(TSqlParserPERMISSIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13537) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13543) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(13538) + + var _x = p.expression(0) + + localctx.(*PERMISSIONSContext).object_id = _x + } + p.SetState(13541) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13539) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13540) + + var _x = p.expression(0) + + localctx.(*PERMISSIONSContext).column = _x + } + + } + + } + { + p.SetState(13545) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 191: + localctx = NewPWDENCRYPTContext(p, localctx) + p.EnterOuterAlt(localctx, 191) + { + p.SetState(13546) + p.Match(TSqlParserPWDENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13547) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13548) + + var _x = p.expression(0) + + localctx.(*PWDENCRYPTContext).password = _x + } + { + p.SetState(13549) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 192: + localctx = NewPWDCOMPAREContext(p, localctx) + p.EnterOuterAlt(localctx, 192) + { + p.SetState(13551) + p.Match(TSqlParserPWDCOMPARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13552) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13553) + + var _x = p.expression(0) + + localctx.(*PWDCOMPAREContext).clear_text_password = _x + } + { + p.SetState(13554) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13555) + + var _x = p.expression(0) + + localctx.(*PWDCOMPAREContext).password_hash = _x + } + p.SetState(13558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13556) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13557) + + var _x = p.expression(0) + + localctx.(*PWDCOMPAREContext).version = _x + } + + } + { + p.SetState(13560) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 193: + localctx = NewSESSION_USERContext(p, localctx) + p.EnterOuterAlt(localctx, 193) + { + p.SetState(13562) + p.Match(TSqlParserSESSION_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 194: + localctx = NewSESSIONPROPERTYContext(p, localctx) + p.EnterOuterAlt(localctx, 194) + { + p.SetState(13563) + p.Match(TSqlParserSESSIONPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13564) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13565) + + var _x = p.expression(0) + + localctx.(*SESSIONPROPERTYContext).option_name = _x + } + { + p.SetState(13566) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 195: + localctx = NewSUSER_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 195) + { + p.SetState(13568) + p.Match(TSqlParserSUSER_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13569) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(13570) + + var _x = p.expression(0) + + localctx.(*SUSER_IDContext).login = _x + } + + } + { + p.SetState(13573) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 196: + localctx = NewSUSER_SNAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 196) + { + p.SetState(13574) + p.Match(TSqlParserSUSER_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13575) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13577) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(13576) + + var _x = p.expression(0) + + localctx.(*SUSER_SNAMEContext).server_user_sid = _x + } + + } + { + p.SetState(13579) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 197: + localctx = NewSUSER_SIDContext(p, localctx) + p.EnterOuterAlt(localctx, 197) + { + p.SetState(13580) + p.Match(TSqlParserSUSER_SID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13581) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(13582) + + var _x = p.expression(0) + + localctx.(*SUSER_SIDContext).login = _x + } + p.SetState(13585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13583) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13584) + + var _x = p.expression(0) + + localctx.(*SUSER_SIDContext).param2 = _x + } + + } + + } + { + p.SetState(13589) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 198: + localctx = NewSUSER_SNAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 198) + { + p.SetState(13590) + p.Match(TSqlParserSUSER_SNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13591) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(13592) + + var _x = p.expression(0) + + localctx.(*SUSER_SNAMEContext).server_user_sid = _x + } + + } + { + p.SetState(13595) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 199: + localctx = NewSYSTEM_USERContext(p, localctx) + p.EnterOuterAlt(localctx, 199) + { + p.SetState(13596) + p.Match(TSqlParserSYSTEM_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 200: + localctx = NewUSERContext(p, localctx) + p.EnterOuterAlt(localctx, 200) + { + p.SetState(13597) + p.Match(TSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 201: + localctx = NewUSER_IDContext(p, localctx) + p.EnterOuterAlt(localctx, 201) + { + p.SetState(13598) + p.Match(TSqlParserUSER_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13599) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(13600) + + var _x = p.expression(0) + + localctx.(*USER_IDContext).user = _x + } + + } + { + p.SetState(13603) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 202: + localctx = NewUSER_NAMEContext(p, localctx) + p.EnterOuterAlt(localctx, 202) + { + p.SetState(13604) + p.Match(TSqlParserUSER_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13605) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13607) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-1)) & ^0x3f) == 0 && ((int64(1)<<(_la-1))&-108121661330423825) != 0) || ((int64((_la-65)) & ^0x3f) == 0 && ((int64(1)<<(_la-65))&-74399966291296265) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-149749120105448465) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2306687434212058177) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387490746373) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8753867308933840637) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9431627966972669) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4607112045755873263) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-35476698628097) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4611686170960668161) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-604634639327302145) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&6917528409165459451) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565893633) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659855902989) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&5116304681508150783) != 0) { + { + p.SetState(13606) + + var _x = p.expression(0) + + localctx.(*USER_NAMEContext).id = _x + } + + } + { + p.SetState(13609) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_data_type_methodsContext is an interface to support dynamic dispatch. +type IXml_data_type_methodsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Value_method() IValue_methodContext + Query_method() IQuery_methodContext + Exist_method() IExist_methodContext + Modify_method() IModify_methodContext + + // IsXml_data_type_methodsContext differentiates from other interfaces. + IsXml_data_type_methodsContext() +} + +type Xml_data_type_methodsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_data_type_methodsContext() *Xml_data_type_methodsContext { + var p = new(Xml_data_type_methodsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_data_type_methods + return p +} + +func InitEmptyXml_data_type_methodsContext(p *Xml_data_type_methodsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_xml_data_type_methods +} + +func (*Xml_data_type_methodsContext) IsXml_data_type_methodsContext() {} + +func NewXml_data_type_methodsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_data_type_methodsContext { + var p = new(Xml_data_type_methodsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_xml_data_type_methods + + return p +} + +func (s *Xml_data_type_methodsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_data_type_methodsContext) Value_method() IValue_methodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValue_methodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValue_methodContext) +} + +func (s *Xml_data_type_methodsContext) Query_method() IQuery_methodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_methodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_methodContext) +} + +func (s *Xml_data_type_methodsContext) Exist_method() IExist_methodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExist_methodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExist_methodContext) +} + +func (s *Xml_data_type_methodsContext) Modify_method() IModify_methodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_methodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_methodContext) +} + +func (s *Xml_data_type_methodsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_data_type_methodsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_data_type_methodsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterXml_data_type_methods(s) + } +} + +func (s *Xml_data_type_methodsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitXml_data_type_methods(s) + } +} + +func (s *Xml_data_type_methodsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitXml_data_type_methods(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Xml_data_type_methods() (localctx IXml_data_type_methodsContext) { + localctx = NewXml_data_type_methodsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1066, TSqlParserRULE_xml_data_type_methods) + p.SetState(13616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1715, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13612) + p.Value_method() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13613) + p.Query_method() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13614) + p.Exist_method() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13615) + p.Modify_method() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDateparts_9Context is an interface to support dynamic dispatch. +type IDateparts_9Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + YEAR() antlr.TerminalNode + YEAR_ABBR() antlr.TerminalNode + QUARTER() antlr.TerminalNode + QUARTER_ABBR() antlr.TerminalNode + MONTH() antlr.TerminalNode + MONTH_ABBR() antlr.TerminalNode + DAY() antlr.TerminalNode + DAY_ABBR() antlr.TerminalNode + WEEK() antlr.TerminalNode + WEEK_ABBR() antlr.TerminalNode + HOUR() antlr.TerminalNode + HOUR_ABBR() antlr.TerminalNode + MINUTE() antlr.TerminalNode + MINUTE_ABBR() antlr.TerminalNode + SECOND() antlr.TerminalNode + SECOND_ABBR() antlr.TerminalNode + MILLISECOND() antlr.TerminalNode + MILLISECOND_ABBR() antlr.TerminalNode + + // IsDateparts_9Context differentiates from other interfaces. + IsDateparts_9Context() +} + +type Dateparts_9Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDateparts_9Context() *Dateparts_9Context { + var p = new(Dateparts_9Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dateparts_9 + return p +} + +func InitEmptyDateparts_9Context(p *Dateparts_9Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dateparts_9 +} + +func (*Dateparts_9Context) IsDateparts_9Context() {} + +func NewDateparts_9Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dateparts_9Context { + var p = new(Dateparts_9Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dateparts_9 + + return p +} + +func (s *Dateparts_9Context) GetParser() antlr.Parser { return s.parser } + +func (s *Dateparts_9Context) YEAR() antlr.TerminalNode { + return s.GetToken(TSqlParserYEAR, 0) +} + +func (s *Dateparts_9Context) YEAR_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserYEAR_ABBR, 0) +} + +func (s *Dateparts_9Context) QUARTER() antlr.TerminalNode { + return s.GetToken(TSqlParserQUARTER, 0) +} + +func (s *Dateparts_9Context) QUARTER_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserQUARTER_ABBR, 0) +} + +func (s *Dateparts_9Context) MONTH() antlr.TerminalNode { + return s.GetToken(TSqlParserMONTH, 0) +} + +func (s *Dateparts_9Context) MONTH_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserMONTH_ABBR, 0) +} + +func (s *Dateparts_9Context) DAY() antlr.TerminalNode { + return s.GetToken(TSqlParserDAY, 0) +} + +func (s *Dateparts_9Context) DAY_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserDAY_ABBR, 0) +} + +func (s *Dateparts_9Context) WEEK() antlr.TerminalNode { + return s.GetToken(TSqlParserWEEK, 0) +} + +func (s *Dateparts_9Context) WEEK_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserWEEK_ABBR, 0) +} + +func (s *Dateparts_9Context) HOUR() antlr.TerminalNode { + return s.GetToken(TSqlParserHOUR, 0) +} + +func (s *Dateparts_9Context) HOUR_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserHOUR_ABBR, 0) +} + +func (s *Dateparts_9Context) MINUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUTE, 0) +} + +func (s *Dateparts_9Context) MINUTE_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUTE_ABBR, 0) +} + +func (s *Dateparts_9Context) SECOND() antlr.TerminalNode { + return s.GetToken(TSqlParserSECOND, 0) +} + +func (s *Dateparts_9Context) SECOND_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserSECOND_ABBR, 0) +} + +func (s *Dateparts_9Context) MILLISECOND() antlr.TerminalNode { + return s.GetToken(TSqlParserMILLISECOND, 0) +} + +func (s *Dateparts_9Context) MILLISECOND_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserMILLISECOND_ABBR, 0) +} + +func (s *Dateparts_9Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dateparts_9Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dateparts_9Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDateparts_9(s) + } +} + +func (s *Dateparts_9Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDateparts_9(s) + } +} + +func (s *Dateparts_9Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDateparts_9(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dateparts_9() (localctx IDateparts_9Context) { + localctx = NewDateparts_9Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1068, TSqlParserRULE_dateparts_9) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13618) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1126)) & ^0x3f) == 0 && ((int64(1)<<(_la-1126))&17029388297) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDateparts_12Context is an interface to support dynamic dispatch. +type IDateparts_12Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Dateparts_9() IDateparts_9Context + DAYOFYEAR() antlr.TerminalNode + DAYOFYEAR_ABBR() antlr.TerminalNode + MICROSECOND() antlr.TerminalNode + MICROSECOND_ABBR() antlr.TerminalNode + NANOSECOND() antlr.TerminalNode + NANOSECOND_ABBR() antlr.TerminalNode + + // IsDateparts_12Context differentiates from other interfaces. + IsDateparts_12Context() +} + +type Dateparts_12Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDateparts_12Context() *Dateparts_12Context { + var p = new(Dateparts_12Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dateparts_12 + return p +} + +func InitEmptyDateparts_12Context(p *Dateparts_12Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dateparts_12 +} + +func (*Dateparts_12Context) IsDateparts_12Context() {} + +func NewDateparts_12Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dateparts_12Context { + var p = new(Dateparts_12Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dateparts_12 + + return p +} + +func (s *Dateparts_12Context) GetParser() antlr.Parser { return s.parser } + +func (s *Dateparts_12Context) Dateparts_9() IDateparts_9Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDateparts_9Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDateparts_9Context) +} + +func (s *Dateparts_12Context) DAYOFYEAR() antlr.TerminalNode { + return s.GetToken(TSqlParserDAYOFYEAR, 0) +} + +func (s *Dateparts_12Context) DAYOFYEAR_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserDAYOFYEAR_ABBR, 0) +} + +func (s *Dateparts_12Context) MICROSECOND() antlr.TerminalNode { + return s.GetToken(TSqlParserMICROSECOND, 0) +} + +func (s *Dateparts_12Context) MICROSECOND_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserMICROSECOND_ABBR, 0) +} + +func (s *Dateparts_12Context) NANOSECOND() antlr.TerminalNode { + return s.GetToken(TSqlParserNANOSECOND, 0) +} + +func (s *Dateparts_12Context) NANOSECOND_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserNANOSECOND_ABBR, 0) +} + +func (s *Dateparts_12Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dateparts_12Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dateparts_12Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDateparts_12(s) + } +} + +func (s *Dateparts_12Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDateparts_12(s) + } +} + +func (s *Dateparts_12Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDateparts_12(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dateparts_12() (localctx IDateparts_12Context) { + localctx = NewDateparts_12Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1070, TSqlParserRULE_dateparts_12) + p.SetState(13627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDAY, TSqlParserMONTH, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13620) + p.Dateparts_9() + } + + case TSqlParserDAYOFYEAR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13621) + p.Match(TSqlParserDAYOFYEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDAYOFYEAR_ABBR: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13622) + p.Match(TSqlParserDAYOFYEAR_ABBR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMICROSECOND: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13623) + p.Match(TSqlParserMICROSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMICROSECOND_ABBR: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13624) + p.Match(TSqlParserMICROSECOND_ABBR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNANOSECOND: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13625) + p.Match(TSqlParserNANOSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNANOSECOND_ABBR: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(13626) + p.Match(TSqlParserNANOSECOND_ABBR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDateparts_15Context is an interface to support dynamic dispatch. +type IDateparts_15Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Dateparts_12() IDateparts_12Context + WEEKDAY() antlr.TerminalNode + WEEKDAY_ABBR() antlr.TerminalNode + TZOFFSET() antlr.TerminalNode + TZOFFSET_ABBR() antlr.TerminalNode + ISO_WEEK() antlr.TerminalNode + ISO_WEEK_ABBR() antlr.TerminalNode + + // IsDateparts_15Context differentiates from other interfaces. + IsDateparts_15Context() +} + +type Dateparts_15Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDateparts_15Context() *Dateparts_15Context { + var p = new(Dateparts_15Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dateparts_15 + return p +} + +func InitEmptyDateparts_15Context(p *Dateparts_15Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dateparts_15 +} + +func (*Dateparts_15Context) IsDateparts_15Context() {} + +func NewDateparts_15Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dateparts_15Context { + var p = new(Dateparts_15Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dateparts_15 + + return p +} + +func (s *Dateparts_15Context) GetParser() antlr.Parser { return s.parser } + +func (s *Dateparts_15Context) Dateparts_12() IDateparts_12Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDateparts_12Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDateparts_12Context) +} + +func (s *Dateparts_15Context) WEEKDAY() antlr.TerminalNode { + return s.GetToken(TSqlParserWEEKDAY, 0) +} + +func (s *Dateparts_15Context) WEEKDAY_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserWEEKDAY_ABBR, 0) +} + +func (s *Dateparts_15Context) TZOFFSET() antlr.TerminalNode { + return s.GetToken(TSqlParserTZOFFSET, 0) +} + +func (s *Dateparts_15Context) TZOFFSET_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserTZOFFSET_ABBR, 0) +} + +func (s *Dateparts_15Context) ISO_WEEK() antlr.TerminalNode { + return s.GetToken(TSqlParserISO_WEEK, 0) +} + +func (s *Dateparts_15Context) ISO_WEEK_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserISO_WEEK_ABBR, 0) +} + +func (s *Dateparts_15Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dateparts_15Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dateparts_15Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDateparts_15(s) + } +} + +func (s *Dateparts_15Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDateparts_15(s) + } +} + +func (s *Dateparts_15Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDateparts_15(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dateparts_15() (localctx IDateparts_15Context) { + localctx = NewDateparts_15Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1072, TSqlParserRULE_dateparts_15) + p.SetState(13636) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDAY, TSqlParserMONTH, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13629) + p.Dateparts_12() + } + + case TSqlParserWEEKDAY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13630) + p.Match(TSqlParserWEEKDAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserWEEKDAY_ABBR: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13631) + p.Match(TSqlParserWEEKDAY_ABBR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTZOFFSET: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13632) + p.Match(TSqlParserTZOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTZOFFSET_ABBR: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13633) + p.Match(TSqlParserTZOFFSET_ABBR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserISO_WEEK: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13634) + p.Match(TSqlParserISO_WEEK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserISO_WEEK_ABBR: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(13635) + p.Match(TSqlParserISO_WEEK_ABBR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDateparts_datetruncContext is an interface to support dynamic dispatch. +type IDateparts_datetruncContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Dateparts_9() IDateparts_9Context + DAYOFYEAR() antlr.TerminalNode + DAYOFYEAR_ABBR() antlr.TerminalNode + MICROSECOND() antlr.TerminalNode + MICROSECOND_ABBR() antlr.TerminalNode + ISO_WEEK() antlr.TerminalNode + ISO_WEEK_ABBR() antlr.TerminalNode + + // IsDateparts_datetruncContext differentiates from other interfaces. + IsDateparts_datetruncContext() +} + +type Dateparts_datetruncContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDateparts_datetruncContext() *Dateparts_datetruncContext { + var p = new(Dateparts_datetruncContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dateparts_datetrunc + return p +} + +func InitEmptyDateparts_datetruncContext(p *Dateparts_datetruncContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dateparts_datetrunc +} + +func (*Dateparts_datetruncContext) IsDateparts_datetruncContext() {} + +func NewDateparts_datetruncContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dateparts_datetruncContext { + var p = new(Dateparts_datetruncContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dateparts_datetrunc + + return p +} + +func (s *Dateparts_datetruncContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dateparts_datetruncContext) Dateparts_9() IDateparts_9Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDateparts_9Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDateparts_9Context) +} + +func (s *Dateparts_datetruncContext) DAYOFYEAR() antlr.TerminalNode { + return s.GetToken(TSqlParserDAYOFYEAR, 0) +} + +func (s *Dateparts_datetruncContext) DAYOFYEAR_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserDAYOFYEAR_ABBR, 0) +} + +func (s *Dateparts_datetruncContext) MICROSECOND() antlr.TerminalNode { + return s.GetToken(TSqlParserMICROSECOND, 0) +} + +func (s *Dateparts_datetruncContext) MICROSECOND_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserMICROSECOND_ABBR, 0) +} + +func (s *Dateparts_datetruncContext) ISO_WEEK() antlr.TerminalNode { + return s.GetToken(TSqlParserISO_WEEK, 0) +} + +func (s *Dateparts_datetruncContext) ISO_WEEK_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserISO_WEEK_ABBR, 0) +} + +func (s *Dateparts_datetruncContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dateparts_datetruncContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dateparts_datetruncContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDateparts_datetrunc(s) + } +} + +func (s *Dateparts_datetruncContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDateparts_datetrunc(s) + } +} + +func (s *Dateparts_datetruncContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDateparts_datetrunc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Dateparts_datetrunc() (localctx IDateparts_datetruncContext) { + localctx = NewDateparts_datetruncContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1074, TSqlParserRULE_dateparts_datetrunc) + p.SetState(13645) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDAY, TSqlParserMONTH, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13638) + p.Dateparts_9() + } + + case TSqlParserDAYOFYEAR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13639) + p.Match(TSqlParserDAYOFYEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDAYOFYEAR_ABBR: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13640) + p.Match(TSqlParserDAYOFYEAR_ABBR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMICROSECOND: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13641) + p.Match(TSqlParserMICROSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserMICROSECOND_ABBR: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13642) + p.Match(TSqlParserMICROSECOND_ABBR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserISO_WEEK: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13643) + p.Match(TSqlParserISO_WEEK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserISO_WEEK_ABBR: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(13644) + p.Match(TSqlParserISO_WEEK_ABBR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IValue_methodContext is an interface to support dynamic dispatch. +type IValue_methodContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLoc_id returns the loc_id token. + GetLoc_id() antlr.Token + + // GetEventdata returns the eventdata token. + GetEventdata() antlr.Token + + // SetLoc_id sets the loc_id token. + SetLoc_id(antlr.Token) + + // SetEventdata sets the eventdata token. + SetEventdata(antlr.Token) + + // GetValue_id returns the value_id rule contexts. + GetValue_id() IFull_column_nameContext + + // GetQuery returns the query rule contexts. + GetQuery() IQuery_methodContext + + // GetCall returns the call rule contexts. + GetCall() IValue_callContext + + // SetValue_id sets the value_id rule contexts. + SetValue_id(IFull_column_nameContext) + + // SetQuery sets the query rule contexts. + SetQuery(IQuery_methodContext) + + // SetCall sets the call rule contexts. + SetCall(IValue_callContext) + + // Getter signatures + DOT() antlr.TerminalNode + Value_call() IValue_callContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Subquery() ISubqueryContext + LOCAL_ID() antlr.TerminalNode + Full_column_name() IFull_column_nameContext + EVENTDATA() antlr.TerminalNode + Query_method() IQuery_methodContext + + // IsValue_methodContext differentiates from other interfaces. + IsValue_methodContext() +} + +type Value_methodContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + loc_id antlr.Token + value_id IFull_column_nameContext + eventdata antlr.Token + query IQuery_methodContext + call IValue_callContext +} + +func NewEmptyValue_methodContext() *Value_methodContext { + var p = new(Value_methodContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_value_method + return p +} + +func InitEmptyValue_methodContext(p *Value_methodContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_value_method +} + +func (*Value_methodContext) IsValue_methodContext() {} + +func NewValue_methodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Value_methodContext { + var p = new(Value_methodContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_value_method + + return p +} + +func (s *Value_methodContext) GetParser() antlr.Parser { return s.parser } + +func (s *Value_methodContext) GetLoc_id() antlr.Token { return s.loc_id } + +func (s *Value_methodContext) GetEventdata() antlr.Token { return s.eventdata } + +func (s *Value_methodContext) SetLoc_id(v antlr.Token) { s.loc_id = v } + +func (s *Value_methodContext) SetEventdata(v antlr.Token) { s.eventdata = v } + +func (s *Value_methodContext) GetValue_id() IFull_column_nameContext { return s.value_id } + +func (s *Value_methodContext) GetQuery() IQuery_methodContext { return s.query } + +func (s *Value_methodContext) GetCall() IValue_callContext { return s.call } + +func (s *Value_methodContext) SetValue_id(v IFull_column_nameContext) { s.value_id = v } + +func (s *Value_methodContext) SetQuery(v IQuery_methodContext) { s.query = v } + +func (s *Value_methodContext) SetCall(v IValue_callContext) { s.call = v } + +func (s *Value_methodContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Value_methodContext) Value_call() IValue_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValue_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValue_callContext) +} + +func (s *Value_methodContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Value_methodContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Value_methodContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Value_methodContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Value_methodContext) Full_column_name() IFull_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *Value_methodContext) EVENTDATA() antlr.TerminalNode { + return s.GetToken(TSqlParserEVENTDATA, 0) +} + +func (s *Value_methodContext) Query_method() IQuery_methodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_methodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_methodContext) +} + +func (s *Value_methodContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Value_methodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Value_methodContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterValue_method(s) + } +} + +func (s *Value_methodContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitValue_method(s) + } +} + +func (s *Value_methodContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitValue_method(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Value_method() (localctx IValue_methodContext) { + localctx = NewValue_methodContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1076, TSqlParserRULE_value_method) + p.EnterOuterAlt(localctx, 1) + p.SetState(13657) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1719, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13647) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*Value_methodContext).loc_id = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(13648) + + var _x = p.Full_column_name() + + localctx.(*Value_methodContext).value_id = _x + } + + case 3: + { + p.SetState(13649) + + var _m = p.Match(TSqlParserEVENTDATA) + + localctx.(*Value_methodContext).eventdata = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13650) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13651) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(13652) + + var _x = p.Query_method() + + localctx.(*Value_methodContext).query = _x + } + + case 5: + { + p.SetState(13653) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13654) + p.Subquery() + } + { + p.SetState(13655) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(13659) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13660) + + var _x = p.Value_call() + + localctx.(*Value_methodContext).call = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IValue_callContext is an interface to support dynamic dispatch. +type IValue_callContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetXquery returns the xquery token. + GetXquery() antlr.Token + + // GetSqltype returns the sqltype token. + GetSqltype() antlr.Token + + // SetXquery sets the xquery token. + SetXquery(antlr.Token) + + // SetSqltype sets the sqltype token. + SetSqltype(antlr.Token) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + COMMA() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + VALUE() antlr.TerminalNode + VALUE_SQUARE_BRACKET() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + + // IsValue_callContext differentiates from other interfaces. + IsValue_callContext() +} + +type Value_callContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + xquery antlr.Token + sqltype antlr.Token +} + +func NewEmptyValue_callContext() *Value_callContext { + var p = new(Value_callContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_value_call + return p +} + +func InitEmptyValue_callContext(p *Value_callContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_value_call +} + +func (*Value_callContext) IsValue_callContext() {} + +func NewValue_callContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Value_callContext { + var p = new(Value_callContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_value_call + + return p +} + +func (s *Value_callContext) GetParser() antlr.Parser { return s.parser } + +func (s *Value_callContext) GetXquery() antlr.Token { return s.xquery } + +func (s *Value_callContext) GetSqltype() antlr.Token { return s.sqltype } + +func (s *Value_callContext) SetXquery(v antlr.Token) { s.xquery = v } + +func (s *Value_callContext) SetSqltype(v antlr.Token) { s.sqltype = v } + +func (s *Value_callContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Value_callContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Value_callContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Value_callContext) VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserVALUE, 0) +} + +func (s *Value_callContext) VALUE_SQUARE_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserVALUE_SQUARE_BRACKET, 0) +} + +func (s *Value_callContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Value_callContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Value_callContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Value_callContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Value_callContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterValue_call(s) + } +} + +func (s *Value_callContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitValue_call(s) + } +} + +func (s *Value_callContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitValue_call(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Value_call() (localctx IValue_callContext) { + localctx = NewValue_callContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1078, TSqlParserRULE_value_call) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13662) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserVALUE || _la == TSqlParserVALUE_SQUARE_BRACKET) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13663) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13664) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Value_callContext).xquery = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13665) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13666) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Value_callContext).sqltype = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13667) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_methodContext is an interface to support dynamic dispatch. +type IQuery_methodContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLoc_id returns the loc_id token. + GetLoc_id() antlr.Token + + // SetLoc_id sets the loc_id token. + SetLoc_id(antlr.Token) + + // GetValue_id returns the value_id rule contexts. + GetValue_id() IFull_column_nameContext + + // GetCall returns the call rule contexts. + GetCall() IQuery_callContext + + // SetValue_id sets the value_id rule contexts. + SetValue_id(IFull_column_nameContext) + + // SetCall sets the call rule contexts. + SetCall(IQuery_callContext) + + // Getter signatures + DOT() antlr.TerminalNode + Query_call() IQuery_callContext + LR_BRACKET() antlr.TerminalNode + Subquery() ISubqueryContext + RR_BRACKET() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + Full_column_name() IFull_column_nameContext + + // IsQuery_methodContext differentiates from other interfaces. + IsQuery_methodContext() +} + +type Query_methodContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + loc_id antlr.Token + value_id IFull_column_nameContext + call IQuery_callContext +} + +func NewEmptyQuery_methodContext() *Query_methodContext { + var p = new(Query_methodContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_query_method + return p +} + +func InitEmptyQuery_methodContext(p *Query_methodContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_query_method +} + +func (*Query_methodContext) IsQuery_methodContext() {} + +func NewQuery_methodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_methodContext { + var p = new(Query_methodContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_query_method + + return p +} + +func (s *Query_methodContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_methodContext) GetLoc_id() antlr.Token { return s.loc_id } + +func (s *Query_methodContext) SetLoc_id(v antlr.Token) { s.loc_id = v } + +func (s *Query_methodContext) GetValue_id() IFull_column_nameContext { return s.value_id } + +func (s *Query_methodContext) GetCall() IQuery_callContext { return s.call } + +func (s *Query_methodContext) SetValue_id(v IFull_column_nameContext) { s.value_id = v } + +func (s *Query_methodContext) SetCall(v IQuery_callContext) { s.call = v } + +func (s *Query_methodContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Query_methodContext) Query_call() IQuery_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_callContext) +} + +func (s *Query_methodContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Query_methodContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Query_methodContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Query_methodContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Query_methodContext) Full_column_name() IFull_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *Query_methodContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_methodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_methodContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterQuery_method(s) + } +} + +func (s *Query_methodContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitQuery_method(s) + } +} + +func (s *Query_methodContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitQuery_method(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Query_method() (localctx IQuery_methodContext) { + localctx = NewQuery_methodContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1080, TSqlParserRULE_query_method) + p.EnterOuterAlt(localctx, 1) + p.SetState(13675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLOCAL_ID: + { + p.SetState(13669) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*Query_methodContext).loc_id = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserDOLLAR: + { + p.SetState(13670) + + var _x = p.Full_column_name() + + localctx.(*Query_methodContext).value_id = _x + } + + case TSqlParserLR_BRACKET: + { + p.SetState(13671) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13672) + p.Subquery() + } + { + p.SetState(13673) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(13677) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13678) + + var _x = p.Query_call() + + localctx.(*Query_methodContext).call = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_callContext is an interface to support dynamic dispatch. +type IQuery_callContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetXquery returns the xquery token. + GetXquery() antlr.Token + + // SetXquery sets the xquery token. + SetXquery(antlr.Token) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + QUERY() antlr.TerminalNode + QUERY_SQUARE_BRACKET() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsQuery_callContext differentiates from other interfaces. + IsQuery_callContext() +} + +type Query_callContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + xquery antlr.Token +} + +func NewEmptyQuery_callContext() *Query_callContext { + var p = new(Query_callContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_query_call + return p +} + +func InitEmptyQuery_callContext(p *Query_callContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_query_call +} + +func (*Query_callContext) IsQuery_callContext() {} + +func NewQuery_callContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_callContext { + var p = new(Query_callContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_query_call + + return p +} + +func (s *Query_callContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_callContext) GetXquery() antlr.Token { return s.xquery } + +func (s *Query_callContext) SetXquery(v antlr.Token) { s.xquery = v } + +func (s *Query_callContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Query_callContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Query_callContext) QUERY() antlr.TerminalNode { + return s.GetToken(TSqlParserQUERY, 0) +} + +func (s *Query_callContext) QUERY_SQUARE_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserQUERY_SQUARE_BRACKET, 0) +} + +func (s *Query_callContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Query_callContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_callContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_callContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterQuery_call(s) + } +} + +func (s *Query_callContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitQuery_call(s) + } +} + +func (s *Query_callContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitQuery_call(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Query_call() (localctx IQuery_callContext) { + localctx = NewQuery_callContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1082, TSqlParserRULE_query_call) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13680) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserQUERY || _la == TSqlParserQUERY_SQUARE_BRACKET) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13681) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13682) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Query_callContext).xquery = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13683) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExist_methodContext is an interface to support dynamic dispatch. +type IExist_methodContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLoc_id returns the loc_id token. + GetLoc_id() antlr.Token + + // SetLoc_id sets the loc_id token. + SetLoc_id(antlr.Token) + + // GetValue_id returns the value_id rule contexts. + GetValue_id() IFull_column_nameContext + + // GetCall returns the call rule contexts. + GetCall() IExist_callContext + + // SetValue_id sets the value_id rule contexts. + SetValue_id(IFull_column_nameContext) + + // SetCall sets the call rule contexts. + SetCall(IExist_callContext) + + // Getter signatures + DOT() antlr.TerminalNode + Exist_call() IExist_callContext + LR_BRACKET() antlr.TerminalNode + Subquery() ISubqueryContext + RR_BRACKET() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + Full_column_name() IFull_column_nameContext + + // IsExist_methodContext differentiates from other interfaces. + IsExist_methodContext() +} + +type Exist_methodContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + loc_id antlr.Token + value_id IFull_column_nameContext + call IExist_callContext +} + +func NewEmptyExist_methodContext() *Exist_methodContext { + var p = new(Exist_methodContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_exist_method + return p +} + +func InitEmptyExist_methodContext(p *Exist_methodContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_exist_method +} + +func (*Exist_methodContext) IsExist_methodContext() {} + +func NewExist_methodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exist_methodContext { + var p = new(Exist_methodContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_exist_method + + return p +} + +func (s *Exist_methodContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exist_methodContext) GetLoc_id() antlr.Token { return s.loc_id } + +func (s *Exist_methodContext) SetLoc_id(v antlr.Token) { s.loc_id = v } + +func (s *Exist_methodContext) GetValue_id() IFull_column_nameContext { return s.value_id } + +func (s *Exist_methodContext) GetCall() IExist_callContext { return s.call } + +func (s *Exist_methodContext) SetValue_id(v IFull_column_nameContext) { s.value_id = v } + +func (s *Exist_methodContext) SetCall(v IExist_callContext) { s.call = v } + +func (s *Exist_methodContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Exist_methodContext) Exist_call() IExist_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExist_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExist_callContext) +} + +func (s *Exist_methodContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Exist_methodContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Exist_methodContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Exist_methodContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Exist_methodContext) Full_column_name() IFull_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *Exist_methodContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exist_methodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exist_methodContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExist_method(s) + } +} + +func (s *Exist_methodContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExist_method(s) + } +} + +func (s *Exist_methodContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExist_method(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Exist_method() (localctx IExist_methodContext) { + localctx = NewExist_methodContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1084, TSqlParserRULE_exist_method) + p.EnterOuterAlt(localctx, 1) + p.SetState(13691) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLOCAL_ID: + { + p.SetState(13685) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*Exist_methodContext).loc_id = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserDOLLAR: + { + p.SetState(13686) + + var _x = p.Full_column_name() + + localctx.(*Exist_methodContext).value_id = _x + } + + case TSqlParserLR_BRACKET: + { + p.SetState(13687) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13688) + p.Subquery() + } + { + p.SetState(13689) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(13693) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13694) + + var _x = p.Exist_call() + + localctx.(*Exist_methodContext).call = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExist_callContext is an interface to support dynamic dispatch. +type IExist_callContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetXquery returns the xquery token. + GetXquery() antlr.Token + + // SetXquery sets the xquery token. + SetXquery(antlr.Token) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + EXIST() antlr.TerminalNode + EXIST_SQUARE_BRACKET() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsExist_callContext differentiates from other interfaces. + IsExist_callContext() +} + +type Exist_callContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + xquery antlr.Token +} + +func NewEmptyExist_callContext() *Exist_callContext { + var p = new(Exist_callContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_exist_call + return p +} + +func InitEmptyExist_callContext(p *Exist_callContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_exist_call +} + +func (*Exist_callContext) IsExist_callContext() {} + +func NewExist_callContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exist_callContext { + var p = new(Exist_callContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_exist_call + + return p +} + +func (s *Exist_callContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exist_callContext) GetXquery() antlr.Token { return s.xquery } + +func (s *Exist_callContext) SetXquery(v antlr.Token) { s.xquery = v } + +func (s *Exist_callContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Exist_callContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Exist_callContext) EXIST() antlr.TerminalNode { + return s.GetToken(TSqlParserEXIST, 0) +} + +func (s *Exist_callContext) EXIST_SQUARE_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserEXIST_SQUARE_BRACKET, 0) +} + +func (s *Exist_callContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Exist_callContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exist_callContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exist_callContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExist_call(s) + } +} + +func (s *Exist_callContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExist_call(s) + } +} + +func (s *Exist_callContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExist_call(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Exist_call() (localctx IExist_callContext) { + localctx = NewExist_callContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1086, TSqlParserRULE_exist_call) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13696) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserEXIST || _la == TSqlParserEXIST_SQUARE_BRACKET) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13697) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13698) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Exist_callContext).xquery = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13699) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_methodContext is an interface to support dynamic dispatch. +type IModify_methodContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLoc_id returns the loc_id token. + GetLoc_id() antlr.Token + + // SetLoc_id sets the loc_id token. + SetLoc_id(antlr.Token) + + // GetValue_id returns the value_id rule contexts. + GetValue_id() IFull_column_nameContext + + // GetCall returns the call rule contexts. + GetCall() IModify_callContext + + // SetValue_id sets the value_id rule contexts. + SetValue_id(IFull_column_nameContext) + + // SetCall sets the call rule contexts. + SetCall(IModify_callContext) + + // Getter signatures + DOT() antlr.TerminalNode + Modify_call() IModify_callContext + LR_BRACKET() antlr.TerminalNode + Subquery() ISubqueryContext + RR_BRACKET() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + Full_column_name() IFull_column_nameContext + + // IsModify_methodContext differentiates from other interfaces. + IsModify_methodContext() +} + +type Modify_methodContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + loc_id antlr.Token + value_id IFull_column_nameContext + call IModify_callContext +} + +func NewEmptyModify_methodContext() *Modify_methodContext { + var p = new(Modify_methodContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_modify_method + return p +} + +func InitEmptyModify_methodContext(p *Modify_methodContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_modify_method +} + +func (*Modify_methodContext) IsModify_methodContext() {} + +func NewModify_methodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_methodContext { + var p = new(Modify_methodContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_modify_method + + return p +} + +func (s *Modify_methodContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_methodContext) GetLoc_id() antlr.Token { return s.loc_id } + +func (s *Modify_methodContext) SetLoc_id(v antlr.Token) { s.loc_id = v } + +func (s *Modify_methodContext) GetValue_id() IFull_column_nameContext { return s.value_id } + +func (s *Modify_methodContext) GetCall() IModify_callContext { return s.call } + +func (s *Modify_methodContext) SetValue_id(v IFull_column_nameContext) { s.value_id = v } + +func (s *Modify_methodContext) SetCall(v IModify_callContext) { s.call = v } + +func (s *Modify_methodContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Modify_methodContext) Modify_call() IModify_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_callContext) +} + +func (s *Modify_methodContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Modify_methodContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Modify_methodContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Modify_methodContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Modify_methodContext) Full_column_name() IFull_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *Modify_methodContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_methodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_methodContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterModify_method(s) + } +} + +func (s *Modify_methodContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitModify_method(s) + } +} + +func (s *Modify_methodContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitModify_method(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Modify_method() (localctx IModify_methodContext) { + localctx = NewModify_methodContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1088, TSqlParserRULE_modify_method) + p.EnterOuterAlt(localctx, 1) + p.SetState(13707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLOCAL_ID: + { + p.SetState(13701) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*Modify_methodContext).loc_id = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserDOLLAR: + { + p.SetState(13702) + + var _x = p.Full_column_name() + + localctx.(*Modify_methodContext).value_id = _x + } + + case TSqlParserLR_BRACKET: + { + p.SetState(13703) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13704) + p.Subquery() + } + { + p.SetState(13705) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(13709) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13710) + + var _x = p.Modify_call() + + localctx.(*Modify_methodContext).call = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_callContext is an interface to support dynamic dispatch. +type IModify_callContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetXml_dml returns the xml_dml token. + GetXml_dml() antlr.Token + + // SetXml_dml sets the xml_dml token. + SetXml_dml(antlr.Token) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + MODIFY() antlr.TerminalNode + MODIFY_SQUARE_BRACKET() antlr.TerminalNode + STRING() antlr.TerminalNode + + // IsModify_callContext differentiates from other interfaces. + IsModify_callContext() +} + +type Modify_callContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + xml_dml antlr.Token +} + +func NewEmptyModify_callContext() *Modify_callContext { + var p = new(Modify_callContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_modify_call + return p +} + +func InitEmptyModify_callContext(p *Modify_callContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_modify_call +} + +func (*Modify_callContext) IsModify_callContext() {} + +func NewModify_callContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_callContext { + var p = new(Modify_callContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_modify_call + + return p +} + +func (s *Modify_callContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_callContext) GetXml_dml() antlr.Token { return s.xml_dml } + +func (s *Modify_callContext) SetXml_dml(v antlr.Token) { s.xml_dml = v } + +func (s *Modify_callContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Modify_callContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Modify_callContext) MODIFY() antlr.TerminalNode { + return s.GetToken(TSqlParserMODIFY, 0) +} + +func (s *Modify_callContext) MODIFY_SQUARE_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserMODIFY_SQUARE_BRACKET, 0) +} + +func (s *Modify_callContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Modify_callContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_callContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_callContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterModify_call(s) + } +} + +func (s *Modify_callContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitModify_call(s) + } +} + +func (s *Modify_callContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitModify_call(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Modify_call() (localctx IModify_callContext) { + localctx = NewModify_callContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1090, TSqlParserRULE_modify_call) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13712) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserMODIFY || _la == TSqlParserMODIFY_SQUARE_BRACKET) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13713) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13714) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Modify_callContext).xml_dml = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13715) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHierarchyid_callContext is an interface to support dynamic dispatch. +type IHierarchyid_callContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetN returns the n rule contexts. + GetN() IExpressionContext + + // GetChild1 returns the child1 rule contexts. + GetChild1() IExpressionContext + + // GetChild2 returns the child2 rule contexts. + GetChild2() IExpressionContext + + // GetParent_ returns the parent_ rule contexts. + GetParent_() IExpressionContext + + // GetOldroot returns the oldroot rule contexts. + GetOldroot() IExpressionContext + + // GetNewroot returns the newroot rule contexts. + GetNewroot() IExpressionContext + + // SetN sets the n rule contexts. + SetN(IExpressionContext) + + // SetChild1 sets the child1 rule contexts. + SetChild1(IExpressionContext) + + // SetChild2 sets the child2 rule contexts. + SetChild2(IExpressionContext) + + // SetParent_ sets the parent_ rule contexts. + SetParent_(IExpressionContext) + + // SetOldroot sets the oldroot rule contexts. + SetOldroot(IExpressionContext) + + // SetNewroot sets the newroot rule contexts. + SetNewroot(IExpressionContext) + + // Getter signatures + GETANCESTOR() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + GETDESCENDANT() antlr.TerminalNode + COMMA() antlr.TerminalNode + GETLEVEL() antlr.TerminalNode + ISDESCENDANTOF() antlr.TerminalNode + GETREPARENTEDVALUE() antlr.TerminalNode + TOSTRING() antlr.TerminalNode + + // IsHierarchyid_callContext differentiates from other interfaces. + IsHierarchyid_callContext() +} + +type Hierarchyid_callContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + n IExpressionContext + child1 IExpressionContext + child2 IExpressionContext + parent_ IExpressionContext + oldroot IExpressionContext + newroot IExpressionContext +} + +func NewEmptyHierarchyid_callContext() *Hierarchyid_callContext { + var p = new(Hierarchyid_callContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_hierarchyid_call + return p +} + +func InitEmptyHierarchyid_callContext(p *Hierarchyid_callContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_hierarchyid_call +} + +func (*Hierarchyid_callContext) IsHierarchyid_callContext() {} + +func NewHierarchyid_callContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hierarchyid_callContext { + var p = new(Hierarchyid_callContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_hierarchyid_call + + return p +} + +func (s *Hierarchyid_callContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hierarchyid_callContext) GetN() IExpressionContext { return s.n } + +func (s *Hierarchyid_callContext) GetChild1() IExpressionContext { return s.child1 } + +func (s *Hierarchyid_callContext) GetChild2() IExpressionContext { return s.child2 } + +func (s *Hierarchyid_callContext) GetParent_() IExpressionContext { return s.parent_ } + +func (s *Hierarchyid_callContext) GetOldroot() IExpressionContext { return s.oldroot } + +func (s *Hierarchyid_callContext) GetNewroot() IExpressionContext { return s.newroot } + +func (s *Hierarchyid_callContext) SetN(v IExpressionContext) { s.n = v } + +func (s *Hierarchyid_callContext) SetChild1(v IExpressionContext) { s.child1 = v } + +func (s *Hierarchyid_callContext) SetChild2(v IExpressionContext) { s.child2 = v } + +func (s *Hierarchyid_callContext) SetParent_(v IExpressionContext) { s.parent_ = v } + +func (s *Hierarchyid_callContext) SetOldroot(v IExpressionContext) { s.oldroot = v } + +func (s *Hierarchyid_callContext) SetNewroot(v IExpressionContext) { s.newroot = v } + +func (s *Hierarchyid_callContext) GETANCESTOR() antlr.TerminalNode { + return s.GetToken(TSqlParserGETANCESTOR, 0) +} + +func (s *Hierarchyid_callContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Hierarchyid_callContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Hierarchyid_callContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Hierarchyid_callContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Hierarchyid_callContext) GETDESCENDANT() antlr.TerminalNode { + return s.GetToken(TSqlParserGETDESCENDANT, 0) +} + +func (s *Hierarchyid_callContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Hierarchyid_callContext) GETLEVEL() antlr.TerminalNode { + return s.GetToken(TSqlParserGETLEVEL, 0) +} + +func (s *Hierarchyid_callContext) ISDESCENDANTOF() antlr.TerminalNode { + return s.GetToken(TSqlParserISDESCENDANTOF, 0) +} + +func (s *Hierarchyid_callContext) GETREPARENTEDVALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserGETREPARENTEDVALUE, 0) +} + +func (s *Hierarchyid_callContext) TOSTRING() antlr.TerminalNode { + return s.GetToken(TSqlParserTOSTRING, 0) +} + +func (s *Hierarchyid_callContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hierarchyid_callContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hierarchyid_callContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterHierarchyid_call(s) + } +} + +func (s *Hierarchyid_callContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitHierarchyid_call(s) + } +} + +func (s *Hierarchyid_callContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitHierarchyid_call(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Hierarchyid_call() (localctx IHierarchyid_callContext) { + localctx = NewHierarchyid_callContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1092, TSqlParserRULE_hierarchyid_call) + p.SetState(13747) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserGETANCESTOR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13717) + p.Match(TSqlParserGETANCESTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13718) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13719) + + var _x = p.expression(0) + + localctx.(*Hierarchyid_callContext).n = _x + } + { + p.SetState(13720) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserGETDESCENDANT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13722) + p.Match(TSqlParserGETDESCENDANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13723) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13724) + + var _x = p.expression(0) + + localctx.(*Hierarchyid_callContext).child1 = _x + } + { + p.SetState(13725) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13726) + + var _x = p.expression(0) + + localctx.(*Hierarchyid_callContext).child2 = _x + } + { + p.SetState(13727) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserGETLEVEL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13729) + p.Match(TSqlParserGETLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13730) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13731) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserISDESCENDANTOF: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13732) + p.Match(TSqlParserISDESCENDANTOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13733) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13734) + + var _x = p.expression(0) + + localctx.(*Hierarchyid_callContext).parent_ = _x + } + { + p.SetState(13735) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserGETREPARENTEDVALUE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13737) + p.Match(TSqlParserGETREPARENTEDVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13738) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13739) + + var _x = p.expression(0) + + localctx.(*Hierarchyid_callContext).oldroot = _x + } + { + p.SetState(13740) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13741) + + var _x = p.expression(0) + + localctx.(*Hierarchyid_callContext).newroot = _x + } + { + p.SetState(13742) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTOSTRING: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13744) + p.Match(TSqlParserTOSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13745) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13746) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHierarchyid_static_methodContext is an interface to support dynamic dispatch. +type IHierarchyid_static_methodContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetInput returns the input rule contexts. + GetInput() IExpressionContext + + // SetInput sets the input rule contexts. + SetInput(IExpressionContext) + + // Getter signatures + HIERARCHYID() antlr.TerminalNode + DOUBLE_COLON() antlr.TerminalNode + GETROOT() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + PARSE() antlr.TerminalNode + Expression() IExpressionContext + + // IsHierarchyid_static_methodContext differentiates from other interfaces. + IsHierarchyid_static_methodContext() +} + +type Hierarchyid_static_methodContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + input IExpressionContext +} + +func NewEmptyHierarchyid_static_methodContext() *Hierarchyid_static_methodContext { + var p = new(Hierarchyid_static_methodContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_hierarchyid_static_method + return p +} + +func InitEmptyHierarchyid_static_methodContext(p *Hierarchyid_static_methodContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_hierarchyid_static_method +} + +func (*Hierarchyid_static_methodContext) IsHierarchyid_static_methodContext() {} + +func NewHierarchyid_static_methodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hierarchyid_static_methodContext { + var p = new(Hierarchyid_static_methodContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_hierarchyid_static_method + + return p +} + +func (s *Hierarchyid_static_methodContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hierarchyid_static_methodContext) GetInput() IExpressionContext { return s.input } + +func (s *Hierarchyid_static_methodContext) SetInput(v IExpressionContext) { s.input = v } + +func (s *Hierarchyid_static_methodContext) HIERARCHYID() antlr.TerminalNode { + return s.GetToken(TSqlParserHIERARCHYID, 0) +} + +func (s *Hierarchyid_static_methodContext) DOUBLE_COLON() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_COLON, 0) +} + +func (s *Hierarchyid_static_methodContext) GETROOT() antlr.TerminalNode { + return s.GetToken(TSqlParserGETROOT, 0) +} + +func (s *Hierarchyid_static_methodContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Hierarchyid_static_methodContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Hierarchyid_static_methodContext) PARSE() antlr.TerminalNode { + return s.GetToken(TSqlParserPARSE, 0) +} + +func (s *Hierarchyid_static_methodContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Hierarchyid_static_methodContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hierarchyid_static_methodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hierarchyid_static_methodContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterHierarchyid_static_method(s) + } +} + +func (s *Hierarchyid_static_methodContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitHierarchyid_static_method(s) + } +} + +func (s *Hierarchyid_static_methodContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitHierarchyid_static_method(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Hierarchyid_static_method() (localctx IHierarchyid_static_methodContext) { + localctx = NewHierarchyid_static_methodContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1094, TSqlParserRULE_hierarchyid_static_method) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13749) + p.Match(TSqlParserHIERARCHYID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13750) + p.Match(TSqlParserDOUBLE_COLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13759) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserGETROOT: + { + p.SetState(13751) + p.Match(TSqlParserGETROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13752) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13753) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPARSE: + { + p.SetState(13754) + p.Match(TSqlParserPARSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13755) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13756) + + var _x = p.expression(0) + + localctx.(*Hierarchyid_static_methodContext).input = _x + } + { + p.SetState(13757) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INodes_methodContext is an interface to support dynamic dispatch. +type INodes_methodContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLoc_id returns the loc_id token. + GetLoc_id() antlr.Token + + // GetXquery returns the xquery token. + GetXquery() antlr.Token + + // SetLoc_id sets the loc_id token. + SetLoc_id(antlr.Token) + + // SetXquery sets the xquery token. + SetXquery(antlr.Token) + + // GetValue_id returns the value_id rule contexts. + GetValue_id() IFull_column_nameContext + + // SetValue_id sets the value_id rule contexts. + SetValue_id(IFull_column_nameContext) + + // Getter signatures + DOT() antlr.TerminalNode + NODES() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + STRING() antlr.TerminalNode + Subquery() ISubqueryContext + LOCAL_ID() antlr.TerminalNode + Full_column_name() IFull_column_nameContext + + // IsNodes_methodContext differentiates from other interfaces. + IsNodes_methodContext() +} + +type Nodes_methodContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + loc_id antlr.Token + value_id IFull_column_nameContext + xquery antlr.Token +} + +func NewEmptyNodes_methodContext() *Nodes_methodContext { + var p = new(Nodes_methodContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_nodes_method + return p +} + +func InitEmptyNodes_methodContext(p *Nodes_methodContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_nodes_method +} + +func (*Nodes_methodContext) IsNodes_methodContext() {} + +func NewNodes_methodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Nodes_methodContext { + var p = new(Nodes_methodContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_nodes_method + + return p +} + +func (s *Nodes_methodContext) GetParser() antlr.Parser { return s.parser } + +func (s *Nodes_methodContext) GetLoc_id() antlr.Token { return s.loc_id } + +func (s *Nodes_methodContext) GetXquery() antlr.Token { return s.xquery } + +func (s *Nodes_methodContext) SetLoc_id(v antlr.Token) { s.loc_id = v } + +func (s *Nodes_methodContext) SetXquery(v antlr.Token) { s.xquery = v } + +func (s *Nodes_methodContext) GetValue_id() IFull_column_nameContext { return s.value_id } + +func (s *Nodes_methodContext) SetValue_id(v IFull_column_nameContext) { s.value_id = v } + +func (s *Nodes_methodContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Nodes_methodContext) NODES() antlr.TerminalNode { + return s.GetToken(TSqlParserNODES, 0) +} + +func (s *Nodes_methodContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Nodes_methodContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Nodes_methodContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Nodes_methodContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Nodes_methodContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Nodes_methodContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Nodes_methodContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Nodes_methodContext) Full_column_name() IFull_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *Nodes_methodContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Nodes_methodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Nodes_methodContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterNodes_method(s) + } +} + +func (s *Nodes_methodContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitNodes_method(s) + } +} + +func (s *Nodes_methodContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitNodes_method(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Nodes_method() (localctx INodes_methodContext) { + localctx = NewNodes_methodContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1096, TSqlParserRULE_nodes_method) + p.EnterOuterAlt(localctx, 1) + p.SetState(13767) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserLOCAL_ID: + { + p.SetState(13761) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*Nodes_methodContext).loc_id = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID, TSqlParserDOLLAR: + { + p.SetState(13762) + + var _x = p.Full_column_name() + + localctx.(*Nodes_methodContext).value_id = _x + } + + case TSqlParserLR_BRACKET: + { + p.SetState(13763) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13764) + p.Subquery() + } + { + p.SetState(13765) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(13769) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13770) + p.Match(TSqlParserNODES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13771) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13772) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Nodes_methodContext).xquery = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13773) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISwitch_sectionContext is an interface to support dynamic dispatch. +type ISwitch_sectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + THEN() antlr.TerminalNode + + // IsSwitch_sectionContext differentiates from other interfaces. + IsSwitch_sectionContext() +} + +type Switch_sectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySwitch_sectionContext() *Switch_sectionContext { + var p = new(Switch_sectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_switch_section + return p +} + +func InitEmptySwitch_sectionContext(p *Switch_sectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_switch_section +} + +func (*Switch_sectionContext) IsSwitch_sectionContext() {} + +func NewSwitch_sectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Switch_sectionContext { + var p = new(Switch_sectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_switch_section + + return p +} + +func (s *Switch_sectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Switch_sectionContext) WHEN() antlr.TerminalNode { + return s.GetToken(TSqlParserWHEN, 0) +} + +func (s *Switch_sectionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Switch_sectionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Switch_sectionContext) THEN() antlr.TerminalNode { + return s.GetToken(TSqlParserTHEN, 0) +} + +func (s *Switch_sectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Switch_sectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Switch_sectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSwitch_section(s) + } +} + +func (s *Switch_sectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSwitch_section(s) + } +} + +func (s *Switch_sectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSwitch_section(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Switch_section() (localctx ISwitch_sectionContext) { + localctx = NewSwitch_sectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1098, TSqlParserRULE_switch_section) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13775) + p.Match(TSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13776) + p.expression(0) + } + { + p.SetState(13777) + p.Match(TSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13778) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISwitch_search_condition_sectionContext is an interface to support dynamic dispatch. +type ISwitch_search_condition_sectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + Search_condition() ISearch_conditionContext + THEN() antlr.TerminalNode + Expression() IExpressionContext + + // IsSwitch_search_condition_sectionContext differentiates from other interfaces. + IsSwitch_search_condition_sectionContext() +} + +type Switch_search_condition_sectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySwitch_search_condition_sectionContext() *Switch_search_condition_sectionContext { + var p = new(Switch_search_condition_sectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_switch_search_condition_section + return p +} + +func InitEmptySwitch_search_condition_sectionContext(p *Switch_search_condition_sectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_switch_search_condition_section +} + +func (*Switch_search_condition_sectionContext) IsSwitch_search_condition_sectionContext() {} + +func NewSwitch_search_condition_sectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Switch_search_condition_sectionContext { + var p = new(Switch_search_condition_sectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_switch_search_condition_section + + return p +} + +func (s *Switch_search_condition_sectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Switch_search_condition_sectionContext) WHEN() antlr.TerminalNode { + return s.GetToken(TSqlParserWHEN, 0) +} + +func (s *Switch_search_condition_sectionContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Switch_search_condition_sectionContext) THEN() antlr.TerminalNode { + return s.GetToken(TSqlParserTHEN, 0) +} + +func (s *Switch_search_condition_sectionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Switch_search_condition_sectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Switch_search_condition_sectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Switch_search_condition_sectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSwitch_search_condition_section(s) + } +} + +func (s *Switch_search_condition_sectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSwitch_search_condition_section(s) + } +} + +func (s *Switch_search_condition_sectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSwitch_search_condition_section(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Switch_search_condition_section() (localctx ISwitch_search_condition_sectionContext) { + localctx = NewSwitch_search_condition_sectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1100, TSqlParserRULE_switch_search_condition_section) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13780) + p.Match(TSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13781) + p.search_condition(0) + } + { + p.SetState(13782) + p.Match(TSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13783) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAs_column_aliasContext is an interface to support dynamic dispatch. +type IAs_column_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_alias() IColumn_aliasContext + AS() antlr.TerminalNode + + // IsAs_column_aliasContext differentiates from other interfaces. + IsAs_column_aliasContext() +} + +type As_column_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAs_column_aliasContext() *As_column_aliasContext { + var p = new(As_column_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_as_column_alias + return p +} + +func InitEmptyAs_column_aliasContext(p *As_column_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_as_column_alias +} + +func (*As_column_aliasContext) IsAs_column_aliasContext() {} + +func NewAs_column_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *As_column_aliasContext { + var p = new(As_column_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_as_column_alias + + return p +} + +func (s *As_column_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *As_column_aliasContext) Column_alias() IColumn_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *As_column_aliasContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *As_column_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *As_column_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *As_column_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAs_column_alias(s) + } +} + +func (s *As_column_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAs_column_alias(s) + } +} + +func (s *As_column_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAs_column_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) As_column_alias() (localctx IAs_column_aliasContext) { + localctx = NewAs_column_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1102, TSqlParserRULE_as_column_alias) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13786) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(13785) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13788) + p.Column_alias() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAs_table_aliasContext is an interface to support dynamic dispatch. +type IAs_table_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_alias() ITable_aliasContext + AS() antlr.TerminalNode + + // IsAs_table_aliasContext differentiates from other interfaces. + IsAs_table_aliasContext() +} + +type As_table_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAs_table_aliasContext() *As_table_aliasContext { + var p = new(As_table_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_as_table_alias + return p +} + +func InitEmptyAs_table_aliasContext(p *As_table_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_as_table_alias +} + +func (*As_table_aliasContext) IsAs_table_aliasContext() {} + +func NewAs_table_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *As_table_aliasContext { + var p = new(As_table_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_as_table_alias + + return p +} + +func (s *As_table_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *As_table_aliasContext) Table_alias() ITable_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *As_table_aliasContext) AS() antlr.TerminalNode { + return s.GetToken(TSqlParserAS, 0) +} + +func (s *As_table_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *As_table_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *As_table_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAs_table_alias(s) + } +} + +func (s *As_table_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAs_table_alias(s) + } +} + +func (s *As_table_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAs_table_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) As_table_alias() (localctx IAs_table_aliasContext) { + localctx = NewAs_table_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1104, TSqlParserRULE_as_table_alias) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserAS { + { + p.SetState(13790) + p.Match(TSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13793) + p.Table_alias() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_aliasContext is an interface to support dynamic dispatch. +type ITable_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + + // IsTable_aliasContext differentiates from other interfaces. + IsTable_aliasContext() +} + +type Table_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_aliasContext() *Table_aliasContext { + var p = new(Table_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_alias + return p +} + +func InitEmptyTable_aliasContext(p *Table_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_alias +} + +func (*Table_aliasContext) IsTable_aliasContext() {} + +func NewTable_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_aliasContext { + var p = new(Table_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_table_alias + + return p +} + +func (s *Table_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_aliasContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Table_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTable_alias(s) + } +} + +func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTable_alias(s) + } +} + +func (s *Table_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTable_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Table_alias() (localctx ITable_aliasContext) { + localctx = NewTable_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1106, TSqlParserRULE_table_alias) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13795) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_table_hintsContext is an interface to support dynamic dispatch. +type IWith_table_hintsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_table_hint returns the _table_hint rule contexts. + Get_table_hint() ITable_hintContext + + // Set_table_hint sets the _table_hint rule contexts. + Set_table_hint(ITable_hintContext) + + // GetHint returns the hint rule context list. + GetHint() []ITable_hintContext + + // SetHint sets the hint rule context list. + SetHint([]ITable_hintContext) + + // Getter signatures + WITH() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllTable_hint() []ITable_hintContext + Table_hint(i int) ITable_hintContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsWith_table_hintsContext differentiates from other interfaces. + IsWith_table_hintsContext() +} + +type With_table_hintsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _table_hint ITable_hintContext + hint []ITable_hintContext +} + +func NewEmptyWith_table_hintsContext() *With_table_hintsContext { + var p = new(With_table_hintsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_with_table_hints + return p +} + +func InitEmptyWith_table_hintsContext(p *With_table_hintsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_with_table_hints +} + +func (*With_table_hintsContext) IsWith_table_hintsContext() {} + +func NewWith_table_hintsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_table_hintsContext { + var p = new(With_table_hintsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_with_table_hints + + return p +} + +func (s *With_table_hintsContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_table_hintsContext) Get_table_hint() ITable_hintContext { return s._table_hint } + +func (s *With_table_hintsContext) Set_table_hint(v ITable_hintContext) { s._table_hint = v } + +func (s *With_table_hintsContext) GetHint() []ITable_hintContext { return s.hint } + +func (s *With_table_hintsContext) SetHint(v []ITable_hintContext) { s.hint = v } + +func (s *With_table_hintsContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *With_table_hintsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *With_table_hintsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *With_table_hintsContext) AllTable_hint() []ITable_hintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_hintContext); ok { + len++ + } + } + + tst := make([]ITable_hintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_hintContext); ok { + tst[i] = t.(ITable_hintContext) + i++ + } + } + + return tst +} + +func (s *With_table_hintsContext) Table_hint(i int) ITable_hintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_hintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_hintContext) +} + +func (s *With_table_hintsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *With_table_hintsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *With_table_hintsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_table_hintsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_table_hintsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterWith_table_hints(s) + } +} + +func (s *With_table_hintsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitWith_table_hints(s) + } +} + +func (s *With_table_hintsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitWith_table_hints(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) With_table_hints() (localctx IWith_table_hintsContext) { + localctx = NewWith_table_hintsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1108, TSqlParserRULE_with_table_hints) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13797) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13798) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13799) + + var _x = p.Table_hint() + + localctx.(*With_table_hintsContext)._table_hint = _x + } + localctx.(*With_table_hintsContext).hint = append(localctx.(*With_table_hintsContext).hint, localctx.(*With_table_hintsContext)._table_hint) + p.SetState(13806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64((_la-369)) & ^0x3f) == 0 && ((int64(1)<<(_la-369))&576460752303423491) != 0) || ((int64((_la-441)) & ^0x3f) == 0 && ((int64(1)<<(_la-441))&45035996273737745) != 0) || ((int64((_la-614)) & ^0x3f) == 0 && ((int64(1)<<(_la-614))&131105) != 0) || _la == TSqlParserPAGLOCK || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&4294967339) != 0) || _la == TSqlParserROWLOCK || _la == TSqlParserSERIALIZABLE || ((int64((_la-921)) & ^0x3f) == 0 && ((int64(1)<<(_la-921))&-4611686018427387391) != 0) || _la == TSqlParserUPDLOCK || _la == TSqlParserXLOCK || _la == TSqlParserCOMMA { + p.SetState(13801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13800) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13803) + + var _x = p.Table_hint() + + localctx.(*With_table_hintsContext)._table_hint = _x + } + localctx.(*With_table_hintsContext).hint = append(localctx.(*With_table_hintsContext).hint, localctx.(*With_table_hintsContext)._table_hint) + + p.SetState(13808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13809) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeprecated_table_hintContext is an interface to support dynamic dispatch. +type IDeprecated_table_hintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + Table_hint() ITable_hintContext + RR_BRACKET() antlr.TerminalNode + + // IsDeprecated_table_hintContext differentiates from other interfaces. + IsDeprecated_table_hintContext() +} + +type Deprecated_table_hintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeprecated_table_hintContext() *Deprecated_table_hintContext { + var p = new(Deprecated_table_hintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_deprecated_table_hint + return p +} + +func InitEmptyDeprecated_table_hintContext(p *Deprecated_table_hintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_deprecated_table_hint +} + +func (*Deprecated_table_hintContext) IsDeprecated_table_hintContext() {} + +func NewDeprecated_table_hintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Deprecated_table_hintContext { + var p = new(Deprecated_table_hintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_deprecated_table_hint + + return p +} + +func (s *Deprecated_table_hintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Deprecated_table_hintContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Deprecated_table_hintContext) Table_hint() ITable_hintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_hintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_hintContext) +} + +func (s *Deprecated_table_hintContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Deprecated_table_hintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Deprecated_table_hintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Deprecated_table_hintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDeprecated_table_hint(s) + } +} + +func (s *Deprecated_table_hintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDeprecated_table_hint(s) + } +} + +func (s *Deprecated_table_hintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDeprecated_table_hint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Deprecated_table_hint() (localctx IDeprecated_table_hintContext) { + localctx = NewDeprecated_table_hintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1110, TSqlParserRULE_deprecated_table_hint) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13811) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13812) + p.Table_hint() + } + { + p.SetState(13813) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISybase_legacy_hintsContext is an interface to support dynamic dispatch. +type ISybase_legacy_hintsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSybase_legacy_hint() []ISybase_legacy_hintContext + Sybase_legacy_hint(i int) ISybase_legacy_hintContext + + // IsSybase_legacy_hintsContext differentiates from other interfaces. + IsSybase_legacy_hintsContext() +} + +type Sybase_legacy_hintsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySybase_legacy_hintsContext() *Sybase_legacy_hintsContext { + var p = new(Sybase_legacy_hintsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_sybase_legacy_hints + return p +} + +func InitEmptySybase_legacy_hintsContext(p *Sybase_legacy_hintsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_sybase_legacy_hints +} + +func (*Sybase_legacy_hintsContext) IsSybase_legacy_hintsContext() {} + +func NewSybase_legacy_hintsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sybase_legacy_hintsContext { + var p = new(Sybase_legacy_hintsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_sybase_legacy_hints + + return p +} + +func (s *Sybase_legacy_hintsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sybase_legacy_hintsContext) AllSybase_legacy_hint() []ISybase_legacy_hintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISybase_legacy_hintContext); ok { + len++ + } + } + + tst := make([]ISybase_legacy_hintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISybase_legacy_hintContext); ok { + tst[i] = t.(ISybase_legacy_hintContext) + i++ + } + } + + return tst +} + +func (s *Sybase_legacy_hintsContext) Sybase_legacy_hint(i int) ISybase_legacy_hintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISybase_legacy_hintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISybase_legacy_hintContext) +} + +func (s *Sybase_legacy_hintsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sybase_legacy_hintsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sybase_legacy_hintsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSybase_legacy_hints(s) + } +} + +func (s *Sybase_legacy_hintsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSybase_legacy_hints(s) + } +} + +func (s *Sybase_legacy_hintsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSybase_legacy_hints(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Sybase_legacy_hints() (localctx ISybase_legacy_hintsContext) { + localctx = NewSybase_legacy_hintsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1112, TSqlParserRULE_sybase_legacy_hints) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(13815) + p.Sybase_legacy_hint() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13818) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1730, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISybase_legacy_hintContext is an interface to support dynamic dispatch. +type ISybase_legacy_hintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HOLDLOCK() antlr.TerminalNode + NOHOLDLOCK() antlr.TerminalNode + READPAST() antlr.TerminalNode + SHARED() antlr.TerminalNode + + // IsSybase_legacy_hintContext differentiates from other interfaces. + IsSybase_legacy_hintContext() +} + +type Sybase_legacy_hintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySybase_legacy_hintContext() *Sybase_legacy_hintContext { + var p = new(Sybase_legacy_hintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_sybase_legacy_hint + return p +} + +func InitEmptySybase_legacy_hintContext(p *Sybase_legacy_hintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_sybase_legacy_hint +} + +func (*Sybase_legacy_hintContext) IsSybase_legacy_hintContext() {} + +func NewSybase_legacy_hintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sybase_legacy_hintContext { + var p = new(Sybase_legacy_hintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_sybase_legacy_hint + + return p +} + +func (s *Sybase_legacy_hintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sybase_legacy_hintContext) HOLDLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserHOLDLOCK, 0) +} + +func (s *Sybase_legacy_hintContext) NOHOLDLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserNOHOLDLOCK, 0) +} + +func (s *Sybase_legacy_hintContext) READPAST() antlr.TerminalNode { + return s.GetToken(TSqlParserREADPAST, 0) +} + +func (s *Sybase_legacy_hintContext) SHARED() antlr.TerminalNode { + return s.GetToken(TSqlParserSHARED, 0) +} + +func (s *Sybase_legacy_hintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sybase_legacy_hintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sybase_legacy_hintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSybase_legacy_hint(s) + } +} + +func (s *Sybase_legacy_hintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSybase_legacy_hint(s) + } +} + +func (s *Sybase_legacy_hintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSybase_legacy_hint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Sybase_legacy_hint() (localctx ISybase_legacy_hintContext) { + localctx = NewSybase_legacy_hintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1114, TSqlParserRULE_sybase_legacy_hint) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13820) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserHOLDLOCK || _la == TSqlParserNOHOLDLOCK || _la == TSqlParserREADPAST || _la == TSqlParserSHARED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_hintContext is an interface to support dynamic dispatch. +type ITable_hintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOEXPAND() antlr.TerminalNode + INDEX() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllIndex_value() []IIndex_valueContext + Index_value(i int) IIndex_valueContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + EQUAL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + FORCESEEK() antlr.TerminalNode + Column_name_list() IColumn_name_listContext + FORCESCAN() antlr.TerminalNode + HOLDLOCK() antlr.TerminalNode + NOLOCK() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + PAGLOCK() antlr.TerminalNode + READCOMMITTED() antlr.TerminalNode + READCOMMITTEDLOCK() antlr.TerminalNode + READPAST() antlr.TerminalNode + READUNCOMMITTED() antlr.TerminalNode + REPEATABLEREAD() antlr.TerminalNode + ROWLOCK() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + SPATIAL_WINDOW_MAX_CELLS() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + TABLOCK() antlr.TerminalNode + TABLOCKX() antlr.TerminalNode + UPDLOCK() antlr.TerminalNode + XLOCK() antlr.TerminalNode + KEEPIDENTITY() antlr.TerminalNode + KEEPDEFAULTS() antlr.TerminalNode + IGNORE_CONSTRAINTS() antlr.TerminalNode + IGNORE_TRIGGERS() antlr.TerminalNode + + // IsTable_hintContext differentiates from other interfaces. + IsTable_hintContext() +} + +type Table_hintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_hintContext() *Table_hintContext { + var p = new(Table_hintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_hint + return p +} + +func InitEmptyTable_hintContext(p *Table_hintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_hint +} + +func (*Table_hintContext) IsTable_hintContext() {} + +func NewTable_hintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_hintContext { + var p = new(Table_hintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_table_hint + + return p +} + +func (s *Table_hintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_hintContext) NOEXPAND() antlr.TerminalNode { + return s.GetToken(TSqlParserNOEXPAND, 0) +} + +func (s *Table_hintContext) INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX, 0) +} + +func (s *Table_hintContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Table_hintContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Table_hintContext) AllIndex_value() []IIndex_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_valueContext); ok { + len++ + } + } + + tst := make([]IIndex_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_valueContext); ok { + tst[i] = t.(IIndex_valueContext) + i++ + } + } + + return tst +} + +func (s *Table_hintContext) Index_value(i int) IIndex_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_valueContext) +} + +func (s *Table_hintContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Table_hintContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Table_hintContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Table_hintContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Table_hintContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Table_hintContext) FORCESEEK() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCESEEK, 0) +} + +func (s *Table_hintContext) Column_name_list() IColumn_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_listContext) +} + +func (s *Table_hintContext) FORCESCAN() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCESCAN, 0) +} + +func (s *Table_hintContext) HOLDLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserHOLDLOCK, 0) +} + +func (s *Table_hintContext) NOLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserNOLOCK, 0) +} + +func (s *Table_hintContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOWAIT, 0) +} + +func (s *Table_hintContext) PAGLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserPAGLOCK, 0) +} + +func (s *Table_hintContext) READCOMMITTED() antlr.TerminalNode { + return s.GetToken(TSqlParserREADCOMMITTED, 0) +} + +func (s *Table_hintContext) READCOMMITTEDLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserREADCOMMITTEDLOCK, 0) +} + +func (s *Table_hintContext) READPAST() antlr.TerminalNode { + return s.GetToken(TSqlParserREADPAST, 0) +} + +func (s *Table_hintContext) READUNCOMMITTED() antlr.TerminalNode { + return s.GetToken(TSqlParserREADUNCOMMITTED, 0) +} + +func (s *Table_hintContext) REPEATABLEREAD() antlr.TerminalNode { + return s.GetToken(TSqlParserREPEATABLEREAD, 0) +} + +func (s *Table_hintContext) ROWLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserROWLOCK, 0) +} + +func (s *Table_hintContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERIALIZABLE, 0) +} + +func (s *Table_hintContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(TSqlParserSNAPSHOT, 0) +} + +func (s *Table_hintContext) SPATIAL_WINDOW_MAX_CELLS() antlr.TerminalNode { + return s.GetToken(TSqlParserSPATIAL_WINDOW_MAX_CELLS, 0) +} + +func (s *Table_hintContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Table_hintContext) TABLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLOCK, 0) +} + +func (s *Table_hintContext) TABLOCKX() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLOCKX, 0) +} + +func (s *Table_hintContext) UPDLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserUPDLOCK, 0) +} + +func (s *Table_hintContext) XLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserXLOCK, 0) +} + +func (s *Table_hintContext) KEEPIDENTITY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEEPIDENTITY, 0) +} + +func (s *Table_hintContext) KEEPDEFAULTS() antlr.TerminalNode { + return s.GetToken(TSqlParserKEEPDEFAULTS, 0) +} + +func (s *Table_hintContext) IGNORE_CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_CONSTRAINTS, 0) +} + +func (s *Table_hintContext) IGNORE_TRIGGERS() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_TRIGGERS, 0) +} + +func (s *Table_hintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_hintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_hintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTable_hint(s) + } +} + +func (s *Table_hintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTable_hint(s) + } +} + +func (s *Table_hintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTable_hint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Table_hint() (localctx ITable_hintContext) { + localctx = NewTable_hintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1116, TSqlParserRULE_table_hint) + var _la int + + p.SetState(13878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserNOEXPAND: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13822) + p.Match(TSqlParserNOEXPAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserINDEX: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13823) + p.Match(TSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13842) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1732, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13824) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13825) + p.Index_value() + } + p.SetState(13830) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(13826) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13827) + p.Index_value() + } + + p.SetState(13832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13833) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(13835) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13836) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13837) + p.Index_value() + } + { + p.SetState(13838) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(13840) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13841) + p.Index_value() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case TSqlParserFORCESEEK: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13844) + p.Match(TSqlParserFORCESEEK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13852) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserLR_BRACKET { + { + p.SetState(13845) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13846) + p.Index_value() + } + { + p.SetState(13847) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13848) + p.Column_name_list() + } + { + p.SetState(13849) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13850) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case TSqlParserFORCESCAN: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13854) + p.Match(TSqlParserFORCESCAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserHOLDLOCK: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13855) + p.Match(TSqlParserHOLDLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNOLOCK: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13856) + p.Match(TSqlParserNOLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserNOWAIT: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(13857) + p.Match(TSqlParserNOWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPAGLOCK: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(13858) + p.Match(TSqlParserPAGLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserREADCOMMITTED: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(13859) + p.Match(TSqlParserREADCOMMITTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserREADCOMMITTEDLOCK: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(13860) + p.Match(TSqlParserREADCOMMITTEDLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserREADPAST: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(13861) + p.Match(TSqlParserREADPAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserREADUNCOMMITTED: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(13862) + p.Match(TSqlParserREADUNCOMMITTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserREPEATABLEREAD: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(13863) + p.Match(TSqlParserREPEATABLEREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserROWLOCK: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(13864) + p.Match(TSqlParserROWLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSERIALIZABLE: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(13865) + p.Match(TSqlParserSERIALIZABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSNAPSHOT: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(13866) + p.Match(TSqlParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSPATIAL_WINDOW_MAX_CELLS: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(13867) + p.Match(TSqlParserSPATIAL_WINDOW_MAX_CELLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13868) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13869) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTABLOCK: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(13870) + p.Match(TSqlParserTABLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTABLOCKX: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(13871) + p.Match(TSqlParserTABLOCKX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserUPDLOCK: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(13872) + p.Match(TSqlParserUPDLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserXLOCK: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(13873) + p.Match(TSqlParserXLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserKEEPIDENTITY: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(13874) + p.Match(TSqlParserKEEPIDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserKEEPDEFAULTS: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(13875) + p.Match(TSqlParserKEEPDEFAULTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserIGNORE_CONSTRAINTS: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(13876) + p.Match(TSqlParserIGNORE_CONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserIGNORE_TRIGGERS: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(13877) + p.Match(TSqlParserIGNORE_TRIGGERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_valueContext is an interface to support dynamic dispatch. +type IIndex_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + DECIMAL() antlr.TerminalNode + + // IsIndex_valueContext differentiates from other interfaces. + IsIndex_valueContext() +} + +type Index_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_valueContext() *Index_valueContext { + var p = new(Index_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_index_value + return p +} + +func InitEmptyIndex_valueContext(p *Index_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_index_value +} + +func (*Index_valueContext) IsIndex_valueContext() {} + +func NewIndex_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_valueContext { + var p = new(Index_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_index_value + + return p +} + +func (s *Index_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_valueContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Index_valueContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Index_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterIndex_value(s) + } +} + +func (s *Index_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitIndex_value(s) + } +} + +func (s *Index_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitIndex_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Index_value() (localctx IIndex_valueContext) { + localctx = NewIndex_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1118, TSqlParserRULE_index_value) + p.SetState(13882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13880) + p.Id_() + } + + case TSqlParserDECIMAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13881) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_alias_listContext is an interface to support dynamic dispatch. +type IColumn_alias_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_column_alias returns the _column_alias rule contexts. + Get_column_alias() IColumn_aliasContext + + // Set_column_alias sets the _column_alias rule contexts. + Set_column_alias(IColumn_aliasContext) + + // GetAlias returns the alias rule context list. + GetAlias() []IColumn_aliasContext + + // SetAlias sets the alias rule context list. + SetAlias([]IColumn_aliasContext) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllColumn_alias() []IColumn_aliasContext + Column_alias(i int) IColumn_aliasContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_alias_listContext differentiates from other interfaces. + IsColumn_alias_listContext() +} + +type Column_alias_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _column_alias IColumn_aliasContext + alias []IColumn_aliasContext +} + +func NewEmptyColumn_alias_listContext() *Column_alias_listContext { + var p = new(Column_alias_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_alias_list + return p +} + +func InitEmptyColumn_alias_listContext(p *Column_alias_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_alias_list +} + +func (*Column_alias_listContext) IsColumn_alias_listContext() {} + +func NewColumn_alias_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_alias_listContext { + var p = new(Column_alias_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_column_alias_list + + return p +} + +func (s *Column_alias_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_alias_listContext) Get_column_alias() IColumn_aliasContext { return s._column_alias } + +func (s *Column_alias_listContext) Set_column_alias(v IColumn_aliasContext) { s._column_alias = v } + +func (s *Column_alias_listContext) GetAlias() []IColumn_aliasContext { return s.alias } + +func (s *Column_alias_listContext) SetAlias(v []IColumn_aliasContext) { s.alias = v } + +func (s *Column_alias_listContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Column_alias_listContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Column_alias_listContext) AllColumn_alias() []IColumn_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_aliasContext); ok { + len++ + } + } + + tst := make([]IColumn_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_aliasContext); ok { + tst[i] = t.(IColumn_aliasContext) + i++ + } + } + + return tst +} + +func (s *Column_alias_listContext) Column_alias(i int) IColumn_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Column_alias_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Column_alias_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Column_alias_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_alias_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_alias_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumn_alias_list(s) + } +} + +func (s *Column_alias_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumn_alias_list(s) + } +} + +func (s *Column_alias_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumn_alias_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Column_alias_list() (localctx IColumn_alias_listContext) { + localctx = NewColumn_alias_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1120, TSqlParserRULE_column_alias_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13884) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13885) + + var _x = p.Column_alias() + + localctx.(*Column_alias_listContext)._column_alias = _x + } + localctx.(*Column_alias_listContext).alias = append(localctx.(*Column_alias_listContext).alias, localctx.(*Column_alias_listContext)._column_alias) + p.SetState(13890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(13886) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13887) + + var _x = p.Column_alias() + + localctx.(*Column_alias_listContext)._column_alias = _x + } + localctx.(*Column_alias_listContext).alias = append(localctx.(*Column_alias_listContext).alias, localctx.(*Column_alias_listContext)._column_alias) + + p.SetState(13892) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13893) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_aliasContext is an interface to support dynamic dispatch. +type IColumn_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + STRING() antlr.TerminalNode + + // IsColumn_aliasContext differentiates from other interfaces. + IsColumn_aliasContext() +} + +type Column_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_aliasContext() *Column_aliasContext { + var p = new(Column_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_alias + return p +} + +func InitEmptyColumn_aliasContext(p *Column_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_alias +} + +func (*Column_aliasContext) IsColumn_aliasContext() {} + +func NewColumn_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_aliasContext { + var p = new(Column_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_column_alias + + return p +} + +func (s *Column_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_aliasContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Column_aliasContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Column_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumn_alias(s) + } +} + +func (s *Column_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumn_alias(s) + } +} + +func (s *Column_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumn_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Column_alias() (localctx IColumn_aliasContext) { + localctx = NewColumn_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1122, TSqlParserRULE_column_alias) + p.SetState(13897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13895) + p.Id_() + } + + case TSqlParserSTRING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13896) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_value_constructorContext is an interface to support dynamic dispatch. +type ITable_value_constructorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_expression_list_ returns the _expression_list_ rule contexts. + Get_expression_list_() IExpression_list_Context + + // Set_expression_list_ sets the _expression_list_ rule contexts. + Set_expression_list_(IExpression_list_Context) + + // GetExps returns the exps rule context list. + GetExps() []IExpression_list_Context + + // SetExps sets the exps rule context list. + SetExps([]IExpression_list_Context) + + // Getter signatures + VALUES() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllExpression_list_() []IExpression_list_Context + Expression_list_(i int) IExpression_list_Context + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTable_value_constructorContext differentiates from other interfaces. + IsTable_value_constructorContext() +} + +type Table_value_constructorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _expression_list_ IExpression_list_Context + exps []IExpression_list_Context +} + +func NewEmptyTable_value_constructorContext() *Table_value_constructorContext { + var p = new(Table_value_constructorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_value_constructor + return p +} + +func InitEmptyTable_value_constructorContext(p *Table_value_constructorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_value_constructor +} + +func (*Table_value_constructorContext) IsTable_value_constructorContext() {} + +func NewTable_value_constructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_value_constructorContext { + var p = new(Table_value_constructorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_table_value_constructor + + return p +} + +func (s *Table_value_constructorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_value_constructorContext) Get_expression_list_() IExpression_list_Context { + return s._expression_list_ +} + +func (s *Table_value_constructorContext) Set_expression_list_(v IExpression_list_Context) { + s._expression_list_ = v +} + +func (s *Table_value_constructorContext) GetExps() []IExpression_list_Context { return s.exps } + +func (s *Table_value_constructorContext) SetExps(v []IExpression_list_Context) { s.exps = v } + +func (s *Table_value_constructorContext) VALUES() antlr.TerminalNode { + return s.GetToken(TSqlParserVALUES, 0) +} + +func (s *Table_value_constructorContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Table_value_constructorContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Table_value_constructorContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Table_value_constructorContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Table_value_constructorContext) AllExpression_list_() []IExpression_list_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpression_list_Context); ok { + len++ + } + } + + tst := make([]IExpression_list_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpression_list_Context); ok { + tst[i] = t.(IExpression_list_Context) + i++ + } + } + + return tst +} + +func (s *Table_value_constructorContext) Expression_list_(i int) IExpression_list_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_list_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpression_list_Context) +} + +func (s *Table_value_constructorContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Table_value_constructorContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Table_value_constructorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_value_constructorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_value_constructorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTable_value_constructor(s) + } +} + +func (s *Table_value_constructorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTable_value_constructor(s) + } +} + +func (s *Table_value_constructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTable_value_constructor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Table_value_constructor() (localctx ITable_value_constructorContext) { + localctx = NewTable_value_constructorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1124, TSqlParserRULE_table_value_constructor) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13899) + p.Match(TSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13900) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13901) + + var _x = p.Expression_list_() + + localctx.(*Table_value_constructorContext)._expression_list_ = _x + } + localctx.(*Table_value_constructorContext).exps = append(localctx.(*Table_value_constructorContext).exps, localctx.(*Table_value_constructorContext)._expression_list_) + { + p.SetState(13902) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13910) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(13903) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13904) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13905) + + var _x = p.Expression_list_() + + localctx.(*Table_value_constructorContext)._expression_list_ = _x + } + localctx.(*Table_value_constructorContext).exps = append(localctx.(*Table_value_constructorContext).exps, localctx.(*Table_value_constructorContext)._expression_list_) + { + p.SetState(13906) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(13912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpression_list_Context is an interface to support dynamic dispatch. +type IExpression_list_Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_expression returns the _expression rule contexts. + Get_expression() IExpressionContext + + // Set_expression sets the _expression rule contexts. + Set_expression(IExpressionContext) + + // GetExp returns the exp rule context list. + GetExp() []IExpressionContext + + // SetExp sets the exp rule context list. + SetExp([]IExpressionContext) + + // Getter signatures + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExpression_list_Context differentiates from other interfaces. + IsExpression_list_Context() +} + +type Expression_list_Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _expression IExpressionContext + exp []IExpressionContext +} + +func NewEmptyExpression_list_Context() *Expression_list_Context { + var p = new(Expression_list_Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_expression_list_ + return p +} + +func InitEmptyExpression_list_Context(p *Expression_list_Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_expression_list_ +} + +func (*Expression_list_Context) IsExpression_list_Context() {} + +func NewExpression_list_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expression_list_Context { + var p = new(Expression_list_Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_expression_list_ + + return p +} + +func (s *Expression_list_Context) GetParser() antlr.Parser { return s.parser } + +func (s *Expression_list_Context) Get_expression() IExpressionContext { return s._expression } + +func (s *Expression_list_Context) Set_expression(v IExpressionContext) { s._expression = v } + +func (s *Expression_list_Context) GetExp() []IExpressionContext { return s.exp } + +func (s *Expression_list_Context) SetExp(v []IExpressionContext) { s.exp = v } + +func (s *Expression_list_Context) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Expression_list_Context) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Expression_list_Context) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Expression_list_Context) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Expression_list_Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expression_list_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expression_list_Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterExpression_list_(s) + } +} + +func (s *Expression_list_Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitExpression_list_(s) + } +} + +func (s *Expression_list_Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitExpression_list_(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Expression_list_() (localctx IExpression_list_Context) { + localctx = NewExpression_list_Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1126, TSqlParserRULE_expression_list_) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13913) + + var _x = p.expression(0) + + localctx.(*Expression_list_Context)._expression = _x + } + localctx.(*Expression_list_Context).exp = append(localctx.(*Expression_list_Context).exp, localctx.(*Expression_list_Context)._expression) + p.SetState(13918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(13914) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13915) + + var _x = p.expression(0) + + localctx.(*Expression_list_Context)._expression = _x + } + localctx.(*Expression_list_Context).exp = append(localctx.(*Expression_list_Context).exp, localctx.(*Expression_list_Context)._expression) + + p.SetState(13920) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRanking_windowed_functionContext is an interface to support dynamic dispatch. +type IRanking_windowed_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Over_clause() IOver_clauseContext + RANK() antlr.TerminalNode + DENSE_RANK() antlr.TerminalNode + ROW_NUMBER() antlr.TerminalNode + NTILE() antlr.TerminalNode + Expression() IExpressionContext + + // IsRanking_windowed_functionContext differentiates from other interfaces. + IsRanking_windowed_functionContext() +} + +type Ranking_windowed_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRanking_windowed_functionContext() *Ranking_windowed_functionContext { + var p = new(Ranking_windowed_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_ranking_windowed_function + return p +} + +func InitEmptyRanking_windowed_functionContext(p *Ranking_windowed_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_ranking_windowed_function +} + +func (*Ranking_windowed_functionContext) IsRanking_windowed_functionContext() {} + +func NewRanking_windowed_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ranking_windowed_functionContext { + var p = new(Ranking_windowed_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_ranking_windowed_function + + return p +} + +func (s *Ranking_windowed_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ranking_windowed_functionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Ranking_windowed_functionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Ranking_windowed_functionContext) Over_clause() IOver_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOver_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOver_clauseContext) +} + +func (s *Ranking_windowed_functionContext) RANK() antlr.TerminalNode { + return s.GetToken(TSqlParserRANK, 0) +} + +func (s *Ranking_windowed_functionContext) DENSE_RANK() antlr.TerminalNode { + return s.GetToken(TSqlParserDENSE_RANK, 0) +} + +func (s *Ranking_windowed_functionContext) ROW_NUMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserROW_NUMBER, 0) +} + +func (s *Ranking_windowed_functionContext) NTILE() antlr.TerminalNode { + return s.GetToken(TSqlParserNTILE, 0) +} + +func (s *Ranking_windowed_functionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Ranking_windowed_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ranking_windowed_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ranking_windowed_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRanking_windowed_function(s) + } +} + +func (s *Ranking_windowed_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRanking_windowed_function(s) + } +} + +func (s *Ranking_windowed_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRanking_windowed_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Ranking_windowed_function() (localctx IRanking_windowed_functionContext) { + localctx = NewRanking_windowed_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1128, TSqlParserRULE_ranking_windowed_function) + var _la int + + p.SetState(13931) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDENSE_RANK, TSqlParserRANK, TSqlParserROW_NUMBER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13921) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDENSE_RANK || _la == TSqlParserRANK || _la == TSqlParserROW_NUMBER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13922) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13923) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13924) + p.Over_clause() + } + + case TSqlParserNTILE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13925) + p.Match(TSqlParserNTILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13926) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13927) + p.expression(0) + } + { + p.SetState(13928) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13929) + p.Over_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAggregate_windowed_functionContext is an interface to support dynamic dispatch. +type IAggregate_windowed_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAgg_func returns the agg_func token. + GetAgg_func() antlr.Token + + // GetCnt returns the cnt token. + GetCnt() antlr.Token + + // SetAgg_func sets the agg_func token. + SetAgg_func(antlr.Token) + + // SetCnt sets the cnt token. + SetCnt(antlr.Token) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + All_distinct_expression() IAll_distinct_expressionContext + RR_BRACKET() antlr.TerminalNode + AVG() antlr.TerminalNode + MAX() antlr.TerminalNode + MIN() antlr.TerminalNode + SUM() antlr.TerminalNode + STDEV() antlr.TerminalNode + STDEVP() antlr.TerminalNode + VAR() antlr.TerminalNode + VARP() antlr.TerminalNode + Over_clause() IOver_clauseContext + COUNT() antlr.TerminalNode + COUNT_BIG() antlr.TerminalNode + STAR() antlr.TerminalNode + CHECKSUM_AGG() antlr.TerminalNode + GROUPING() antlr.TerminalNode + Expression() IExpressionContext + GROUPING_ID() antlr.TerminalNode + Expression_list_() IExpression_list_Context + + // IsAggregate_windowed_functionContext differentiates from other interfaces. + IsAggregate_windowed_functionContext() +} + +type Aggregate_windowed_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + agg_func antlr.Token + cnt antlr.Token +} + +func NewEmptyAggregate_windowed_functionContext() *Aggregate_windowed_functionContext { + var p = new(Aggregate_windowed_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_aggregate_windowed_function + return p +} + +func InitEmptyAggregate_windowed_functionContext(p *Aggregate_windowed_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_aggregate_windowed_function +} + +func (*Aggregate_windowed_functionContext) IsAggregate_windowed_functionContext() {} + +func NewAggregate_windowed_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_windowed_functionContext { + var p = new(Aggregate_windowed_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_aggregate_windowed_function + + return p +} + +func (s *Aggregate_windowed_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aggregate_windowed_functionContext) GetAgg_func() antlr.Token { return s.agg_func } + +func (s *Aggregate_windowed_functionContext) GetCnt() antlr.Token { return s.cnt } + +func (s *Aggregate_windowed_functionContext) SetAgg_func(v antlr.Token) { s.agg_func = v } + +func (s *Aggregate_windowed_functionContext) SetCnt(v antlr.Token) { s.cnt = v } + +func (s *Aggregate_windowed_functionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Aggregate_windowed_functionContext) All_distinct_expression() IAll_distinct_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_distinct_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_distinct_expressionContext) +} + +func (s *Aggregate_windowed_functionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Aggregate_windowed_functionContext) AVG() antlr.TerminalNode { + return s.GetToken(TSqlParserAVG, 0) +} + +func (s *Aggregate_windowed_functionContext) MAX() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX, 0) +} + +func (s *Aggregate_windowed_functionContext) MIN() antlr.TerminalNode { + return s.GetToken(TSqlParserMIN, 0) +} + +func (s *Aggregate_windowed_functionContext) SUM() antlr.TerminalNode { + return s.GetToken(TSqlParserSUM, 0) +} + +func (s *Aggregate_windowed_functionContext) STDEV() antlr.TerminalNode { + return s.GetToken(TSqlParserSTDEV, 0) +} + +func (s *Aggregate_windowed_functionContext) STDEVP() antlr.TerminalNode { + return s.GetToken(TSqlParserSTDEVP, 0) +} + +func (s *Aggregate_windowed_functionContext) VAR() antlr.TerminalNode { + return s.GetToken(TSqlParserVAR, 0) +} + +func (s *Aggregate_windowed_functionContext) VARP() antlr.TerminalNode { + return s.GetToken(TSqlParserVARP, 0) +} + +func (s *Aggregate_windowed_functionContext) Over_clause() IOver_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOver_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOver_clauseContext) +} + +func (s *Aggregate_windowed_functionContext) COUNT() antlr.TerminalNode { + return s.GetToken(TSqlParserCOUNT, 0) +} + +func (s *Aggregate_windowed_functionContext) COUNT_BIG() antlr.TerminalNode { + return s.GetToken(TSqlParserCOUNT_BIG, 0) +} + +func (s *Aggregate_windowed_functionContext) STAR() antlr.TerminalNode { + return s.GetToken(TSqlParserSTAR, 0) +} + +func (s *Aggregate_windowed_functionContext) CHECKSUM_AGG() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKSUM_AGG, 0) +} + +func (s *Aggregate_windowed_functionContext) GROUPING() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUPING, 0) +} + +func (s *Aggregate_windowed_functionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Aggregate_windowed_functionContext) GROUPING_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUPING_ID, 0) +} + +func (s *Aggregate_windowed_functionContext) Expression_list_() IExpression_list_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_list_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_list_Context) +} + +func (s *Aggregate_windowed_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aggregate_windowed_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aggregate_windowed_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAggregate_windowed_function(s) + } +} + +func (s *Aggregate_windowed_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAggregate_windowed_function(s) + } +} + +func (s *Aggregate_windowed_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAggregate_windowed_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Aggregate_windowed_function() (localctx IAggregate_windowed_functionContext) { + localctx = NewAggregate_windowed_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1130, TSqlParserRULE_aggregate_windowed_function) + var _la int + + p.SetState(13965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserAVG, TSqlParserMAX, TSqlParserMIN, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSUM, TSqlParserVAR, TSqlParserVARP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13933) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Aggregate_windowed_functionContext).agg_func = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserAVG || _la == TSqlParserMAX || _la == TSqlParserMIN || ((int64((_la-953)) & ^0x3f) == 0 && ((int64(1)<<(_la-953))&16387) != 0) || _la == TSqlParserVAR || _la == TSqlParserVARP) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Aggregate_windowed_functionContext).agg_func = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13934) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13935) + p.All_distinct_expression() + } + { + p.SetState(13936) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13938) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1741, p.GetParserRuleContext()) == 1 { + { + p.SetState(13937) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserCOUNT, TSqlParserCOUNT_BIG: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13940) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Aggregate_windowed_functionContext).cnt = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCOUNT || _la == TSqlParserCOUNT_BIG) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Aggregate_windowed_functionContext).cnt = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13941) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTAR: + { + p.SetState(13942) + p.Match(TSqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALL, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCASE, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOALESCE, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTAINSTABLE, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCONVERT, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_DATE, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TIMESTAMP, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURRENT_USER, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTINCT, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDOLLAR_PARTITION, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFREETEXTTABLE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEFT, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULLIF, TSqlParserNULL_, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVER, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserRIGHT, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMANTICKEYPHRASETABLE, TSqlParserSEMANTICSIMILARITYDETAILSTABLE, TSqlParserSEMANTICSIMILARITYTABLE, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSESSION_USER, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserSYSTEM_USER, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOLLAR_ACTION, TSqlParserCURSOR_ROWS, TSqlParserFETCH_STATUS, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserLOCAL_ID, TSqlParserTEMP_ID, TSqlParserDECIMAL, TSqlParserID, TSqlParserSTRING, TSqlParserBINARY, TSqlParserFLOAT, TSqlParserREAL, TSqlParserDOT, TSqlParserDOLLAR, TSqlParserLR_BRACKET, TSqlParserPLUS, TSqlParserMINUS, TSqlParserBIT_NOT, TSqlParserPLACEHOLDER: + { + p.SetState(13943) + p.All_distinct_expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(13946) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13948) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1743, p.GetParserRuleContext()) == 1 { + { + p.SetState(13947) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case TSqlParserCHECKSUM_AGG: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13950) + p.Match(TSqlParserCHECKSUM_AGG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13951) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13952) + p.All_distinct_expression() + } + { + p.SetState(13953) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserGROUPING: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13955) + p.Match(TSqlParserGROUPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13956) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13957) + p.expression(0) + } + { + p.SetState(13958) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserGROUPING_ID: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13960) + p.Match(TSqlParserGROUPING_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13961) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13962) + p.Expression_list_() + } + { + p.SetState(13963) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAnalytic_windowed_functionContext is an interface to support dynamic dispatch. +type IAnalytic_windowed_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + Over_clause() IOver_clauseContext + FIRST_VALUE() antlr.TerminalNode + LAST_VALUE() antlr.TerminalNode + LAG() antlr.TerminalNode + LEAD() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + OVER() antlr.TerminalNode + Order_by_clause() IOrder_by_clauseContext + CUME_DIST() antlr.TerminalNode + PERCENT_RANK() antlr.TerminalNode + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + Expression_list_() IExpression_list_Context + WITHIN() antlr.TerminalNode + GROUP() antlr.TerminalNode + PERCENTILE_CONT() antlr.TerminalNode + PERCENTILE_DISC() antlr.TerminalNode + + // IsAnalytic_windowed_functionContext differentiates from other interfaces. + IsAnalytic_windowed_functionContext() +} + +type Analytic_windowed_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnalytic_windowed_functionContext() *Analytic_windowed_functionContext { + var p = new(Analytic_windowed_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_analytic_windowed_function + return p +} + +func InitEmptyAnalytic_windowed_functionContext(p *Analytic_windowed_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_analytic_windowed_function +} + +func (*Analytic_windowed_functionContext) IsAnalytic_windowed_functionContext() {} + +func NewAnalytic_windowed_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Analytic_windowed_functionContext { + var p = new(Analytic_windowed_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_analytic_windowed_function + + return p +} + +func (s *Analytic_windowed_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Analytic_windowed_functionContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLR_BRACKET) +} + +func (s *Analytic_windowed_functionContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, i) +} + +func (s *Analytic_windowed_functionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Analytic_windowed_functionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Analytic_windowed_functionContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(TSqlParserRR_BRACKET) +} + +func (s *Analytic_windowed_functionContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, i) +} + +func (s *Analytic_windowed_functionContext) Over_clause() IOver_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOver_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOver_clauseContext) +} + +func (s *Analytic_windowed_functionContext) FIRST_VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserFIRST_VALUE, 0) +} + +func (s *Analytic_windowed_functionContext) LAST_VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserLAST_VALUE, 0) +} + +func (s *Analytic_windowed_functionContext) LAG() antlr.TerminalNode { + return s.GetToken(TSqlParserLAG, 0) +} + +func (s *Analytic_windowed_functionContext) LEAD() antlr.TerminalNode { + return s.GetToken(TSqlParserLEAD, 0) +} + +func (s *Analytic_windowed_functionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Analytic_windowed_functionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Analytic_windowed_functionContext) OVER() antlr.TerminalNode { + return s.GetToken(TSqlParserOVER, 0) +} + +func (s *Analytic_windowed_functionContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Analytic_windowed_functionContext) CUME_DIST() antlr.TerminalNode { + return s.GetToken(TSqlParserCUME_DIST, 0) +} + +func (s *Analytic_windowed_functionContext) PERCENT_RANK() antlr.TerminalNode { + return s.GetToken(TSqlParserPERCENT_RANK, 0) +} + +func (s *Analytic_windowed_functionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITION, 0) +} + +func (s *Analytic_windowed_functionContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Analytic_windowed_functionContext) Expression_list_() IExpression_list_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_list_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_list_Context) +} + +func (s *Analytic_windowed_functionContext) WITHIN() antlr.TerminalNode { + return s.GetToken(TSqlParserWITHIN, 0) +} + +func (s *Analytic_windowed_functionContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *Analytic_windowed_functionContext) PERCENTILE_CONT() antlr.TerminalNode { + return s.GetToken(TSqlParserPERCENTILE_CONT, 0) +} + +func (s *Analytic_windowed_functionContext) PERCENTILE_DISC() antlr.TerminalNode { + return s.GetToken(TSqlParserPERCENTILE_DISC, 0) +} + +func (s *Analytic_windowed_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Analytic_windowed_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Analytic_windowed_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAnalytic_windowed_function(s) + } +} + +func (s *Analytic_windowed_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAnalytic_windowed_function(s) + } +} + +func (s *Analytic_windowed_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAnalytic_windowed_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Analytic_windowed_function() (localctx IAnalytic_windowed_functionContext) { + localctx = NewAnalytic_windowed_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1132, TSqlParserRULE_analytic_windowed_function) + var _la int + + p.SetState(14018) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFIRST_VALUE, TSqlParserLAST_VALUE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13967) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFIRST_VALUE || _la == TSqlParserLAST_VALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13968) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13969) + p.expression(0) + } + { + p.SetState(13970) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13971) + p.Over_clause() + } + + case TSqlParserLAG, TSqlParserLEAD: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13973) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLAG || _la == TSqlParserLEAD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13974) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13975) + p.expression(0) + } + p.SetState(13982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13976) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13977) + p.expression(0) + } + p.SetState(13980) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(13978) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13979) + p.expression(0) + } + + } + + } + { + p.SetState(13984) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13985) + p.Over_clause() + } + + case TSqlParserCUME_DIST, TSqlParserPERCENT_RANK: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13987) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCUME_DIST || _la == TSqlParserPERCENT_RANK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13988) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13989) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13990) + p.Match(TSqlParserOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13991) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPARTITION { + { + p.SetState(13992) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13993) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13994) + p.Expression_list_() + } + + } + { + p.SetState(13997) + p.Order_by_clause() + } + { + p.SetState(13998) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14000) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserPERCENTILE_CONT || _la == TSqlParserPERCENTILE_DISC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14001) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14002) + p.expression(0) + } + { + p.SetState(14003) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14004) + p.Match(TSqlParserWITHIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14005) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14006) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14007) + p.Order_by_clause() + } + { + p.SetState(14008) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14009) + p.Match(TSqlParserOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14010) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPARTITION { + { + p.SetState(14011) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14012) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14013) + p.Expression_list_() + } + + } + { + p.SetState(14016) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAll_distinct_expressionContext is an interface to support dynamic dispatch. +type IAll_distinct_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + ALL() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + + // IsAll_distinct_expressionContext differentiates from other interfaces. + IsAll_distinct_expressionContext() +} + +type All_distinct_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAll_distinct_expressionContext() *All_distinct_expressionContext { + var p = new(All_distinct_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_all_distinct_expression + return p +} + +func InitEmptyAll_distinct_expressionContext(p *All_distinct_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_all_distinct_expression +} + +func (*All_distinct_expressionContext) IsAll_distinct_expressionContext() {} + +func NewAll_distinct_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_distinct_expressionContext { + var p = new(All_distinct_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_all_distinct_expression + + return p +} + +func (s *All_distinct_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *All_distinct_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *All_distinct_expressionContext) ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserALL, 0) +} + +func (s *All_distinct_expressionContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(TSqlParserDISTINCT, 0) +} + +func (s *All_distinct_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *All_distinct_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *All_distinct_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAll_distinct_expression(s) + } +} + +func (s *All_distinct_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAll_distinct_expression(s) + } +} + +func (s *All_distinct_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAll_distinct_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) All_distinct_expression() (localctx IAll_distinct_expressionContext) { + localctx = NewAll_distinct_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1134, TSqlParserRULE_all_distinct_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14021) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserALL || _la == TSqlParserDISTINCT { + { + p.SetState(14020) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserALL || _la == TSqlParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(14023) + p.expression(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOver_clauseContext is an interface to support dynamic dispatch. +type IOver_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OVER() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + Expression_list_() IExpression_list_Context + Order_by_clause() IOrder_by_clauseContext + Row_or_range_clause() IRow_or_range_clauseContext + + // IsOver_clauseContext differentiates from other interfaces. + IsOver_clauseContext() +} + +type Over_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOver_clauseContext() *Over_clauseContext { + var p = new(Over_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_over_clause + return p +} + +func InitEmptyOver_clauseContext(p *Over_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_over_clause +} + +func (*Over_clauseContext) IsOver_clauseContext() {} + +func NewOver_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Over_clauseContext { + var p = new(Over_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_over_clause + + return p +} + +func (s *Over_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Over_clauseContext) OVER() antlr.TerminalNode { + return s.GetToken(TSqlParserOVER, 0) +} + +func (s *Over_clauseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Over_clauseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Over_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITION, 0) +} + +func (s *Over_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(TSqlParserBY, 0) +} + +func (s *Over_clauseContext) Expression_list_() IExpression_list_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_list_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_list_Context) +} + +func (s *Over_clauseContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Over_clauseContext) Row_or_range_clause() IRow_or_range_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_or_range_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_or_range_clauseContext) +} + +func (s *Over_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Over_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Over_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOver_clause(s) + } +} + +func (s *Over_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOver_clause(s) + } +} + +func (s *Over_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOver_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Over_clause() (localctx IOver_clauseContext) { + localctx = NewOver_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1136, TSqlParserRULE_over_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14025) + p.Match(TSqlParserOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14026) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPARTITION { + { + p.SetState(14027) + p.Match(TSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14028) + p.Match(TSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14029) + p.Expression_list_() + } + + } + p.SetState(14033) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserORDER { + { + p.SetState(14032) + p.Order_by_clause() + } + + } + p.SetState(14036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserRANGE || _la == TSqlParserROWS { + { + p.SetState(14035) + p.Row_or_range_clause() + } + + } + { + p.SetState(14038) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRow_or_range_clauseContext is an interface to support dynamic dispatch. +type IRow_or_range_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Window_frame_extent() IWindow_frame_extentContext + ROWS() antlr.TerminalNode + RANGE() antlr.TerminalNode + + // IsRow_or_range_clauseContext differentiates from other interfaces. + IsRow_or_range_clauseContext() +} + +type Row_or_range_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRow_or_range_clauseContext() *Row_or_range_clauseContext { + var p = new(Row_or_range_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_row_or_range_clause + return p +} + +func InitEmptyRow_or_range_clauseContext(p *Row_or_range_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_row_or_range_clause +} + +func (*Row_or_range_clauseContext) IsRow_or_range_clauseContext() {} + +func NewRow_or_range_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_or_range_clauseContext { + var p = new(Row_or_range_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_row_or_range_clause + + return p +} + +func (s *Row_or_range_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Row_or_range_clauseContext) Window_frame_extent() IWindow_frame_extentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_frame_extentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_frame_extentContext) +} + +func (s *Row_or_range_clauseContext) ROWS() antlr.TerminalNode { + return s.GetToken(TSqlParserROWS, 0) +} + +func (s *Row_or_range_clauseContext) RANGE() antlr.TerminalNode { + return s.GetToken(TSqlParserRANGE, 0) +} + +func (s *Row_or_range_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Row_or_range_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Row_or_range_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterRow_or_range_clause(s) + } +} + +func (s *Row_or_range_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitRow_or_range_clause(s) + } +} + +func (s *Row_or_range_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitRow_or_range_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Row_or_range_clause() (localctx IRow_or_range_clauseContext) { + localctx = NewRow_or_range_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1138, TSqlParserRULE_row_or_range_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14040) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserRANGE || _la == TSqlParserROWS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14041) + p.Window_frame_extent() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_frame_extentContext is an interface to support dynamic dispatch. +type IWindow_frame_extentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Window_frame_preceding() IWindow_frame_precedingContext + BETWEEN() antlr.TerminalNode + AllWindow_frame_bound() []IWindow_frame_boundContext + Window_frame_bound(i int) IWindow_frame_boundContext + AND() antlr.TerminalNode + + // IsWindow_frame_extentContext differentiates from other interfaces. + IsWindow_frame_extentContext() +} + +type Window_frame_extentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_frame_extentContext() *Window_frame_extentContext { + var p = new(Window_frame_extentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_window_frame_extent + return p +} + +func InitEmptyWindow_frame_extentContext(p *Window_frame_extentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_window_frame_extent +} + +func (*Window_frame_extentContext) IsWindow_frame_extentContext() {} + +func NewWindow_frame_extentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_frame_extentContext { + var p = new(Window_frame_extentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_window_frame_extent + + return p +} + +func (s *Window_frame_extentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_frame_extentContext) Window_frame_preceding() IWindow_frame_precedingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_frame_precedingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_frame_precedingContext) +} + +func (s *Window_frame_extentContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(TSqlParserBETWEEN, 0) +} + +func (s *Window_frame_extentContext) AllWindow_frame_bound() []IWindow_frame_boundContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWindow_frame_boundContext); ok { + len++ + } + } + + tst := make([]IWindow_frame_boundContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWindow_frame_boundContext); ok { + tst[i] = t.(IWindow_frame_boundContext) + i++ + } + } + + return tst +} + +func (s *Window_frame_extentContext) Window_frame_bound(i int) IWindow_frame_boundContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_frame_boundContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWindow_frame_boundContext) +} + +func (s *Window_frame_extentContext) AND() antlr.TerminalNode { + return s.GetToken(TSqlParserAND, 0) +} + +func (s *Window_frame_extentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_frame_extentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_frame_extentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterWindow_frame_extent(s) + } +} + +func (s *Window_frame_extentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitWindow_frame_extent(s) + } +} + +func (s *Window_frame_extentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitWindow_frame_extent(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Window_frame_extent() (localctx IWindow_frame_extentContext) { + localctx = NewWindow_frame_extentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1140, TSqlParserRULE_window_frame_extent) + p.SetState(14049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserCURRENT, TSqlParserUNBOUNDED, TSqlParserDECIMAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14043) + p.Window_frame_preceding() + } + + case TSqlParserBETWEEN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14044) + p.Match(TSqlParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14045) + p.Window_frame_bound() + } + { + p.SetState(14046) + p.Match(TSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14047) + p.Window_frame_bound() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_frame_boundContext is an interface to support dynamic dispatch. +type IWindow_frame_boundContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Window_frame_preceding() IWindow_frame_precedingContext + Window_frame_following() IWindow_frame_followingContext + + // IsWindow_frame_boundContext differentiates from other interfaces. + IsWindow_frame_boundContext() +} + +type Window_frame_boundContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_frame_boundContext() *Window_frame_boundContext { + var p = new(Window_frame_boundContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_window_frame_bound + return p +} + +func InitEmptyWindow_frame_boundContext(p *Window_frame_boundContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_window_frame_bound +} + +func (*Window_frame_boundContext) IsWindow_frame_boundContext() {} + +func NewWindow_frame_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_frame_boundContext { + var p = new(Window_frame_boundContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_window_frame_bound + + return p +} + +func (s *Window_frame_boundContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_frame_boundContext) Window_frame_preceding() IWindow_frame_precedingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_frame_precedingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_frame_precedingContext) +} + +func (s *Window_frame_boundContext) Window_frame_following() IWindow_frame_followingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_frame_followingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_frame_followingContext) +} + +func (s *Window_frame_boundContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_frame_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_frame_boundContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterWindow_frame_bound(s) + } +} + +func (s *Window_frame_boundContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitWindow_frame_bound(s) + } +} + +func (s *Window_frame_boundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitWindow_frame_bound(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Window_frame_bound() (localctx IWindow_frame_boundContext) { + localctx = NewWindow_frame_boundContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1142, TSqlParserRULE_window_frame_bound) + p.SetState(14053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1755, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14051) + p.Window_frame_preceding() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14052) + p.Window_frame_following() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_frame_precedingContext is an interface to support dynamic dispatch. +type IWindow_frame_precedingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNBOUNDED() antlr.TerminalNode + PRECEDING() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + CURRENT() antlr.TerminalNode + ROW() antlr.TerminalNode + + // IsWindow_frame_precedingContext differentiates from other interfaces. + IsWindow_frame_precedingContext() +} + +type Window_frame_precedingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_frame_precedingContext() *Window_frame_precedingContext { + var p = new(Window_frame_precedingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_window_frame_preceding + return p +} + +func InitEmptyWindow_frame_precedingContext(p *Window_frame_precedingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_window_frame_preceding +} + +func (*Window_frame_precedingContext) IsWindow_frame_precedingContext() {} + +func NewWindow_frame_precedingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_frame_precedingContext { + var p = new(Window_frame_precedingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_window_frame_preceding + + return p +} + +func (s *Window_frame_precedingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_frame_precedingContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(TSqlParserUNBOUNDED, 0) +} + +func (s *Window_frame_precedingContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(TSqlParserPRECEDING, 0) +} + +func (s *Window_frame_precedingContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Window_frame_precedingContext) CURRENT() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT, 0) +} + +func (s *Window_frame_precedingContext) ROW() antlr.TerminalNode { + return s.GetToken(TSqlParserROW, 0) +} + +func (s *Window_frame_precedingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_frame_precedingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_frame_precedingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterWindow_frame_preceding(s) + } +} + +func (s *Window_frame_precedingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitWindow_frame_preceding(s) + } +} + +func (s *Window_frame_precedingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitWindow_frame_preceding(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Window_frame_preceding() (localctx IWindow_frame_precedingContext) { + localctx = NewWindow_frame_precedingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1144, TSqlParserRULE_window_frame_preceding) + p.SetState(14061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserUNBOUNDED: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14055) + p.Match(TSqlParserUNBOUNDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14056) + p.Match(TSqlParserPRECEDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14057) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14058) + p.Match(TSqlParserPRECEDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserCURRENT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14059) + p.Match(TSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14060) + p.Match(TSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_frame_followingContext is an interface to support dynamic dispatch. +type IWindow_frame_followingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNBOUNDED() antlr.TerminalNode + FOLLOWING() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + + // IsWindow_frame_followingContext differentiates from other interfaces. + IsWindow_frame_followingContext() +} + +type Window_frame_followingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_frame_followingContext() *Window_frame_followingContext { + var p = new(Window_frame_followingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_window_frame_following + return p +} + +func InitEmptyWindow_frame_followingContext(p *Window_frame_followingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_window_frame_following +} + +func (*Window_frame_followingContext) IsWindow_frame_followingContext() {} + +func NewWindow_frame_followingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_frame_followingContext { + var p = new(Window_frame_followingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_window_frame_following + + return p +} + +func (s *Window_frame_followingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_frame_followingContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(TSqlParserUNBOUNDED, 0) +} + +func (s *Window_frame_followingContext) FOLLOWING() antlr.TerminalNode { + return s.GetToken(TSqlParserFOLLOWING, 0) +} + +func (s *Window_frame_followingContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Window_frame_followingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_frame_followingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_frame_followingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterWindow_frame_following(s) + } +} + +func (s *Window_frame_followingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitWindow_frame_following(s) + } +} + +func (s *Window_frame_followingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitWindow_frame_following(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Window_frame_following() (localctx IWindow_frame_followingContext) { + localctx = NewWindow_frame_followingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1146, TSqlParserRULE_window_frame_following) + p.SetState(14067) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserUNBOUNDED: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14063) + p.Match(TSqlParserUNBOUNDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14064) + p.Match(TSqlParserFOLLOWING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14065) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14066) + p.Match(TSqlParserFOLLOWING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_database_optionContext is an interface to support dynamic dispatch. +type ICreate_database_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FILESTREAM() antlr.TerminalNode + AllDatabase_filestream_option() []IDatabase_filestream_optionContext + Database_filestream_option(i int) IDatabase_filestream_optionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DEFAULT_LANGUAGE() antlr.TerminalNode + EQUAL() antlr.TerminalNode + Id_() IId_Context + STRING() antlr.TerminalNode + DEFAULT_FULLTEXT_LANGUAGE() antlr.TerminalNode + NESTED_TRIGGERS() antlr.TerminalNode + OFF() antlr.TerminalNode + ON() antlr.TerminalNode + TRANSFORM_NOISE_WORDS() antlr.TerminalNode + TWO_DIGIT_YEAR_CUTOFF() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + DB_CHAINING() antlr.TerminalNode + TRUSTWORTHY() antlr.TerminalNode + + // IsCreate_database_optionContext differentiates from other interfaces. + IsCreate_database_optionContext() +} + +type Create_database_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_database_optionContext() *Create_database_optionContext { + var p = new(Create_database_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_database_option + return p +} + +func InitEmptyCreate_database_optionContext(p *Create_database_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_create_database_option +} + +func (*Create_database_optionContext) IsCreate_database_optionContext() {} + +func NewCreate_database_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_database_optionContext { + var p = new(Create_database_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_create_database_option + + return p +} + +func (s *Create_database_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_database_optionContext) FILESTREAM() antlr.TerminalNode { + return s.GetToken(TSqlParserFILESTREAM, 0) +} + +func (s *Create_database_optionContext) AllDatabase_filestream_option() []IDatabase_filestream_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatabase_filestream_optionContext); ok { + len++ + } + } + + tst := make([]IDatabase_filestream_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatabase_filestream_optionContext); ok { + tst[i] = t.(IDatabase_filestream_optionContext) + i++ + } + } + + return tst +} + +func (s *Create_database_optionContext) Database_filestream_option(i int) IDatabase_filestream_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_filestream_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_filestream_optionContext) +} + +func (s *Create_database_optionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Create_database_optionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Create_database_optionContext) DEFAULT_LANGUAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_LANGUAGE, 0) +} + +func (s *Create_database_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Create_database_optionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_database_optionContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Create_database_optionContext) DEFAULT_FULLTEXT_LANGUAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_FULLTEXT_LANGUAGE, 0) +} + +func (s *Create_database_optionContext) NESTED_TRIGGERS() antlr.TerminalNode { + return s.GetToken(TSqlParserNESTED_TRIGGERS, 0) +} + +func (s *Create_database_optionContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Create_database_optionContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Create_database_optionContext) TRANSFORM_NOISE_WORDS() antlr.TerminalNode { + return s.GetToken(TSqlParserTRANSFORM_NOISE_WORDS, 0) +} + +func (s *Create_database_optionContext) TWO_DIGIT_YEAR_CUTOFF() antlr.TerminalNode { + return s.GetToken(TSqlParserTWO_DIGIT_YEAR_CUTOFF, 0) +} + +func (s *Create_database_optionContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Create_database_optionContext) DB_CHAINING() antlr.TerminalNode { + return s.GetToken(TSqlParserDB_CHAINING, 0) +} + +func (s *Create_database_optionContext) TRUSTWORTHY() antlr.TerminalNode { + return s.GetToken(TSqlParserTRUSTWORTHY, 0) +} + +func (s *Create_database_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_database_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_database_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCreate_database_option(s) + } +} + +func (s *Create_database_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCreate_database_option(s) + } +} + +func (s *Create_database_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCreate_database_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Create_database_option() (localctx ICreate_database_optionContext) { + localctx = NewCreate_database_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1148, TSqlParserRULE_create_database_option) + var _la int + + var _alt int + + p.SetState(14103) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFILESTREAM: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14069) + p.Match(TSqlParserFILESTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(14070) + p.Database_filestream_option() + } + p.SetState(14075) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1758, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(14071) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14072) + p.Database_filestream_option() + } + + } + p.SetState(14077) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1758, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case TSqlParserDEFAULT_LANGUAGE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14078) + p.Match(TSqlParserDEFAULT_LANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14079) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(14080) + p.Id_() + } + + case TSqlParserSTRING: + { + p.SetState(14081) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserDEFAULT_FULLTEXT_LANGUAGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14084) + p.Match(TSqlParserDEFAULT_FULLTEXT_LANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14085) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14088) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(14086) + p.Id_() + } + + case TSqlParserSTRING: + { + p.SetState(14087) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case TSqlParserNESTED_TRIGGERS: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14090) + p.Match(TSqlParserNESTED_TRIGGERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14091) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14092) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserTRANSFORM_NOISE_WORDS: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14093) + p.Match(TSqlParserTRANSFORM_NOISE_WORDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14094) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14095) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserTWO_DIGIT_YEAR_CUTOFF: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14096) + p.Match(TSqlParserTWO_DIGIT_YEAR_CUTOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14097) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14098) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDB_CHAINING: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(14099) + p.Match(TSqlParserDB_CHAINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14100) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserTRUSTWORTHY: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(14101) + p.Match(TSqlParserTRUSTWORTHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14102) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatabase_filestream_optionContext is an interface to support dynamic dispatch. +type IDatabase_filestream_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + NON_TRANSACTED_ACCESS() antlr.TerminalNode + EQUAL() antlr.TerminalNode + DIRECTORY_NAME() antlr.TerminalNode + STRING() antlr.TerminalNode + OFF() antlr.TerminalNode + READ_ONLY() antlr.TerminalNode + FULL() antlr.TerminalNode + + // IsDatabase_filestream_optionContext differentiates from other interfaces. + IsDatabase_filestream_optionContext() +} + +type Database_filestream_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_filestream_optionContext() *Database_filestream_optionContext { + var p = new(Database_filestream_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_database_filestream_option + return p +} + +func InitEmptyDatabase_filestream_optionContext(p *Database_filestream_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_database_filestream_option +} + +func (*Database_filestream_optionContext) IsDatabase_filestream_optionContext() {} + +func NewDatabase_filestream_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_filestream_optionContext { + var p = new(Database_filestream_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_database_filestream_option + + return p +} + +func (s *Database_filestream_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_filestream_optionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Database_filestream_optionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Database_filestream_optionContext) NON_TRANSACTED_ACCESS() antlr.TerminalNode { + return s.GetToken(TSqlParserNON_TRANSACTED_ACCESS, 0) +} + +func (s *Database_filestream_optionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Database_filestream_optionContext) DIRECTORY_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserDIRECTORY_NAME, 0) +} + +func (s *Database_filestream_optionContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Database_filestream_optionContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *Database_filestream_optionContext) READ_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_ONLY, 0) +} + +func (s *Database_filestream_optionContext) FULL() antlr.TerminalNode { + return s.GetToken(TSqlParserFULL, 0) +} + +func (s *Database_filestream_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_filestream_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_filestream_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDatabase_filestream_option(s) + } +} + +func (s *Database_filestream_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDatabase_filestream_option(s) + } +} + +func (s *Database_filestream_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDatabase_filestream_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Database_filestream_option() (localctx IDatabase_filestream_optionContext) { + localctx = NewDatabase_filestream_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1150, TSqlParserRULE_database_filestream_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14105) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14112) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserNON_TRANSACTED_ACCESS: + { + p.SetState(14106) + p.Match(TSqlParserNON_TRANSACTED_ACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14107) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14108) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserFULL || _la == TSqlParserOFF || _la == TSqlParserREAD_ONLY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserDIRECTORY_NAME: + { + p.SetState(14109) + p.Match(TSqlParserDIRECTORY_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14110) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14111) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(14114) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatabase_file_specContext is an interface to support dynamic dispatch. +type IDatabase_file_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + File_group() IFile_groupContext + File_spec() IFile_specContext + + // IsDatabase_file_specContext differentiates from other interfaces. + IsDatabase_file_specContext() +} + +type Database_file_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_file_specContext() *Database_file_specContext { + var p = new(Database_file_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_database_file_spec + return p +} + +func InitEmptyDatabase_file_specContext(p *Database_file_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_database_file_spec +} + +func (*Database_file_specContext) IsDatabase_file_specContext() {} + +func NewDatabase_file_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_file_specContext { + var p = new(Database_file_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_database_file_spec + + return p +} + +func (s *Database_file_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_file_specContext) File_group() IFile_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_groupContext) +} + +func (s *Database_file_specContext) File_spec() IFile_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_specContext) +} + +func (s *Database_file_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_file_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_file_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDatabase_file_spec(s) + } +} + +func (s *Database_file_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDatabase_file_spec(s) + } +} + +func (s *Database_file_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDatabase_file_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Database_file_spec() (localctx IDatabase_file_specContext) { + localctx = NewDatabase_file_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1152, TSqlParserRULE_database_file_spec) + p.SetState(14118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserFILEGROUP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14116) + p.File_group() + } + + case TSqlParserLR_BRACKET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14117) + p.File_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFile_groupContext is an interface to support dynamic dispatch. +type IFile_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FILEGROUP() antlr.TerminalNode + Id_() IId_Context + AllFile_spec() []IFile_specContext + File_spec(i int) IFile_specContext + AllCONTAINS() []antlr.TerminalNode + CONTAINS(i int) antlr.TerminalNode + FILESTREAM() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + MEMORY_OPTIMIZED_DATA() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFile_groupContext differentiates from other interfaces. + IsFile_groupContext() +} + +type File_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_groupContext() *File_groupContext { + var p = new(File_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_file_group + return p +} + +func InitEmptyFile_groupContext(p *File_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_file_group +} + +func (*File_groupContext) IsFile_groupContext() {} + +func NewFile_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_groupContext { + var p = new(File_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_file_group + + return p +} + +func (s *File_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_groupContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROUP, 0) +} + +func (s *File_groupContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *File_groupContext) AllFile_spec() []IFile_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specContext); ok { + len++ + } + } + + tst := make([]IFile_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specContext); ok { + tst[i] = t.(IFile_specContext) + i++ + } + } + + return tst +} + +func (s *File_groupContext) File_spec(i int) IFile_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specContext) +} + +func (s *File_groupContext) AllCONTAINS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCONTAINS) +} + +func (s *File_groupContext) CONTAINS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCONTAINS, i) +} + +func (s *File_groupContext) FILESTREAM() antlr.TerminalNode { + return s.GetToken(TSqlParserFILESTREAM, 0) +} + +func (s *File_groupContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT, 0) +} + +func (s *File_groupContext) MEMORY_OPTIMIZED_DATA() antlr.TerminalNode { + return s.GetToken(TSqlParserMEMORY_OPTIMIZED_DATA, 0) +} + +func (s *File_groupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *File_groupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *File_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFile_group(s) + } +} + +func (s *File_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFile_group(s) + } +} + +func (s *File_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFile_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) File_group() (localctx IFile_groupContext) { + localctx = NewFile_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1154, TSqlParserRULE_file_group) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14120) + p.Match(TSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14121) + p.Id_() + } + p.SetState(14124) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1764, p.GetParserRuleContext()) == 1 { + { + p.SetState(14122) + p.Match(TSqlParserCONTAINS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14123) + p.Match(TSqlParserFILESTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserDEFAULT { + { + p.SetState(14126) + p.Match(TSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCONTAINS { + { + p.SetState(14129) + p.Match(TSqlParserCONTAINS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14130) + p.Match(TSqlParserMEMORY_OPTIMIZED_DATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14133) + p.File_spec() + } + p.SetState(14138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1767, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(14134) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14135) + p.File_spec() + } + + } + p.SetState(14140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1767, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFile_specContext is an interface to support dynamic dispatch. +type IFile_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFile returns the file token. + GetFile() antlr.Token + + // SetFile sets the file token. + SetFile(antlr.Token) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + NAME() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + FILENAME() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + Id_() IId_Context + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SIZE() antlr.TerminalNode + AllFile_size() []IFile_sizeContext + File_size(i int) IFile_sizeContext + MAXSIZE() antlr.TerminalNode + FILEGROWTH() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + + // IsFile_specContext differentiates from other interfaces. + IsFile_specContext() +} + +type File_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + file antlr.Token +} + +func NewEmptyFile_specContext() *File_specContext { + var p = new(File_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_file_spec + return p +} + +func InitEmptyFile_specContext(p *File_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_file_spec +} + +func (*File_specContext) IsFile_specContext() {} + +func NewFile_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_specContext { + var p = new(File_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_file_spec + + return p +} + +func (s *File_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_specContext) GetFile() antlr.Token { return s.file } + +func (s *File_specContext) SetFile(v antlr.Token) { s.file = v } + +func (s *File_specContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *File_specContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *File_specContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *File_specContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *File_specContext) FILENAME() antlr.TerminalNode { + return s.GetToken(TSqlParserFILENAME, 0) +} + +func (s *File_specContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *File_specContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *File_specContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *File_specContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *File_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *File_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *File_specContext) SIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserSIZE, 0) +} + +func (s *File_specContext) AllFile_size() []IFile_sizeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_sizeContext); ok { + len++ + } + } + + tst := make([]IFile_sizeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_sizeContext); ok { + tst[i] = t.(IFile_sizeContext) + i++ + } + } + + return tst +} + +func (s *File_specContext) File_size(i int) IFile_sizeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_sizeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_sizeContext) +} + +func (s *File_specContext) MAXSIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXSIZE, 0) +} + +func (s *File_specContext) FILEGROWTH() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROWTH, 0) +} + +func (s *File_specContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(TSqlParserUNLIMITED, 0) +} + +func (s *File_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFile_spec(s) + } +} + +func (s *File_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFile_spec(s) + } +} + +func (s *File_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFile_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) File_spec() (localctx IFile_specContext) { + localctx = NewFile_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1156, TSqlParserRULE_file_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14141) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14142) + p.Match(TSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14143) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(14144) + p.Id_() + } + + case TSqlParserSTRING: + { + p.SetState(14145) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(14148) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14151) + p.Match(TSqlParserFILENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14152) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14153) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*File_specContext).file = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(14154) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserSIZE { + { + p.SetState(14157) + p.Match(TSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14158) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14159) + p.File_size() + } + p.SetState(14161) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(14160) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(14174) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMAXSIZE { + { + p.SetState(14165) + p.Match(TSqlParserMAXSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14166) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserDECIMAL: + { + p.SetState(14167) + p.File_size() + } + + case TSqlParserUNLIMITED: + { + p.SetState(14168) + p.Match(TSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14172) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(14171) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(14182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserFILEGROWTH { + { + p.SetState(14176) + p.Match(TSqlParserFILEGROWTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14177) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14178) + p.File_size() + } + p.SetState(14180) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(14179) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + { + p.SetState(14184) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEntity_nameContext is an interface to support dynamic dispatch. +type IEntity_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetServer returns the server rule contexts. + GetServer() IId_Context + + // GetDatabase returns the database rule contexts. + GetDatabase() IId_Context + + // GetSchema returns the schema rule contexts. + GetSchema() IId_Context + + // GetTable returns the table rule contexts. + GetTable() IId_Context + + // SetServer sets the server rule contexts. + SetServer(IId_Context) + + // SetDatabase sets the database rule contexts. + SetDatabase(IId_Context) + + // SetSchema sets the schema rule contexts. + SetSchema(IId_Context) + + // SetTable sets the table rule contexts. + SetTable(IId_Context) + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsEntity_nameContext differentiates from other interfaces. + IsEntity_nameContext() +} + +type Entity_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + server IId_Context + database IId_Context + schema IId_Context + table IId_Context +} + +func NewEmptyEntity_nameContext() *Entity_nameContext { + var p = new(Entity_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_entity_name + return p +} + +func InitEmptyEntity_nameContext(p *Entity_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_entity_name +} + +func (*Entity_nameContext) IsEntity_nameContext() {} + +func NewEntity_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Entity_nameContext { + var p = new(Entity_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_entity_name + + return p +} + +func (s *Entity_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Entity_nameContext) GetServer() IId_Context { return s.server } + +func (s *Entity_nameContext) GetDatabase() IId_Context { return s.database } + +func (s *Entity_nameContext) GetSchema() IId_Context { return s.schema } + +func (s *Entity_nameContext) GetTable() IId_Context { return s.table } + +func (s *Entity_nameContext) SetServer(v IId_Context) { s.server = v } + +func (s *Entity_nameContext) SetDatabase(v IId_Context) { s.database = v } + +func (s *Entity_nameContext) SetSchema(v IId_Context) { s.schema = v } + +func (s *Entity_nameContext) SetTable(v IId_Context) { s.table = v } + +func (s *Entity_nameContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Entity_nameContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Entity_nameContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Entity_nameContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Entity_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Entity_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Entity_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEntity_name(s) + } +} + +func (s *Entity_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEntity_name(s) + } +} + +func (s *Entity_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEntity_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Entity_name() (localctx IEntity_nameContext) { + localctx = NewEntity_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1158, TSqlParserRULE_entity_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14203) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1779, p.GetParserRuleContext()) == 1 { + { + p.SetState(14186) + + var _x = p.Id_() + + localctx.(*Entity_nameContext).server = _x + } + { + p.SetState(14187) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14188) + + var _x = p.Id_() + + localctx.(*Entity_nameContext).database = _x + } + { + p.SetState(14189) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14190) + + var _x = p.Id_() + + localctx.(*Entity_nameContext).schema = _x + } + { + p.SetState(14191) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1779, p.GetParserRuleContext()) == 2 { + { + p.SetState(14193) + + var _x = p.Id_() + + localctx.(*Entity_nameContext).database = _x + } + { + p.SetState(14194) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14196) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&22413823) != 0) { + { + p.SetState(14195) + + var _x = p.Id_() + + localctx.(*Entity_nameContext).schema = _x + } + + } + { + p.SetState(14198) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1779, p.GetParserRuleContext()) == 3 { + { + p.SetState(14200) + + var _x = p.Id_() + + localctx.(*Entity_nameContext).schema = _x + } + { + p.SetState(14201) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(14205) + + var _x = p.Id_() + + localctx.(*Entity_nameContext).table = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEntity_name_for_azure_dwContext is an interface to support dynamic dispatch. +type IEntity_name_for_azure_dwContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema returns the schema rule contexts. + GetSchema() IId_Context + + // GetObject_name returns the object_name rule contexts. + GetObject_name() IId_Context + + // SetSchema sets the schema rule contexts. + SetSchema(IId_Context) + + // SetObject_name sets the object_name rule contexts. + SetObject_name(IId_Context) + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + DOT() antlr.TerminalNode + + // IsEntity_name_for_azure_dwContext differentiates from other interfaces. + IsEntity_name_for_azure_dwContext() +} + +type Entity_name_for_azure_dwContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema IId_Context + object_name IId_Context +} + +func NewEmptyEntity_name_for_azure_dwContext() *Entity_name_for_azure_dwContext { + var p = new(Entity_name_for_azure_dwContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_entity_name_for_azure_dw + return p +} + +func InitEmptyEntity_name_for_azure_dwContext(p *Entity_name_for_azure_dwContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_entity_name_for_azure_dw +} + +func (*Entity_name_for_azure_dwContext) IsEntity_name_for_azure_dwContext() {} + +func NewEntity_name_for_azure_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Entity_name_for_azure_dwContext { + var p = new(Entity_name_for_azure_dwContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_entity_name_for_azure_dw + + return p +} + +func (s *Entity_name_for_azure_dwContext) GetParser() antlr.Parser { return s.parser } + +func (s *Entity_name_for_azure_dwContext) GetSchema() IId_Context { return s.schema } + +func (s *Entity_name_for_azure_dwContext) GetObject_name() IId_Context { return s.object_name } + +func (s *Entity_name_for_azure_dwContext) SetSchema(v IId_Context) { s.schema = v } + +func (s *Entity_name_for_azure_dwContext) SetObject_name(v IId_Context) { s.object_name = v } + +func (s *Entity_name_for_azure_dwContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Entity_name_for_azure_dwContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Entity_name_for_azure_dwContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Entity_name_for_azure_dwContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Entity_name_for_azure_dwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Entity_name_for_azure_dwContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEntity_name_for_azure_dw(s) + } +} + +func (s *Entity_name_for_azure_dwContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEntity_name_for_azure_dw(s) + } +} + +func (s *Entity_name_for_azure_dwContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEntity_name_for_azure_dw(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Entity_name_for_azure_dw() (localctx IEntity_name_for_azure_dwContext) { + localctx = NewEntity_name_for_azure_dwContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1160, TSqlParserRULE_entity_name_for_azure_dw) + p.SetState(14212) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1780, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14207) + + var _x = p.Id_() + + localctx.(*Entity_name_for_azure_dwContext).schema = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14208) + + var _x = p.Id_() + + localctx.(*Entity_name_for_azure_dwContext).schema = _x + } + { + p.SetState(14209) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14210) + + var _x = p.Id_() + + localctx.(*Entity_name_for_azure_dwContext).object_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEntity_name_for_parallel_dwContext is an interface to support dynamic dispatch. +type IEntity_name_for_parallel_dwContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_database returns the schema_database rule contexts. + GetSchema_database() IId_Context + + // GetSchema returns the schema rule contexts. + GetSchema() IId_Context + + // GetObject_name returns the object_name rule contexts. + GetObject_name() IId_Context + + // SetSchema_database sets the schema_database rule contexts. + SetSchema_database(IId_Context) + + // SetSchema sets the schema rule contexts. + SetSchema(IId_Context) + + // SetObject_name sets the object_name rule contexts. + SetObject_name(IId_Context) + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + DOT() antlr.TerminalNode + + // IsEntity_name_for_parallel_dwContext differentiates from other interfaces. + IsEntity_name_for_parallel_dwContext() +} + +type Entity_name_for_parallel_dwContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_database IId_Context + schema IId_Context + object_name IId_Context +} + +func NewEmptyEntity_name_for_parallel_dwContext() *Entity_name_for_parallel_dwContext { + var p = new(Entity_name_for_parallel_dwContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_entity_name_for_parallel_dw + return p +} + +func InitEmptyEntity_name_for_parallel_dwContext(p *Entity_name_for_parallel_dwContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_entity_name_for_parallel_dw +} + +func (*Entity_name_for_parallel_dwContext) IsEntity_name_for_parallel_dwContext() {} + +func NewEntity_name_for_parallel_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Entity_name_for_parallel_dwContext { + var p = new(Entity_name_for_parallel_dwContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_entity_name_for_parallel_dw + + return p +} + +func (s *Entity_name_for_parallel_dwContext) GetParser() antlr.Parser { return s.parser } + +func (s *Entity_name_for_parallel_dwContext) GetSchema_database() IId_Context { + return s.schema_database +} + +func (s *Entity_name_for_parallel_dwContext) GetSchema() IId_Context { return s.schema } + +func (s *Entity_name_for_parallel_dwContext) GetObject_name() IId_Context { return s.object_name } + +func (s *Entity_name_for_parallel_dwContext) SetSchema_database(v IId_Context) { s.schema_database = v } + +func (s *Entity_name_for_parallel_dwContext) SetSchema(v IId_Context) { s.schema = v } + +func (s *Entity_name_for_parallel_dwContext) SetObject_name(v IId_Context) { s.object_name = v } + +func (s *Entity_name_for_parallel_dwContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Entity_name_for_parallel_dwContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Entity_name_for_parallel_dwContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Entity_name_for_parallel_dwContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Entity_name_for_parallel_dwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Entity_name_for_parallel_dwContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEntity_name_for_parallel_dw(s) + } +} + +func (s *Entity_name_for_parallel_dwContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEntity_name_for_parallel_dw(s) + } +} + +func (s *Entity_name_for_parallel_dwContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEntity_name_for_parallel_dw(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Entity_name_for_parallel_dw() (localctx IEntity_name_for_parallel_dwContext) { + localctx = NewEntity_name_for_parallel_dwContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1162, TSqlParserRULE_entity_name_for_parallel_dw) + p.SetState(14219) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1781, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14214) + + var _x = p.Id_() + + localctx.(*Entity_name_for_parallel_dwContext).schema_database = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14215) + + var _x = p.Id_() + + localctx.(*Entity_name_for_parallel_dwContext).schema = _x + } + { + p.SetState(14216) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14217) + + var _x = p.Id_() + + localctx.(*Entity_name_for_parallel_dwContext).object_name = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFull_table_nameContext is an interface to support dynamic dispatch. +type IFull_table_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + DoubleDotID() IDoubleDotIDContext + AllDotID() []IDotIDContext + DotID(i int) IDotIDContext + + // IsFull_table_nameContext differentiates from other interfaces. + IsFull_table_nameContext() +} + +type Full_table_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFull_table_nameContext() *Full_table_nameContext { + var p = new(Full_table_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_full_table_name + return p +} + +func InitEmptyFull_table_nameContext(p *Full_table_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_full_table_name +} + +func (*Full_table_nameContext) IsFull_table_nameContext() {} + +func NewFull_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Full_table_nameContext { + var p = new(Full_table_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_full_table_name + + return p +} + +func (s *Full_table_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Full_table_nameContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Full_table_nameContext) DoubleDotID() IDoubleDotIDContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDoubleDotIDContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDoubleDotIDContext) +} + +func (s *Full_table_nameContext) AllDotID() []IDotIDContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDotIDContext); ok { + len++ + } + } + + tst := make([]IDotIDContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDotIDContext); ok { + tst[i] = t.(IDotIDContext) + i++ + } + } + + return tst +} + +func (s *Full_table_nameContext) DotID(i int) IDotIDContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDotIDContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDotIDContext) +} + +func (s *Full_table_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Full_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Full_table_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFull_table_name(s) + } +} + +func (s *Full_table_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFull_table_name(s) + } +} + +func (s *Full_table_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFull_table_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Full_table_name() (localctx IFull_table_nameContext) { + localctx = NewFull_table_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1164, TSqlParserRULE_full_table_name) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14221) + p.Id_() + } + p.SetState(14231) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1784, p.GetParserRuleContext()) == 1 { + p.SetState(14223) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(14222) + p.DotID() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14225) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1782, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1784, p.GetParserRuleContext()) == 2 { + { + p.SetState(14227) + p.DoubleDotID() + } + p.SetState(14229) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1783, p.GetParserRuleContext()) == 1 { + { + p.SetState(14228) + p.DotID() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDotIDContext is an interface to support dynamic dispatch. +type IDotIDContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DOT() antlr.TerminalNode + Id_() IId_Context + + // IsDotIDContext differentiates from other interfaces. + IsDotIDContext() +} + +type DotIDContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDotIDContext() *DotIDContext { + var p = new(DotIDContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dotID + return p +} + +func InitEmptyDotIDContext(p *DotIDContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_dotID +} + +func (*DotIDContext) IsDotIDContext() {} + +func NewDotIDContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DotIDContext { + var p = new(DotIDContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_dotID + + return p +} + +func (s *DotIDContext) GetParser() antlr.Parser { return s.parser } + +func (s *DotIDContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *DotIDContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *DotIDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DotIDContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DotIDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDotID(s) + } +} + +func (s *DotIDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDotID(s) + } +} + +func (s *DotIDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDotID(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) DotID() (localctx IDotIDContext) { + localctx = NewDotIDContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1166, TSqlParserRULE_dotID) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14233) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14234) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDoubleDotIDContext is an interface to support dynamic dispatch. +type IDoubleDotIDContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + Id_() IId_Context + + // IsDoubleDotIDContext differentiates from other interfaces. + IsDoubleDotIDContext() +} + +type DoubleDotIDContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDoubleDotIDContext() *DoubleDotIDContext { + var p = new(DoubleDotIDContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_doubleDotID + return p +} + +func InitEmptyDoubleDotIDContext(p *DoubleDotIDContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_doubleDotID +} + +func (*DoubleDotIDContext) IsDoubleDotIDContext() {} + +func NewDoubleDotIDContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DoubleDotIDContext { + var p = new(DoubleDotIDContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_doubleDotID + + return p +} + +func (s *DoubleDotIDContext) GetParser() antlr.Parser { return s.parser } + +func (s *DoubleDotIDContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *DoubleDotIDContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *DoubleDotIDContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *DoubleDotIDContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DoubleDotIDContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DoubleDotIDContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDoubleDotID(s) + } +} + +func (s *DoubleDotIDContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDoubleDotID(s) + } +} + +func (s *DoubleDotIDContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDoubleDotID(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) DoubleDotID() (localctx IDoubleDotIDContext) { + localctx = NewDoubleDotIDContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1168, TSqlParserRULE_doubleDotID) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14236) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14237) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14238) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_nameContext is an interface to support dynamic dispatch. +type ITable_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBlocking_hierarchy returns the blocking_hierarchy token. + GetBlocking_hierarchy() antlr.Token + + // SetBlocking_hierarchy sets the blocking_hierarchy token. + SetBlocking_hierarchy(antlr.Token) + + // GetDatabase returns the database rule contexts. + GetDatabase() IId_Context + + // GetSchema returns the schema rule contexts. + GetSchema() IId_Context + + // GetTable returns the table rule contexts. + GetTable() IId_Context + + // SetDatabase sets the database rule contexts. + SetDatabase(IId_Context) + + // SetSchema sets the schema rule contexts. + SetSchema(IId_Context) + + // SetTable sets the table rule contexts. + SetTable(IId_Context) + + // Getter signatures + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + BLOCKING_HIERARCHY() antlr.TerminalNode + + // IsTable_nameContext differentiates from other interfaces. + IsTable_nameContext() +} + +type Table_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database IId_Context + schema IId_Context + table IId_Context + blocking_hierarchy antlr.Token +} + +func NewEmptyTable_nameContext() *Table_nameContext { + var p = new(Table_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_name + return p +} + +func InitEmptyTable_nameContext(p *Table_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_table_name +} + +func (*Table_nameContext) IsTable_nameContext() {} + +func NewTable_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_nameContext { + var p = new(Table_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_table_name + + return p +} + +func (s *Table_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_nameContext) GetBlocking_hierarchy() antlr.Token { return s.blocking_hierarchy } + +func (s *Table_nameContext) SetBlocking_hierarchy(v antlr.Token) { s.blocking_hierarchy = v } + +func (s *Table_nameContext) GetDatabase() IId_Context { return s.database } + +func (s *Table_nameContext) GetSchema() IId_Context { return s.schema } + +func (s *Table_nameContext) GetTable() IId_Context { return s.table } + +func (s *Table_nameContext) SetDatabase(v IId_Context) { s.database = v } + +func (s *Table_nameContext) SetSchema(v IId_Context) { s.schema = v } + +func (s *Table_nameContext) SetTable(v IId_Context) { s.table = v } + +func (s *Table_nameContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Table_nameContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Table_nameContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Table_nameContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Table_nameContext) BLOCKING_HIERARCHY() antlr.TerminalNode { + return s.GetToken(TSqlParserBLOCKING_HIERARCHY, 0) +} + +func (s *Table_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterTable_name(s) + } +} + +func (s *Table_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitTable_name(s) + } +} + +func (s *Table_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitTable_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Table_name() (localctx ITable_nameContext) { + localctx = NewTable_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1170, TSqlParserRULE_table_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14250) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1786, p.GetParserRuleContext()) == 1 { + { + p.SetState(14240) + + var _x = p.Id_() + + localctx.(*Table_nameContext).database = _x + } + { + p.SetState(14241) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&22413823) != 0) { + { + p.SetState(14242) + + var _x = p.Id_() + + localctx.(*Table_nameContext).schema = _x + } + + } + { + p.SetState(14245) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1786, p.GetParserRuleContext()) == 2 { + { + p.SetState(14247) + + var _x = p.Id_() + + localctx.(*Table_nameContext).schema = _x + } + { + p.SetState(14248) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1787, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14252) + + var _x = p.Id_() + + localctx.(*Table_nameContext).table = _x + } + + case 2: + { + p.SetState(14253) + + var _m = p.Match(TSqlParserBLOCKING_HIERARCHY) + + localctx.(*Table_nameContext).blocking_hierarchy = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimple_nameContext is an interface to support dynamic dispatch. +type ISimple_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema returns the schema rule contexts. + GetSchema() IId_Context + + // GetName returns the name rule contexts. + GetName() IId_Context + + // SetSchema sets the schema rule contexts. + SetSchema(IId_Context) + + // SetName sets the name rule contexts. + SetName(IId_Context) + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + DOT() antlr.TerminalNode + + // IsSimple_nameContext differentiates from other interfaces. + IsSimple_nameContext() +} + +type Simple_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema IId_Context + name IId_Context +} + +func NewEmptySimple_nameContext() *Simple_nameContext { + var p = new(Simple_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_simple_name + return p +} + +func InitEmptySimple_nameContext(p *Simple_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_simple_name +} + +func (*Simple_nameContext) IsSimple_nameContext() {} + +func NewSimple_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_nameContext { + var p = new(Simple_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_simple_name + + return p +} + +func (s *Simple_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Simple_nameContext) GetSchema() IId_Context { return s.schema } + +func (s *Simple_nameContext) GetName() IId_Context { return s.name } + +func (s *Simple_nameContext) SetSchema(v IId_Context) { s.schema = v } + +func (s *Simple_nameContext) SetName(v IId_Context) { s.name = v } + +func (s *Simple_nameContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Simple_nameContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Simple_nameContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Simple_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Simple_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Simple_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSimple_name(s) + } +} + +func (s *Simple_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSimple_name(s) + } +} + +func (s *Simple_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSimple_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Simple_name() (localctx ISimple_nameContext) { + localctx = NewSimple_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1172, TSqlParserRULE_simple_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(14259) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1788, p.GetParserRuleContext()) == 1 { + { + p.SetState(14256) + + var _x = p.Id_() + + localctx.(*Simple_nameContext).schema = _x + } + { + p.SetState(14257) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(14261) + + var _x = p.Id_() + + localctx.(*Simple_nameContext).name = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_proc_name_schemaContext is an interface to support dynamic dispatch. +type IFunc_proc_name_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema returns the schema rule contexts. + GetSchema() IId_Context + + // GetProcedure returns the procedure rule contexts. + GetProcedure() IId_Context + + // SetSchema sets the schema rule contexts. + SetSchema(IId_Context) + + // SetProcedure sets the procedure rule contexts. + SetProcedure(IId_Context) + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + DOT() antlr.TerminalNode + + // IsFunc_proc_name_schemaContext differentiates from other interfaces. + IsFunc_proc_name_schemaContext() +} + +type Func_proc_name_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema IId_Context + procedure IId_Context +} + +func NewEmptyFunc_proc_name_schemaContext() *Func_proc_name_schemaContext { + var p = new(Func_proc_name_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_func_proc_name_schema + return p +} + +func InitEmptyFunc_proc_name_schemaContext(p *Func_proc_name_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_func_proc_name_schema +} + +func (*Func_proc_name_schemaContext) IsFunc_proc_name_schemaContext() {} + +func NewFunc_proc_name_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_proc_name_schemaContext { + var p = new(Func_proc_name_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_func_proc_name_schema + + return p +} + +func (s *Func_proc_name_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_proc_name_schemaContext) GetSchema() IId_Context { return s.schema } + +func (s *Func_proc_name_schemaContext) GetProcedure() IId_Context { return s.procedure } + +func (s *Func_proc_name_schemaContext) SetSchema(v IId_Context) { s.schema = v } + +func (s *Func_proc_name_schemaContext) SetProcedure(v IId_Context) { s.procedure = v } + +func (s *Func_proc_name_schemaContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Func_proc_name_schemaContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Func_proc_name_schemaContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Func_proc_name_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_proc_name_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_proc_name_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFunc_proc_name_schema(s) + } +} + +func (s *Func_proc_name_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFunc_proc_name_schema(s) + } +} + +func (s *Func_proc_name_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFunc_proc_name_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Func_proc_name_schema() (localctx IFunc_proc_name_schemaContext) { + localctx = NewFunc_proc_name_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1174, TSqlParserRULE_func_proc_name_schema) + p.EnterOuterAlt(localctx, 1) + p.SetState(14266) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1789, p.GetParserRuleContext()) == 1 { + { + p.SetState(14263) + + var _x = p.Id_() + + localctx.(*Func_proc_name_schemaContext).schema = _x + } + + { + p.SetState(14264) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(14268) + + var _x = p.Id_() + + localctx.(*Func_proc_name_schemaContext).procedure = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_proc_name_database_schemaContext is an interface to support dynamic dispatch. +type IFunc_proc_name_database_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatabase returns the database rule contexts. + GetDatabase() IId_Context + + // GetSchema returns the schema rule contexts. + GetSchema() IId_Context + + // GetProcedure returns the procedure rule contexts. + GetProcedure() IId_Context + + // SetDatabase sets the database rule contexts. + SetDatabase(IId_Context) + + // SetSchema sets the schema rule contexts. + SetSchema(IId_Context) + + // SetProcedure sets the procedure rule contexts. + SetProcedure(IId_Context) + + // Getter signatures + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + Func_proc_name_schema() IFunc_proc_name_schemaContext + + // IsFunc_proc_name_database_schemaContext differentiates from other interfaces. + IsFunc_proc_name_database_schemaContext() +} + +type Func_proc_name_database_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database IId_Context + schema IId_Context + procedure IId_Context +} + +func NewEmptyFunc_proc_name_database_schemaContext() *Func_proc_name_database_schemaContext { + var p = new(Func_proc_name_database_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_func_proc_name_database_schema + return p +} + +func InitEmptyFunc_proc_name_database_schemaContext(p *Func_proc_name_database_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_func_proc_name_database_schema +} + +func (*Func_proc_name_database_schemaContext) IsFunc_proc_name_database_schemaContext() {} + +func NewFunc_proc_name_database_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_proc_name_database_schemaContext { + var p = new(Func_proc_name_database_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_func_proc_name_database_schema + + return p +} + +func (s *Func_proc_name_database_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_proc_name_database_schemaContext) GetDatabase() IId_Context { return s.database } + +func (s *Func_proc_name_database_schemaContext) GetSchema() IId_Context { return s.schema } + +func (s *Func_proc_name_database_schemaContext) GetProcedure() IId_Context { return s.procedure } + +func (s *Func_proc_name_database_schemaContext) SetDatabase(v IId_Context) { s.database = v } + +func (s *Func_proc_name_database_schemaContext) SetSchema(v IId_Context) { s.schema = v } + +func (s *Func_proc_name_database_schemaContext) SetProcedure(v IId_Context) { s.procedure = v } + +func (s *Func_proc_name_database_schemaContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Func_proc_name_database_schemaContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Func_proc_name_database_schemaContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Func_proc_name_database_schemaContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Func_proc_name_database_schemaContext) Func_proc_name_schema() IFunc_proc_name_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_proc_name_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_proc_name_schemaContext) +} + +func (s *Func_proc_name_database_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_proc_name_database_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_proc_name_database_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFunc_proc_name_database_schema(s) + } +} + +func (s *Func_proc_name_database_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFunc_proc_name_database_schema(s) + } +} + +func (s *Func_proc_name_database_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFunc_proc_name_database_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Func_proc_name_database_schema() (localctx IFunc_proc_name_database_schemaContext) { + localctx = NewFunc_proc_name_database_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1176, TSqlParserRULE_func_proc_name_database_schema) + var _la int + + p.SetState(14280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1792, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(14271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&22413823) != 0) { + { + p.SetState(14270) + + var _x = p.Id_() + + localctx.(*Func_proc_name_database_schemaContext).database = _x + } + + } + { + p.SetState(14273) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&22413823) != 0) { + { + p.SetState(14274) + + var _x = p.Id_() + + localctx.(*Func_proc_name_database_schemaContext).schema = _x + } + + } + { + p.SetState(14277) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14278) + + var _x = p.Id_() + + localctx.(*Func_proc_name_database_schemaContext).procedure = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14279) + p.Func_proc_name_schema() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_proc_name_server_database_schemaContext is an interface to support dynamic dispatch. +type IFunc_proc_name_server_database_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetServer returns the server rule contexts. + GetServer() IId_Context + + // GetDatabase returns the database rule contexts. + GetDatabase() IId_Context + + // GetSchema returns the schema rule contexts. + GetSchema() IId_Context + + // GetProcedure returns the procedure rule contexts. + GetProcedure() IId_Context + + // SetServer sets the server rule contexts. + SetServer(IId_Context) + + // SetDatabase sets the database rule contexts. + SetDatabase(IId_Context) + + // SetSchema sets the schema rule contexts. + SetSchema(IId_Context) + + // SetProcedure sets the procedure rule contexts. + SetProcedure(IId_Context) + + // Getter signatures + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + Func_proc_name_database_schema() IFunc_proc_name_database_schemaContext + + // IsFunc_proc_name_server_database_schemaContext differentiates from other interfaces. + IsFunc_proc_name_server_database_schemaContext() +} + +type Func_proc_name_server_database_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + server IId_Context + database IId_Context + schema IId_Context + procedure IId_Context +} + +func NewEmptyFunc_proc_name_server_database_schemaContext() *Func_proc_name_server_database_schemaContext { + var p = new(Func_proc_name_server_database_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_func_proc_name_server_database_schema + return p +} + +func InitEmptyFunc_proc_name_server_database_schemaContext(p *Func_proc_name_server_database_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_func_proc_name_server_database_schema +} + +func (*Func_proc_name_server_database_schemaContext) IsFunc_proc_name_server_database_schemaContext() { +} + +func NewFunc_proc_name_server_database_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_proc_name_server_database_schemaContext { + var p = new(Func_proc_name_server_database_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_func_proc_name_server_database_schema + + return p +} + +func (s *Func_proc_name_server_database_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_proc_name_server_database_schemaContext) GetServer() IId_Context { return s.server } + +func (s *Func_proc_name_server_database_schemaContext) GetDatabase() IId_Context { return s.database } + +func (s *Func_proc_name_server_database_schemaContext) GetSchema() IId_Context { return s.schema } + +func (s *Func_proc_name_server_database_schemaContext) GetProcedure() IId_Context { return s.procedure } + +func (s *Func_proc_name_server_database_schemaContext) SetServer(v IId_Context) { s.server = v } + +func (s *Func_proc_name_server_database_schemaContext) SetDatabase(v IId_Context) { s.database = v } + +func (s *Func_proc_name_server_database_schemaContext) SetSchema(v IId_Context) { s.schema = v } + +func (s *Func_proc_name_server_database_schemaContext) SetProcedure(v IId_Context) { s.procedure = v } + +func (s *Func_proc_name_server_database_schemaContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Func_proc_name_server_database_schemaContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Func_proc_name_server_database_schemaContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Func_proc_name_server_database_schemaContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Func_proc_name_server_database_schemaContext) Func_proc_name_database_schema() IFunc_proc_name_database_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_proc_name_database_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_proc_name_database_schemaContext) +} + +func (s *Func_proc_name_server_database_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_proc_name_server_database_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_proc_name_server_database_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFunc_proc_name_server_database_schema(s) + } +} + +func (s *Func_proc_name_server_database_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFunc_proc_name_server_database_schema(s) + } +} + +func (s *Func_proc_name_server_database_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFunc_proc_name_server_database_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Func_proc_name_server_database_schema() (localctx IFunc_proc_name_server_database_schemaContext) { + localctx = NewFunc_proc_name_server_database_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1178, TSqlParserRULE_func_proc_name_server_database_schema) + var _la int + + p.SetState(14296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1796, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(14283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&22413823) != 0) { + { + p.SetState(14282) + + var _x = p.Id_() + + localctx.(*Func_proc_name_server_database_schemaContext).server = _x + } + + } + { + p.SetState(14285) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14287) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&22413823) != 0) { + { + p.SetState(14286) + + var _x = p.Id_() + + localctx.(*Func_proc_name_server_database_schemaContext).database = _x + } + + } + { + p.SetState(14289) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14291) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&22413823) != 0) { + { + p.SetState(14290) + + var _x = p.Id_() + + localctx.(*Func_proc_name_server_database_schemaContext).schema = _x + } + + } + { + p.SetState(14293) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14294) + + var _x = p.Id_() + + localctx.(*Func_proc_name_server_database_schemaContext).procedure = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14295) + p.Func_proc_name_database_schema() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDdl_objectContext is an interface to support dynamic dispatch. +type IDdl_objectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Full_table_name() IFull_table_nameContext + LOCAL_ID() antlr.TerminalNode + + // IsDdl_objectContext differentiates from other interfaces. + IsDdl_objectContext() +} + +type Ddl_objectContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDdl_objectContext() *Ddl_objectContext { + var p = new(Ddl_objectContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_ddl_object + return p +} + +func InitEmptyDdl_objectContext(p *Ddl_objectContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_ddl_object +} + +func (*Ddl_objectContext) IsDdl_objectContext() {} + +func NewDdl_objectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ddl_objectContext { + var p = new(Ddl_objectContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_ddl_object + + return p +} + +func (s *Ddl_objectContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ddl_objectContext) Full_table_name() IFull_table_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_table_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_table_nameContext) +} + +func (s *Ddl_objectContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Ddl_objectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ddl_objectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ddl_objectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterDdl_object(s) + } +} + +func (s *Ddl_objectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitDdl_object(s) + } +} + +func (s *Ddl_objectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitDdl_object(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Ddl_object() (localctx IDdl_objectContext) { + localctx = NewDdl_objectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1180, TSqlParserRULE_ddl_object) + p.SetState(14300) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14298) + p.Full_table_name() + } + + case TSqlParserLOCAL_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14299) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFull_column_nameContext is an interface to support dynamic dispatch. +type IFull_column_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetColumn_name returns the column_name rule contexts. + GetColumn_name() IId_Context + + // SetColumn_name sets the column_name rule contexts. + SetColumn_name(IId_Context) + + // Getter signatures + DELETED() antlr.TerminalNode + INSERTED() antlr.TerminalNode + Id_() IId_Context + DOLLAR() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + ROWGUID() antlr.TerminalNode + Full_table_name() IFull_table_nameContext + DOT() antlr.TerminalNode + + // IsFull_column_nameContext differentiates from other interfaces. + IsFull_column_nameContext() +} + +type Full_column_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + column_name IId_Context +} + +func NewEmptyFull_column_nameContext() *Full_column_nameContext { + var p = new(Full_column_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_full_column_name + return p +} + +func InitEmptyFull_column_nameContext(p *Full_column_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_full_column_name +} + +func (*Full_column_nameContext) IsFull_column_nameContext() {} + +func NewFull_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Full_column_nameContext { + var p = new(Full_column_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_full_column_name + + return p +} + +func (s *Full_column_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Full_column_nameContext) GetColumn_name() IId_Context { return s.column_name } + +func (s *Full_column_nameContext) SetColumn_name(v IId_Context) { s.column_name = v } + +func (s *Full_column_nameContext) DELETED() antlr.TerminalNode { + return s.GetToken(TSqlParserDELETED, 0) +} + +func (s *Full_column_nameContext) INSERTED() antlr.TerminalNode { + return s.GetToken(TSqlParserINSERTED, 0) +} + +func (s *Full_column_nameContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Full_column_nameContext) DOLLAR() antlr.TerminalNode { + return s.GetToken(TSqlParserDOLLAR, 0) +} + +func (s *Full_column_nameContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENTITY, 0) +} + +func (s *Full_column_nameContext) ROWGUID() antlr.TerminalNode { + return s.GetToken(TSqlParserROWGUID, 0) +} + +func (s *Full_column_nameContext) Full_table_name() IFull_table_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_table_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_table_nameContext) +} + +func (s *Full_column_nameContext) DOT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, 0) +} + +func (s *Full_column_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Full_column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Full_column_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFull_column_name(s) + } +} + +func (s *Full_column_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFull_column_name(s) + } +} + +func (s *Full_column_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFull_column_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Full_column_name() (localctx IFull_column_nameContext) { + localctx = NewFull_column_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1182, TSqlParserRULE_full_column_name) + var _la int + + p.SetState(14320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1801, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14302) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDELETED || _la == TSqlParserINSERTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(14306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(14303) + + var _x = p.Id_() + + localctx.(*Full_column_nameContext).column_name = _x + } + + case TSqlParserDOLLAR: + { + p.SetState(14304) + p.Match(TSqlParserDOLLAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14305) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserIDENTITY || _la == TSqlParserROWGUID) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14308) + p.Full_table_name() + } + { + p.SetState(14309) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14313) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(14310) + + var _x = p.Id_() + + localctx.(*Full_column_nameContext).column_name = _x + } + + case TSqlParserDOLLAR: + { + p.SetState(14311) + p.Match(TSqlParserDOLLAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14312) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserIDENTITY || _la == TSqlParserROWGUID) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + p.SetState(14318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + { + p.SetState(14315) + + var _x = p.Id_() + + localctx.(*Full_column_nameContext).column_name = _x + } + + case TSqlParserDOLLAR: + { + p.SetState(14316) + p.Match(TSqlParserDOLLAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14317) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserIDENTITY || _la == TSqlParserROWGUID) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_name_list_with_orderContext is an interface to support dynamic dispatch. +type IColumn_name_list_with_orderContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn_name_with_order() []IColumn_name_with_orderContext + Column_name_with_order(i int) IColumn_name_with_orderContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_name_list_with_orderContext differentiates from other interfaces. + IsColumn_name_list_with_orderContext() +} + +type Column_name_list_with_orderContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_name_list_with_orderContext() *Column_name_list_with_orderContext { + var p = new(Column_name_list_with_orderContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_name_list_with_order + return p +} + +func InitEmptyColumn_name_list_with_orderContext(p *Column_name_list_with_orderContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_name_list_with_order +} + +func (*Column_name_list_with_orderContext) IsColumn_name_list_with_orderContext() {} + +func NewColumn_name_list_with_orderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_name_list_with_orderContext { + var p = new(Column_name_list_with_orderContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_column_name_list_with_order + + return p +} + +func (s *Column_name_list_with_orderContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_name_list_with_orderContext) AllColumn_name_with_order() []IColumn_name_with_orderContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_name_with_orderContext); ok { + len++ + } + } + + tst := make([]IColumn_name_with_orderContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_name_with_orderContext); ok { + tst[i] = t.(IColumn_name_with_orderContext) + i++ + } + } + + return tst +} + +func (s *Column_name_list_with_orderContext) Column_name_with_order(i int) IColumn_name_with_orderContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_name_with_orderContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_name_with_orderContext) +} + +func (s *Column_name_list_with_orderContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Column_name_list_with_orderContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Column_name_list_with_orderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_name_list_with_orderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_name_list_with_orderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumn_name_list_with_order(s) + } +} + +func (s *Column_name_list_with_orderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumn_name_list_with_order(s) + } +} + +func (s *Column_name_list_with_orderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumn_name_list_with_order(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Column_name_list_with_order() (localctx IColumn_name_list_with_orderContext) { + localctx = NewColumn_name_list_with_orderContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1184, TSqlParserRULE_column_name_list_with_order) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14322) + p.Column_name_with_order() + } + p.SetState(14327) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(14323) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14324) + p.Column_name_with_order() + } + + p.SetState(14329) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_name_with_orderContext is an interface to support dynamic dispatch. +type IColumn_name_with_orderContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + + // IsColumn_name_with_orderContext differentiates from other interfaces. + IsColumn_name_with_orderContext() +} + +type Column_name_with_orderContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_name_with_orderContext() *Column_name_with_orderContext { + var p = new(Column_name_with_orderContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_name_with_order + return p +} + +func InitEmptyColumn_name_with_orderContext(p *Column_name_with_orderContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_name_with_order +} + +func (*Column_name_with_orderContext) IsColumn_name_with_orderContext() {} + +func NewColumn_name_with_orderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_name_with_orderContext { + var p = new(Column_name_with_orderContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_column_name_with_order + + return p +} + +func (s *Column_name_with_orderContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_name_with_orderContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Column_name_with_orderContext) ASC() antlr.TerminalNode { + return s.GetToken(TSqlParserASC, 0) +} + +func (s *Column_name_with_orderContext) DESC() antlr.TerminalNode { + return s.GetToken(TSqlParserDESC, 0) +} + +func (s *Column_name_with_orderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_name_with_orderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_name_with_orderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumn_name_with_order(s) + } +} + +func (s *Column_name_with_orderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumn_name_with_order(s) + } +} + +func (s *Column_name_with_orderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumn_name_with_order(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Column_name_with_order() (localctx IColumn_name_with_orderContext) { + localctx = NewColumn_name_with_orderContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1186, TSqlParserRULE_column_name_with_order) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14330) + p.Id_() + } + p.SetState(14332) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserASC || _la == TSqlParserDESC { + { + p.SetState(14331) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserASC || _la == TSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_column_name_listContext is an interface to support dynamic dispatch. +type IInsert_column_name_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_insert_column_id returns the _insert_column_id rule contexts. + Get_insert_column_id() IInsert_column_idContext + + // Set_insert_column_id sets the _insert_column_id rule contexts. + Set_insert_column_id(IInsert_column_idContext) + + // GetCol returns the col rule context list. + GetCol() []IInsert_column_idContext + + // SetCol sets the col rule context list. + SetCol([]IInsert_column_idContext) + + // Getter signatures + AllInsert_column_id() []IInsert_column_idContext + Insert_column_id(i int) IInsert_column_idContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsInsert_column_name_listContext differentiates from other interfaces. + IsInsert_column_name_listContext() +} + +type Insert_column_name_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _insert_column_id IInsert_column_idContext + col []IInsert_column_idContext +} + +func NewEmptyInsert_column_name_listContext() *Insert_column_name_listContext { + var p = new(Insert_column_name_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_insert_column_name_list + return p +} + +func InitEmptyInsert_column_name_listContext(p *Insert_column_name_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_insert_column_name_list +} + +func (*Insert_column_name_listContext) IsInsert_column_name_listContext() {} + +func NewInsert_column_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_column_name_listContext { + var p = new(Insert_column_name_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_insert_column_name_list + + return p +} + +func (s *Insert_column_name_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_column_name_listContext) Get_insert_column_id() IInsert_column_idContext { + return s._insert_column_id +} + +func (s *Insert_column_name_listContext) Set_insert_column_id(v IInsert_column_idContext) { + s._insert_column_id = v +} + +func (s *Insert_column_name_listContext) GetCol() []IInsert_column_idContext { return s.col } + +func (s *Insert_column_name_listContext) SetCol(v []IInsert_column_idContext) { s.col = v } + +func (s *Insert_column_name_listContext) AllInsert_column_id() []IInsert_column_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInsert_column_idContext); ok { + len++ + } + } + + tst := make([]IInsert_column_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInsert_column_idContext); ok { + tst[i] = t.(IInsert_column_idContext) + i++ + } + } + + return tst +} + +func (s *Insert_column_name_listContext) Insert_column_id(i int) IInsert_column_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_column_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInsert_column_idContext) +} + +func (s *Insert_column_name_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Insert_column_name_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Insert_column_name_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_column_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_column_name_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterInsert_column_name_list(s) + } +} + +func (s *Insert_column_name_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitInsert_column_name_list(s) + } +} + +func (s *Insert_column_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitInsert_column_name_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Insert_column_name_list() (localctx IInsert_column_name_listContext) { + localctx = NewInsert_column_name_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1188, TSqlParserRULE_insert_column_name_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14334) + + var _x = p.Insert_column_id() + + localctx.(*Insert_column_name_listContext)._insert_column_id = _x + } + localctx.(*Insert_column_name_listContext).col = append(localctx.(*Insert_column_name_listContext).col, localctx.(*Insert_column_name_listContext)._insert_column_id) + p.SetState(14339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(14335) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14336) + + var _x = p.Insert_column_id() + + localctx.(*Insert_column_name_listContext)._insert_column_id = _x + } + localctx.(*Insert_column_name_listContext).col = append(localctx.(*Insert_column_name_listContext).col, localctx.(*Insert_column_name_listContext)._insert_column_id) + + p.SetState(14341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_column_idContext is an interface to support dynamic dispatch. +type IInsert_column_idContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_id_ returns the _id_ rule contexts. + Get_id_() IId_Context + + // Set_id_ sets the _id_ rule contexts. + Set_id_(IId_Context) + + // GetIgnore returns the ignore rule context list. + GetIgnore() []IId_Context + + // SetIgnore sets the ignore rule context list. + SetIgnore([]IId_Context) + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsInsert_column_idContext differentiates from other interfaces. + IsInsert_column_idContext() +} + +type Insert_column_idContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _id_ IId_Context + ignore []IId_Context +} + +func NewEmptyInsert_column_idContext() *Insert_column_idContext { + var p = new(Insert_column_idContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_insert_column_id + return p +} + +func InitEmptyInsert_column_idContext(p *Insert_column_idContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_insert_column_id +} + +func (*Insert_column_idContext) IsInsert_column_idContext() {} + +func NewInsert_column_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_column_idContext { + var p = new(Insert_column_idContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_insert_column_id + + return p +} + +func (s *Insert_column_idContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_column_idContext) Get_id_() IId_Context { return s._id_ } + +func (s *Insert_column_idContext) Set_id_(v IId_Context) { s._id_ = v } + +func (s *Insert_column_idContext) GetIgnore() []IId_Context { return s.ignore } + +func (s *Insert_column_idContext) SetIgnore(v []IId_Context) { s.ignore = v } + +func (s *Insert_column_idContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Insert_column_idContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Insert_column_idContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Insert_column_idContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Insert_column_idContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_column_idContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_column_idContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterInsert_column_id(s) + } +} + +func (s *Insert_column_idContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitInsert_column_id(s) + } +} + +func (s *Insert_column_idContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitInsert_column_id(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Insert_column_id() (localctx IInsert_column_idContext) { + localctx = NewInsert_column_idContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1190, TSqlParserRULE_insert_column_id) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14348) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1806, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(14343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4756364434024172545) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&22413823) != 0) { + { + p.SetState(14342) + + var _x = p.Id_() + + localctx.(*Insert_column_idContext)._id_ = _x + } + localctx.(*Insert_column_idContext).ignore = append(localctx.(*Insert_column_idContext).ignore, localctx.(*Insert_column_idContext)._id_) + + } + { + p.SetState(14345) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14350) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1806, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(14351) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_name_listContext is an interface to support dynamic dispatch. +type IColumn_name_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Get_id_ returns the _id_ rule contexts. + Get_id_() IId_Context + + // Set_id_ sets the _id_ rule contexts. + Set_id_(IId_Context) + + // GetCol returns the col rule context list. + GetCol() []IId_Context + + // SetCol sets the col rule context list. + SetCol([]IId_Context) + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_name_listContext differentiates from other interfaces. + IsColumn_name_listContext() +} + +type Column_name_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + _id_ IId_Context + col []IId_Context +} + +func NewEmptyColumn_name_listContext() *Column_name_listContext { + var p = new(Column_name_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_name_list + return p +} + +func InitEmptyColumn_name_listContext(p *Column_name_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_column_name_list +} + +func (*Column_name_listContext) IsColumn_name_listContext() {} + +func NewColumn_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_name_listContext { + var p = new(Column_name_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_column_name_list + + return p +} + +func (s *Column_name_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_name_listContext) Get_id_() IId_Context { return s._id_ } + +func (s *Column_name_listContext) Set_id_(v IId_Context) { s._id_ = v } + +func (s *Column_name_listContext) GetCol() []IId_Context { return s.col } + +func (s *Column_name_listContext) SetCol(v []IId_Context) { s.col = v } + +func (s *Column_name_listContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Column_name_listContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Column_name_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Column_name_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Column_name_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_name_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterColumn_name_list(s) + } +} + +func (s *Column_name_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitColumn_name_list(s) + } +} + +func (s *Column_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitColumn_name_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Column_name_list() (localctx IColumn_name_listContext) { + localctx = NewColumn_name_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1192, TSqlParserRULE_column_name_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14353) + + var _x = p.Id_() + + localctx.(*Column_name_listContext)._id_ = _x + } + localctx.(*Column_name_listContext).col = append(localctx.(*Column_name_listContext).col, localctx.(*Column_name_listContext)._id_) + p.SetState(14358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == TSqlParserCOMMA { + { + p.SetState(14354) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14355) + + var _x = p.Id_() + + localctx.(*Column_name_listContext)._id_ = _x + } + localctx.(*Column_name_listContext).col = append(localctx.(*Column_name_listContext).col, localctx.(*Column_name_listContext)._id_) + + p.SetState(14360) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICursor_nameContext is an interface to support dynamic dispatch. +type ICursor_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + LOCAL_ID() antlr.TerminalNode + + // IsCursor_nameContext differentiates from other interfaces. + IsCursor_nameContext() +} + +type Cursor_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_nameContext() *Cursor_nameContext { + var p = new(Cursor_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_cursor_name + return p +} + +func InitEmptyCursor_nameContext(p *Cursor_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_cursor_name +} + +func (*Cursor_nameContext) IsCursor_nameContext() {} + +func NewCursor_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_nameContext { + var p = new(Cursor_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_cursor_name + + return p +} + +func (s *Cursor_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_nameContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Cursor_nameContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Cursor_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterCursor_name(s) + } +} + +func (s *Cursor_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitCursor_name(s) + } +} + +func (s *Cursor_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitCursor_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Cursor_name() (localctx ICursor_nameContext) { + localctx = NewCursor_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1194, TSqlParserRULE_cursor_name) + p.SetState(14363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14361) + p.Id_() + } + + case TSqlParserLOCAL_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14362) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_offContext is an interface to support dynamic dispatch. +type IOn_offContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsOn_offContext differentiates from other interfaces. + IsOn_offContext() +} + +type On_offContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_offContext() *On_offContext { + var p = new(On_offContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_on_off + return p +} + +func InitEmptyOn_offContext(p *On_offContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_on_off +} + +func (*On_offContext) IsOn_offContext() {} + +func NewOn_offContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_offContext { + var p = new(On_offContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_on_off + + return p +} + +func (s *On_offContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_offContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *On_offContext) OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserOFF, 0) +} + +func (s *On_offContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_offContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_offContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterOn_off(s) + } +} + +func (s *On_offContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitOn_off(s) + } +} + +func (s *On_offContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitOn_off(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) On_off() (localctx IOn_offContext) { + localctx = NewOn_offContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1196, TSqlParserRULE_on_off) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14365) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserOFF || _la == TSqlParserON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClusteredContext is an interface to support dynamic dispatch. +type IClusteredContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLUSTERED() antlr.TerminalNode + NONCLUSTERED() antlr.TerminalNode + + // IsClusteredContext differentiates from other interfaces. + IsClusteredContext() +} + +type ClusteredContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClusteredContext() *ClusteredContext { + var p = new(ClusteredContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_clustered + return p +} + +func InitEmptyClusteredContext(p *ClusteredContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_clustered +} + +func (*ClusteredContext) IsClusteredContext() {} + +func NewClusteredContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClusteredContext { + var p = new(ClusteredContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_clustered + + return p +} + +func (s *ClusteredContext) GetParser() antlr.Parser { return s.parser } + +func (s *ClusteredContext) CLUSTERED() antlr.TerminalNode { + return s.GetToken(TSqlParserCLUSTERED, 0) +} + +func (s *ClusteredContext) NONCLUSTERED() antlr.TerminalNode { + return s.GetToken(TSqlParserNONCLUSTERED, 0) +} + +func (s *ClusteredContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ClusteredContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ClusteredContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterClustered(s) + } +} + +func (s *ClusteredContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitClustered(s) + } +} + +func (s *ClusteredContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitClustered(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Clustered() (localctx IClusteredContext) { + localctx = NewClusteredContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1198, TSqlParserRULE_clustered) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14367) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserCLUSTERED || _la == TSqlParserNONCLUSTERED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INull_notnullContext is an interface to support dynamic dispatch. +type INull_notnullContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsNull_notnullContext differentiates from other interfaces. + IsNull_notnullContext() +} + +type Null_notnullContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNull_notnullContext() *Null_notnullContext { + var p = new(Null_notnullContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_null_notnull + return p +} + +func InitEmptyNull_notnullContext(p *Null_notnullContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_null_notnull +} + +func (*Null_notnullContext) IsNull_notnullContext() {} + +func NewNull_notnullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Null_notnullContext { + var p = new(Null_notnullContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_null_notnull + + return p +} + +func (s *Null_notnullContext) GetParser() antlr.Parser { return s.parser } + +func (s *Null_notnullContext) NULL_() antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_, 0) +} + +func (s *Null_notnullContext) NOT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOT, 0) +} + +func (s *Null_notnullContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Null_notnullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Null_notnullContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterNull_notnull(s) + } +} + +func (s *Null_notnullContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitNull_notnull(s) + } +} + +func (s *Null_notnullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitNull_notnull(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Null_notnull() (localctx INull_notnullContext) { + localctx = NewNull_notnullContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1200, TSqlParserRULE_null_notnull) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserNOT { + { + p.SetState(14369) + p.Match(TSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14372) + p.Match(TSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IScalar_function_nameContext is an interface to support dynamic dispatch. +type IScalar_function_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_proc_name_server_database_schema() IFunc_proc_name_server_database_schemaContext + RIGHT() antlr.TerminalNode + LEFT() antlr.TerminalNode + BINARY_CHECKSUM() antlr.TerminalNode + CHECKSUM() antlr.TerminalNode + + // IsScalar_function_nameContext differentiates from other interfaces. + IsScalar_function_nameContext() +} + +type Scalar_function_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyScalar_function_nameContext() *Scalar_function_nameContext { + var p = new(Scalar_function_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_scalar_function_name + return p +} + +func InitEmptyScalar_function_nameContext(p *Scalar_function_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_scalar_function_name +} + +func (*Scalar_function_nameContext) IsScalar_function_nameContext() {} + +func NewScalar_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Scalar_function_nameContext { + var p = new(Scalar_function_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_scalar_function_name + + return p +} + +func (s *Scalar_function_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Scalar_function_nameContext) Func_proc_name_server_database_schema() IFunc_proc_name_server_database_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_proc_name_server_database_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_proc_name_server_database_schemaContext) +} + +func (s *Scalar_function_nameContext) RIGHT() antlr.TerminalNode { + return s.GetToken(TSqlParserRIGHT, 0) +} + +func (s *Scalar_function_nameContext) LEFT() antlr.TerminalNode { + return s.GetToken(TSqlParserLEFT, 0) +} + +func (s *Scalar_function_nameContext) BINARY_CHECKSUM() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY_CHECKSUM, 0) +} + +func (s *Scalar_function_nameContext) CHECKSUM() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKSUM, 0) +} + +func (s *Scalar_function_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Scalar_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Scalar_function_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterScalar_function_name(s) + } +} + +func (s *Scalar_function_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitScalar_function_name(s) + } +} + +func (s *Scalar_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitScalar_function_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Scalar_function_name() (localctx IScalar_function_nameContext) { + localctx = NewScalar_function_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1202, TSqlParserRULE_scalar_function_name) + p.SetState(14379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1810, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14374) + p.Func_proc_name_server_database_schema() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14375) + p.Match(TSqlParserRIGHT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14376) + p.Match(TSqlParserLEFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14377) + p.Match(TSqlParserBINARY_CHECKSUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14378) + p.Match(TSqlParserCHECKSUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBegin_conversation_timerContext is an interface to support dynamic dispatch. +type IBegin_conversation_timerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BEGIN() antlr.TerminalNode + CONVERSATION() antlr.TerminalNode + TIMER() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + TIMEOUT() antlr.TerminalNode + EQUAL() antlr.TerminalNode + Time() ITimeContext + SEMI() antlr.TerminalNode + + // IsBegin_conversation_timerContext differentiates from other interfaces. + IsBegin_conversation_timerContext() +} + +type Begin_conversation_timerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBegin_conversation_timerContext() *Begin_conversation_timerContext { + var p = new(Begin_conversation_timerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_begin_conversation_timer + return p +} + +func InitEmptyBegin_conversation_timerContext(p *Begin_conversation_timerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_begin_conversation_timer +} + +func (*Begin_conversation_timerContext) IsBegin_conversation_timerContext() {} + +func NewBegin_conversation_timerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Begin_conversation_timerContext { + var p = new(Begin_conversation_timerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_begin_conversation_timer + + return p +} + +func (s *Begin_conversation_timerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Begin_conversation_timerContext) BEGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserBEGIN, 0) +} + +func (s *Begin_conversation_timerContext) CONVERSATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONVERSATION, 0) +} + +func (s *Begin_conversation_timerContext) TIMER() antlr.TerminalNode { + return s.GetToken(TSqlParserTIMER, 0) +} + +func (s *Begin_conversation_timerContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Begin_conversation_timerContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Begin_conversation_timerContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Begin_conversation_timerContext) TIMEOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserTIMEOUT, 0) +} + +func (s *Begin_conversation_timerContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Begin_conversation_timerContext) Time() ITimeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITimeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITimeContext) +} + +func (s *Begin_conversation_timerContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Begin_conversation_timerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Begin_conversation_timerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Begin_conversation_timerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBegin_conversation_timer(s) + } +} + +func (s *Begin_conversation_timerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBegin_conversation_timer(s) + } +} + +func (s *Begin_conversation_timerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBegin_conversation_timer(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Begin_conversation_timer() (localctx IBegin_conversation_timerContext) { + localctx = NewBegin_conversation_timerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1204, TSqlParserRULE_begin_conversation_timer) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14381) + p.Match(TSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14382) + p.Match(TSqlParserCONVERSATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14383) + p.Match(TSqlParserTIMER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14384) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14385) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14386) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14387) + p.Match(TSqlParserTIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14388) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14389) + p.Time() + } + p.SetState(14391) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1811, p.GetParserRuleContext()) == 1 { + { + p.SetState(14390) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBegin_conversation_dialogContext is an interface to support dynamic dispatch. +type IBegin_conversation_dialogContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDialog_handle returns the dialog_handle token. + GetDialog_handle() antlr.Token + + // GetService_broker_guid returns the service_broker_guid token. + GetService_broker_guid() antlr.Token + + // SetDialog_handle sets the dialog_handle token. + SetDialog_handle(antlr.Token) + + // SetService_broker_guid sets the service_broker_guid token. + SetService_broker_guid(antlr.Token) + + // GetInitiator_service_name returns the initiator_service_name rule contexts. + GetInitiator_service_name() IService_nameContext + + // GetTarget_service_name returns the target_service_name rule contexts. + GetTarget_service_name() IService_nameContext + + // SetInitiator_service_name sets the initiator_service_name rule contexts. + SetInitiator_service_name(IService_nameContext) + + // SetTarget_service_name sets the target_service_name rule contexts. + SetTarget_service_name(IService_nameContext) + + // Getter signatures + BEGIN() antlr.TerminalNode + DIALOG() antlr.TerminalNode + FROM() antlr.TerminalNode + AllSERVICE() []antlr.TerminalNode + SERVICE(i int) antlr.TerminalNode + TO() antlr.TerminalNode + ON() antlr.TerminalNode + CONTRACT() antlr.TerminalNode + Contract_name() IContract_nameContext + AllLOCAL_ID() []antlr.TerminalNode + LOCAL_ID(i int) antlr.TerminalNode + AllService_name() []IService_nameContext + Service_name(i int) IService_nameContext + CONVERSATION() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + SEMI() antlr.TerminalNode + STRING() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + LIFETIME() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + On_off() IOn_offContext + RELATED_CONVERSATION() antlr.TerminalNode + RELATED_CONVERSATION_GROUP() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + + // IsBegin_conversation_dialogContext differentiates from other interfaces. + IsBegin_conversation_dialogContext() +} + +type Begin_conversation_dialogContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dialog_handle antlr.Token + initiator_service_name IService_nameContext + target_service_name IService_nameContext + service_broker_guid antlr.Token +} + +func NewEmptyBegin_conversation_dialogContext() *Begin_conversation_dialogContext { + var p = new(Begin_conversation_dialogContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_begin_conversation_dialog + return p +} + +func InitEmptyBegin_conversation_dialogContext(p *Begin_conversation_dialogContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_begin_conversation_dialog +} + +func (*Begin_conversation_dialogContext) IsBegin_conversation_dialogContext() {} + +func NewBegin_conversation_dialogContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Begin_conversation_dialogContext { + var p = new(Begin_conversation_dialogContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_begin_conversation_dialog + + return p +} + +func (s *Begin_conversation_dialogContext) GetParser() antlr.Parser { return s.parser } + +func (s *Begin_conversation_dialogContext) GetDialog_handle() antlr.Token { return s.dialog_handle } + +func (s *Begin_conversation_dialogContext) GetService_broker_guid() antlr.Token { + return s.service_broker_guid +} + +func (s *Begin_conversation_dialogContext) SetDialog_handle(v antlr.Token) { s.dialog_handle = v } + +func (s *Begin_conversation_dialogContext) SetService_broker_guid(v antlr.Token) { + s.service_broker_guid = v +} + +func (s *Begin_conversation_dialogContext) GetInitiator_service_name() IService_nameContext { + return s.initiator_service_name +} + +func (s *Begin_conversation_dialogContext) GetTarget_service_name() IService_nameContext { + return s.target_service_name +} + +func (s *Begin_conversation_dialogContext) SetInitiator_service_name(v IService_nameContext) { + s.initiator_service_name = v +} + +func (s *Begin_conversation_dialogContext) SetTarget_service_name(v IService_nameContext) { + s.target_service_name = v +} + +func (s *Begin_conversation_dialogContext) BEGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserBEGIN, 0) +} + +func (s *Begin_conversation_dialogContext) DIALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserDIALOG, 0) +} + +func (s *Begin_conversation_dialogContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Begin_conversation_dialogContext) AllSERVICE() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSERVICE) +} + +func (s *Begin_conversation_dialogContext) SERVICE(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, i) +} + +func (s *Begin_conversation_dialogContext) TO() antlr.TerminalNode { + return s.GetToken(TSqlParserTO, 0) +} + +func (s *Begin_conversation_dialogContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Begin_conversation_dialogContext) CONTRACT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTRACT, 0) +} + +func (s *Begin_conversation_dialogContext) Contract_name() IContract_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContract_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContract_nameContext) +} + +func (s *Begin_conversation_dialogContext) AllLOCAL_ID() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOCAL_ID) +} + +func (s *Begin_conversation_dialogContext) LOCAL_ID(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, i) +} + +func (s *Begin_conversation_dialogContext) AllService_name() []IService_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IService_nameContext); ok { + len++ + } + } + + tst := make([]IService_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IService_nameContext); ok { + tst[i] = t.(IService_nameContext) + i++ + } + } + + return tst +} + +func (s *Begin_conversation_dialogContext) Service_name(i int) IService_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IService_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IService_nameContext) +} + +func (s *Begin_conversation_dialogContext) CONVERSATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONVERSATION, 0) +} + +func (s *Begin_conversation_dialogContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(TSqlParserCOMMA) +} + +func (s *Begin_conversation_dialogContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, i) +} + +func (s *Begin_conversation_dialogContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *Begin_conversation_dialogContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Begin_conversation_dialogContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Begin_conversation_dialogContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *Begin_conversation_dialogContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *Begin_conversation_dialogContext) LIFETIME() antlr.TerminalNode { + return s.GetToken(TSqlParserLIFETIME, 0) +} + +func (s *Begin_conversation_dialogContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *Begin_conversation_dialogContext) On_off() IOn_offContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_offContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_offContext) +} + +func (s *Begin_conversation_dialogContext) RELATED_CONVERSATION() antlr.TerminalNode { + return s.GetToken(TSqlParserRELATED_CONVERSATION, 0) +} + +func (s *Begin_conversation_dialogContext) RELATED_CONVERSATION_GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserRELATED_CONVERSATION_GROUP, 0) +} + +func (s *Begin_conversation_dialogContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Begin_conversation_dialogContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Begin_conversation_dialogContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Begin_conversation_dialogContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterBegin_conversation_dialog(s) + } +} + +func (s *Begin_conversation_dialogContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitBegin_conversation_dialog(s) + } +} + +func (s *Begin_conversation_dialogContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitBegin_conversation_dialog(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Begin_conversation_dialog() (localctx IBegin_conversation_dialogContext) { + localctx = NewBegin_conversation_dialogContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1206, TSqlParserRULE_begin_conversation_dialog) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14393) + p.Match(TSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14394) + p.Match(TSqlParserDIALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCONVERSATION { + { + p.SetState(14395) + p.Match(TSqlParserCONVERSATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14398) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*Begin_conversation_dialogContext).dialog_handle = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14399) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14400) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14401) + + var _x = p.Service_name() + + localctx.(*Begin_conversation_dialogContext).initiator_service_name = _x + } + { + p.SetState(14402) + p.Match(TSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14403) + p.Match(TSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14404) + + var _x = p.Service_name() + + localctx.(*Begin_conversation_dialogContext).target_service_name = _x + } + p.SetState(14407) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(14405) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14406) + + var _m = p.Match(TSqlParserSTRING) + + localctx.(*Begin_conversation_dialogContext).service_broker_guid = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14409) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14410) + p.Match(TSqlParserCONTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14411) + p.Contract_name() + } + p.SetState(14434) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1819, p.GetParserRuleContext()) == 1 { + { + p.SetState(14412) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14419) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1815, p.GetParserRuleContext()) == 1 { + { + p.SetState(14413) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserRELATED_CONVERSATION || _la == TSqlParserRELATED_CONVERSATION_GROUP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14414) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14415) + p.Match(TSqlParserLOCAL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14417) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(14416) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14427) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1817, p.GetParserRuleContext()) == 1 { + { + p.SetState(14421) + p.Match(TSqlParserLIFETIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14422) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14423) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOCAL_ID || _la == TSqlParserDECIMAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(14425) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(14424) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14432) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1818, p.GetParserRuleContext()) == 1 { + { + p.SetState(14429) + p.Match(TSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14430) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14431) + p.On_off() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14437) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1820, p.GetParserRuleContext()) == 1 { + { + p.SetState(14436) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IContract_nameContext is an interface to support dynamic dispatch. +type IContract_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + Expression() IExpressionContext + + // IsContract_nameContext differentiates from other interfaces. + IsContract_nameContext() +} + +type Contract_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContract_nameContext() *Contract_nameContext { + var p = new(Contract_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_contract_name + return p +} + +func InitEmptyContract_nameContext(p *Contract_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_contract_name +} + +func (*Contract_nameContext) IsContract_nameContext() {} + +func NewContract_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Contract_nameContext { + var p = new(Contract_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_contract_name + + return p +} + +func (s *Contract_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Contract_nameContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Contract_nameContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Contract_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Contract_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Contract_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterContract_name(s) + } +} + +func (s *Contract_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitContract_name(s) + } +} + +func (s *Contract_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitContract_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Contract_name() (localctx IContract_nameContext) { + localctx = NewContract_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1208, TSqlParserRULE_contract_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(14441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1821, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14439) + p.Id_() + } + + case 2: + { + p.SetState(14440) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IService_nameContext is an interface to support dynamic dispatch. +type IService_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + Expression() IExpressionContext + + // IsService_nameContext differentiates from other interfaces. + IsService_nameContext() +} + +type Service_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyService_nameContext() *Service_nameContext { + var p = new(Service_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_service_name + return p +} + +func InitEmptyService_nameContext(p *Service_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_service_name +} + +func (*Service_nameContext) IsService_nameContext() {} + +func NewService_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Service_nameContext { + var p = new(Service_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_service_name + + return p +} + +func (s *Service_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Service_nameContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Service_nameContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Service_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Service_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Service_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterService_name(s) + } +} + +func (s *Service_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitService_name(s) + } +} + +func (s *Service_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitService_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Service_name() (localctx IService_nameContext) { + localctx = NewService_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1210, TSqlParserRULE_service_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(14445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1822, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14443) + p.Id_() + } + + case 2: + { + p.SetState(14444) + p.expression(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEnd_conversationContext is an interface to support dynamic dispatch. +type IEnd_conversationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetConversation_handle returns the conversation_handle token. + GetConversation_handle() antlr.Token + + // GetFaliure_code returns the faliure_code token. + GetFaliure_code() antlr.Token + + // GetFailure_text returns the failure_text token. + GetFailure_text() antlr.Token + + // SetConversation_handle sets the conversation_handle token. + SetConversation_handle(antlr.Token) + + // SetFaliure_code sets the faliure_code token. + SetFaliure_code(antlr.Token) + + // SetFailure_text sets the failure_text token. + SetFailure_text(antlr.Token) + + // Getter signatures + END() antlr.TerminalNode + CONVERSATION() antlr.TerminalNode + AllLOCAL_ID() []antlr.TerminalNode + LOCAL_ID(i int) antlr.TerminalNode + SEMI() antlr.TerminalNode + WITH() antlr.TerminalNode + ERROR() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + DESCRIPTION() antlr.TerminalNode + CLEANUP() antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + + // IsEnd_conversationContext differentiates from other interfaces. + IsEnd_conversationContext() +} + +type End_conversationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + conversation_handle antlr.Token + faliure_code antlr.Token + failure_text antlr.Token +} + +func NewEmptyEnd_conversationContext() *End_conversationContext { + var p = new(End_conversationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_end_conversation + return p +} + +func InitEmptyEnd_conversationContext(p *End_conversationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_end_conversation +} + +func (*End_conversationContext) IsEnd_conversationContext() {} + +func NewEnd_conversationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *End_conversationContext { + var p = new(End_conversationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_end_conversation + + return p +} + +func (s *End_conversationContext) GetParser() antlr.Parser { return s.parser } + +func (s *End_conversationContext) GetConversation_handle() antlr.Token { return s.conversation_handle } + +func (s *End_conversationContext) GetFaliure_code() antlr.Token { return s.faliure_code } + +func (s *End_conversationContext) GetFailure_text() antlr.Token { return s.failure_text } + +func (s *End_conversationContext) SetConversation_handle(v antlr.Token) { s.conversation_handle = v } + +func (s *End_conversationContext) SetFaliure_code(v antlr.Token) { s.faliure_code = v } + +func (s *End_conversationContext) SetFailure_text(v antlr.Token) { s.failure_text = v } + +func (s *End_conversationContext) END() antlr.TerminalNode { + return s.GetToken(TSqlParserEND, 0) +} + +func (s *End_conversationContext) CONVERSATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONVERSATION, 0) +} + +func (s *End_conversationContext) AllLOCAL_ID() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOCAL_ID) +} + +func (s *End_conversationContext) LOCAL_ID(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, i) +} + +func (s *End_conversationContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *End_conversationContext) WITH() antlr.TerminalNode { + return s.GetToken(TSqlParserWITH, 0) +} + +func (s *End_conversationContext) ERROR() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR, 0) +} + +func (s *End_conversationContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserEQUAL) +} + +func (s *End_conversationContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, i) +} + +func (s *End_conversationContext) DESCRIPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserDESCRIPTION, 0) +} + +func (s *End_conversationContext) CLEANUP() antlr.TerminalNode { + return s.GetToken(TSqlParserCLEANUP, 0) +} + +func (s *End_conversationContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *End_conversationContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *End_conversationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *End_conversationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *End_conversationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterEnd_conversation(s) + } +} + +func (s *End_conversationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitEnd_conversation(s) + } +} + +func (s *End_conversationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitEnd_conversation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) End_conversation() (localctx IEnd_conversationContext) { + localctx = NewEnd_conversationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1212, TSqlParserRULE_end_conversation) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14447) + p.Match(TSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14448) + p.Match(TSqlParserCONVERSATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14449) + + var _m = p.Match(TSqlParserLOCAL_ID) + + localctx.(*End_conversationContext).conversation_handle = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14451) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1823, p.GetParserRuleContext()) == 1 { + { + p.SetState(14450) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14465) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1826, p.GetParserRuleContext()) == 1 { + { + p.SetState(14453) + p.Match(TSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14460) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1824, p.GetParserRuleContext()) == 1 { + { + p.SetState(14454) + p.Match(TSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14455) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14456) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*End_conversationContext).faliure_code = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOCAL_ID || _la == TSqlParserSTRING) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*End_conversationContext).faliure_code = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14457) + p.Match(TSqlParserDESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14458) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14459) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*End_conversationContext).failure_text = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOCAL_ID || _la == TSqlParserSTRING) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*End_conversationContext).failure_text = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14463) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1825, p.GetParserRuleContext()) == 1 { + { + p.SetState(14462) + p.Match(TSqlParserCLEANUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWaitfor_conversationContext is an interface to support dynamic dispatch. +type IWaitfor_conversationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTimeout returns the timeout rule contexts. + GetTimeout() ITimeContext + + // SetTimeout sets the timeout rule contexts. + SetTimeout(ITimeContext) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + Get_conversation() IGet_conversationContext + RR_BRACKET() antlr.TerminalNode + WAITFOR() antlr.TerminalNode + TIMEOUT() antlr.TerminalNode + SEMI() antlr.TerminalNode + Time() ITimeContext + COMMA() antlr.TerminalNode + + // IsWaitfor_conversationContext differentiates from other interfaces. + IsWaitfor_conversationContext() +} + +type Waitfor_conversationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + timeout ITimeContext +} + +func NewEmptyWaitfor_conversationContext() *Waitfor_conversationContext { + var p = new(Waitfor_conversationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_waitfor_conversation + return p +} + +func InitEmptyWaitfor_conversationContext(p *Waitfor_conversationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_waitfor_conversation +} + +func (*Waitfor_conversationContext) IsWaitfor_conversationContext() {} + +func NewWaitfor_conversationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Waitfor_conversationContext { + var p = new(Waitfor_conversationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_waitfor_conversation + + return p +} + +func (s *Waitfor_conversationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Waitfor_conversationContext) GetTimeout() ITimeContext { return s.timeout } + +func (s *Waitfor_conversationContext) SetTimeout(v ITimeContext) { s.timeout = v } + +func (s *Waitfor_conversationContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Waitfor_conversationContext) Get_conversation() IGet_conversationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGet_conversationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGet_conversationContext) +} + +func (s *Waitfor_conversationContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Waitfor_conversationContext) WAITFOR() antlr.TerminalNode { + return s.GetToken(TSqlParserWAITFOR, 0) +} + +func (s *Waitfor_conversationContext) TIMEOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserTIMEOUT, 0) +} + +func (s *Waitfor_conversationContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Waitfor_conversationContext) Time() ITimeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITimeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITimeContext) +} + +func (s *Waitfor_conversationContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Waitfor_conversationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Waitfor_conversationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Waitfor_conversationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterWaitfor_conversation(s) + } +} + +func (s *Waitfor_conversationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitWaitfor_conversation(s) + } +} + +func (s *Waitfor_conversationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitWaitfor_conversation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Waitfor_conversation() (localctx IWaitfor_conversationContext) { + localctx = NewWaitfor_conversationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1214, TSqlParserRULE_waitfor_conversation) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserWAITFOR { + { + p.SetState(14467) + p.Match(TSqlParserWAITFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14470) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14471) + p.Get_conversation() + } + { + p.SetState(14472) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14478) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1829, p.GetParserRuleContext()) == 1 { + p.SetState(14474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserCOMMA { + { + p.SetState(14473) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14476) + p.Match(TSqlParserTIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14477) + + var _x = p.Time() + + localctx.(*Waitfor_conversationContext).timeout = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14481) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1830, p.GetParserRuleContext()) == 1 { + { + p.SetState(14480) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGet_conversationContext is an interface to support dynamic dispatch. +type IGet_conversationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetConversation_group_id returns the conversation_group_id token. + GetConversation_group_id() antlr.Token + + // SetConversation_group_id sets the conversation_group_id token. + SetConversation_group_id(antlr.Token) + + // GetQueue returns the queue rule contexts. + GetQueue() IQueue_idContext + + // SetQueue sets the queue rule contexts. + SetQueue(IQueue_idContext) + + // Getter signatures + GET() antlr.TerminalNode + CONVERSATION() antlr.TerminalNode + GROUP() antlr.TerminalNode + FROM() antlr.TerminalNode + Queue_id() IQueue_idContext + STRING() antlr.TerminalNode + LOCAL_ID() antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsGet_conversationContext differentiates from other interfaces. + IsGet_conversationContext() +} + +type Get_conversationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + conversation_group_id antlr.Token + queue IQueue_idContext +} + +func NewEmptyGet_conversationContext() *Get_conversationContext { + var p = new(Get_conversationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_get_conversation + return p +} + +func InitEmptyGet_conversationContext(p *Get_conversationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_get_conversation +} + +func (*Get_conversationContext) IsGet_conversationContext() {} + +func NewGet_conversationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Get_conversationContext { + var p = new(Get_conversationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_get_conversation + + return p +} + +func (s *Get_conversationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Get_conversationContext) GetConversation_group_id() antlr.Token { + return s.conversation_group_id +} + +func (s *Get_conversationContext) SetConversation_group_id(v antlr.Token) { + s.conversation_group_id = v +} + +func (s *Get_conversationContext) GetQueue() IQueue_idContext { return s.queue } + +func (s *Get_conversationContext) SetQueue(v IQueue_idContext) { s.queue = v } + +func (s *Get_conversationContext) GET() antlr.TerminalNode { + return s.GetToken(TSqlParserGET, 0) +} + +func (s *Get_conversationContext) CONVERSATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONVERSATION, 0) +} + +func (s *Get_conversationContext) GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP, 0) +} + +func (s *Get_conversationContext) FROM() antlr.TerminalNode { + return s.GetToken(TSqlParserFROM, 0) +} + +func (s *Get_conversationContext) Queue_id() IQueue_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQueue_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQueue_idContext) +} + +func (s *Get_conversationContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Get_conversationContext) LOCAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, 0) +} + +func (s *Get_conversationContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Get_conversationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Get_conversationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Get_conversationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterGet_conversation(s) + } +} + +func (s *Get_conversationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitGet_conversation(s) + } +} + +func (s *Get_conversationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitGet_conversation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Get_conversation() (localctx IGet_conversationContext) { + localctx = NewGet_conversationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1216, TSqlParserRULE_get_conversation) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14483) + p.Match(TSqlParserGET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14484) + p.Match(TSqlParserCONVERSATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14485) + p.Match(TSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14486) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Get_conversationContext).conversation_group_id = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOCAL_ID || _la == TSqlParserSTRING) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Get_conversationContext).conversation_group_id = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14487) + p.Match(TSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14488) + + var _x = p.Queue_id() + + localctx.(*Get_conversationContext).queue = _x + } + p.SetState(14490) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1831, p.GetParserRuleContext()) == 1 { + { + p.SetState(14489) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQueue_idContext is an interface to support dynamic dispatch. +type IQueue_idContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatabase_name returns the database_name rule contexts. + GetDatabase_name() IId_Context + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IId_Context + + // GetName returns the name rule contexts. + GetName() IId_Context + + // SetDatabase_name sets the database_name rule contexts. + SetDatabase_name(IId_Context) + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IId_Context) + + // SetName sets the name rule contexts. + SetName(IId_Context) + + // Getter signatures + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + + // IsQueue_idContext differentiates from other interfaces. + IsQueue_idContext() +} + +type Queue_idContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database_name IId_Context + schema_name IId_Context + name IId_Context +} + +func NewEmptyQueue_idContext() *Queue_idContext { + var p = new(Queue_idContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_queue_id + return p +} + +func InitEmptyQueue_idContext(p *Queue_idContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_queue_id +} + +func (*Queue_idContext) IsQueue_idContext() {} + +func NewQueue_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Queue_idContext { + var p = new(Queue_idContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_queue_id + + return p +} + +func (s *Queue_idContext) GetParser() antlr.Parser { return s.parser } + +func (s *Queue_idContext) GetDatabase_name() IId_Context { return s.database_name } + +func (s *Queue_idContext) GetSchema_name() IId_Context { return s.schema_name } + +func (s *Queue_idContext) GetName() IId_Context { return s.name } + +func (s *Queue_idContext) SetDatabase_name(v IId_Context) { s.database_name = v } + +func (s *Queue_idContext) SetSchema_name(v IId_Context) { s.schema_name = v } + +func (s *Queue_idContext) SetName(v IId_Context) { s.name = v } + +func (s *Queue_idContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDOT) +} + +func (s *Queue_idContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDOT, i) +} + +func (s *Queue_idContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Queue_idContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Queue_idContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Queue_idContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Queue_idContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterQueue_id(s) + } +} + +func (s *Queue_idContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitQueue_id(s) + } +} + +func (s *Queue_idContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitQueue_id(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Queue_id() (localctx IQueue_idContext) { + localctx = NewQueue_idContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1218, TSqlParserRULE_queue_id) + p.SetState(14499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1832, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14492) + + var _x = p.Id_() + + localctx.(*Queue_idContext).database_name = _x + } + { + p.SetState(14493) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14494) + + var _x = p.Id_() + + localctx.(*Queue_idContext).schema_name = _x + } + { + p.SetState(14495) + p.Match(TSqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14496) + + var _x = p.Id_() + + localctx.(*Queue_idContext).name = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14498) + p.Id_() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISend_conversationContext is an interface to support dynamic dispatch. +type ISend_conversationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetConversation_handle returns the conversation_handle token. + GetConversation_handle() antlr.Token + + // GetMessage_body_expression returns the message_body_expression token. + GetMessage_body_expression() antlr.Token + + // SetConversation_handle sets the conversation_handle token. + SetConversation_handle(antlr.Token) + + // SetMessage_body_expression sets the message_body_expression token. + SetMessage_body_expression(antlr.Token) + + // GetMessage_type_name returns the message_type_name rule contexts. + GetMessage_type_name() IExpressionContext + + // SetMessage_type_name sets the message_type_name rule contexts. + SetMessage_type_name(IExpressionContext) + + // Getter signatures + SEND() antlr.TerminalNode + ON() antlr.TerminalNode + CONVERSATION() antlr.TerminalNode + MESSAGE() antlr.TerminalNode + TYPE() antlr.TerminalNode + Expression() IExpressionContext + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + AllLOCAL_ID() []antlr.TerminalNode + LOCAL_ID(i int) antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsSend_conversationContext differentiates from other interfaces. + IsSend_conversationContext() +} + +type Send_conversationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + conversation_handle antlr.Token + message_type_name IExpressionContext + message_body_expression antlr.Token +} + +func NewEmptySend_conversationContext() *Send_conversationContext { + var p = new(Send_conversationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_send_conversation + return p +} + +func InitEmptySend_conversationContext(p *Send_conversationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_send_conversation +} + +func (*Send_conversationContext) IsSend_conversationContext() {} + +func NewSend_conversationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Send_conversationContext { + var p = new(Send_conversationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_send_conversation + + return p +} + +func (s *Send_conversationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Send_conversationContext) GetConversation_handle() antlr.Token { return s.conversation_handle } + +func (s *Send_conversationContext) GetMessage_body_expression() antlr.Token { + return s.message_body_expression +} + +func (s *Send_conversationContext) SetConversation_handle(v antlr.Token) { s.conversation_handle = v } + +func (s *Send_conversationContext) SetMessage_body_expression(v antlr.Token) { + s.message_body_expression = v +} + +func (s *Send_conversationContext) GetMessage_type_name() IExpressionContext { + return s.message_type_name +} + +func (s *Send_conversationContext) SetMessage_type_name(v IExpressionContext) { + s.message_type_name = v +} + +func (s *Send_conversationContext) SEND() antlr.TerminalNode { + return s.GetToken(TSqlParserSEND, 0) +} + +func (s *Send_conversationContext) ON() antlr.TerminalNode { + return s.GetToken(TSqlParserON, 0) +} + +func (s *Send_conversationContext) CONVERSATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONVERSATION, 0) +} + +func (s *Send_conversationContext) MESSAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE, 0) +} + +func (s *Send_conversationContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *Send_conversationContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Send_conversationContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(TSqlParserSTRING) +} + +func (s *Send_conversationContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, i) +} + +func (s *Send_conversationContext) AllLOCAL_ID() []antlr.TerminalNode { + return s.GetTokens(TSqlParserLOCAL_ID) +} + +func (s *Send_conversationContext) LOCAL_ID(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_ID, i) +} + +func (s *Send_conversationContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Send_conversationContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Send_conversationContext) SEMI() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI, 0) +} + +func (s *Send_conversationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Send_conversationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Send_conversationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSend_conversation(s) + } +} + +func (s *Send_conversationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSend_conversation(s) + } +} + +func (s *Send_conversationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSend_conversation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Send_conversation() (localctx ISend_conversationContext) { + localctx = NewSend_conversationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1220, TSqlParserRULE_send_conversation) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14501) + p.Match(TSqlParserSEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14502) + p.Match(TSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14503) + p.Match(TSqlParserCONVERSATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14504) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Send_conversationContext).conversation_handle = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOCAL_ID || _la == TSqlParserSTRING) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Send_conversationContext).conversation_handle = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14505) + p.Match(TSqlParserMESSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14506) + p.Match(TSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14507) + + var _x = p.expression(0) + + localctx.(*Send_conversationContext).message_type_name = _x + } + p.SetState(14511) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1833, p.GetParserRuleContext()) == 1 { + { + p.SetState(14508) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14509) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Send_conversationContext).message_body_expression = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserLOCAL_ID || _la == TSqlParserSTRING) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Send_conversationContext).message_body_expression = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14510) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14514) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1834, p.GetParserRuleContext()) == 1 { + { + p.SetState(14513) + p.Match(TSqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IData_typeContext is an interface to support dynamic dispatch. +type IData_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetScaled returns the scaled token. + GetScaled() antlr.Token + + // GetScale returns the scale token. + GetScale() antlr.Token + + // GetPrec returns the prec token. + GetPrec() antlr.Token + + // GetSeed returns the seed token. + GetSeed() antlr.Token + + // GetInc returns the inc token. + GetInc() antlr.Token + + // GetDouble_prec returns the double_prec token. + GetDouble_prec() antlr.Token + + // GetSpatial_type returns the spatial_type token. + GetSpatial_type() antlr.Token + + // SetScaled sets the scaled token. + SetScaled(antlr.Token) + + // SetScale sets the scale token. + SetScale(antlr.Token) + + // SetPrec sets the prec token. + SetPrec(antlr.Token) + + // SetSeed sets the seed token. + SetSeed(antlr.Token) + + // SetInc sets the inc token. + SetInc(antlr.Token) + + // SetDouble_prec sets the double_prec token. + SetDouble_prec(antlr.Token) + + // SetSpatial_type sets the spatial_type token. + SetSpatial_type(antlr.Token) + + // GetExt_type returns the ext_type rule contexts. + GetExt_type() IId_Context + + // GetUnscaled_type returns the unscaled_type rule contexts. + GetUnscaled_type() IId_Context + + // SetExt_type sets the ext_type rule contexts. + SetExt_type(IId_Context) + + // SetUnscaled_type sets the unscaled_type rule contexts. + SetUnscaled_type(IId_Context) + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + MAX() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + VARCHAR() antlr.TerminalNode + NVARCHAR() antlr.TerminalNode + BINARY_KEYWORD() antlr.TerminalNode + VARBINARY_KEYWORD() antlr.TerminalNode + SQUARE_BRACKET_ID() antlr.TerminalNode + COMMA() antlr.TerminalNode + Id_() IId_Context + AllDECIMAL() []antlr.TerminalNode + DECIMAL(i int) antlr.TerminalNode + IDENTITY() antlr.TerminalNode + DOUBLE() antlr.TerminalNode + PRECISION() antlr.TerminalNode + GEOMETRY() antlr.TerminalNode + GEOGRAPHY() antlr.TerminalNode + + // IsData_typeContext differentiates from other interfaces. + IsData_typeContext() +} + +type Data_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + scaled antlr.Token + ext_type IId_Context + scale antlr.Token + prec antlr.Token + seed antlr.Token + inc antlr.Token + double_prec antlr.Token + spatial_type antlr.Token + unscaled_type IId_Context +} + +func NewEmptyData_typeContext() *Data_typeContext { + var p = new(Data_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_data_type + return p +} + +func InitEmptyData_typeContext(p *Data_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_data_type +} + +func (*Data_typeContext) IsData_typeContext() {} + +func NewData_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Data_typeContext { + var p = new(Data_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_data_type + + return p +} + +func (s *Data_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Data_typeContext) GetScaled() antlr.Token { return s.scaled } + +func (s *Data_typeContext) GetScale() antlr.Token { return s.scale } + +func (s *Data_typeContext) GetPrec() antlr.Token { return s.prec } + +func (s *Data_typeContext) GetSeed() antlr.Token { return s.seed } + +func (s *Data_typeContext) GetInc() antlr.Token { return s.inc } + +func (s *Data_typeContext) GetDouble_prec() antlr.Token { return s.double_prec } + +func (s *Data_typeContext) GetSpatial_type() antlr.Token { return s.spatial_type } + +func (s *Data_typeContext) SetScaled(v antlr.Token) { s.scaled = v } + +func (s *Data_typeContext) SetScale(v antlr.Token) { s.scale = v } + +func (s *Data_typeContext) SetPrec(v antlr.Token) { s.prec = v } + +func (s *Data_typeContext) SetSeed(v antlr.Token) { s.seed = v } + +func (s *Data_typeContext) SetInc(v antlr.Token) { s.inc = v } + +func (s *Data_typeContext) SetDouble_prec(v antlr.Token) { s.double_prec = v } + +func (s *Data_typeContext) SetSpatial_type(v antlr.Token) { s.spatial_type = v } + +func (s *Data_typeContext) GetExt_type() IId_Context { return s.ext_type } + +func (s *Data_typeContext) GetUnscaled_type() IId_Context { return s.unscaled_type } + +func (s *Data_typeContext) SetExt_type(v IId_Context) { s.ext_type = v } + +func (s *Data_typeContext) SetUnscaled_type(v IId_Context) { s.unscaled_type = v } + +func (s *Data_typeContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserLR_BRACKET, 0) +} + +func (s *Data_typeContext) MAX() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX, 0) +} + +func (s *Data_typeContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserRR_BRACKET, 0) +} + +func (s *Data_typeContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(TSqlParserVARCHAR, 0) +} + +func (s *Data_typeContext) NVARCHAR() antlr.TerminalNode { + return s.GetToken(TSqlParserNVARCHAR, 0) +} + +func (s *Data_typeContext) BINARY_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY_KEYWORD, 0) +} + +func (s *Data_typeContext) VARBINARY_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserVARBINARY_KEYWORD, 0) +} + +func (s *Data_typeContext) SQUARE_BRACKET_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserSQUARE_BRACKET_ID, 0) +} + +func (s *Data_typeContext) COMMA() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMA, 0) +} + +func (s *Data_typeContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Data_typeContext) AllDECIMAL() []antlr.TerminalNode { + return s.GetTokens(TSqlParserDECIMAL) +} + +func (s *Data_typeContext) DECIMAL(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, i) +} + +func (s *Data_typeContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENTITY, 0) +} + +func (s *Data_typeContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE, 0) +} + +func (s *Data_typeContext) PRECISION() antlr.TerminalNode { + return s.GetToken(TSqlParserPRECISION, 0) +} + +func (s *Data_typeContext) GEOMETRY() antlr.TerminalNode { + return s.GetToken(TSqlParserGEOMETRY, 0) +} + +func (s *Data_typeContext) GEOGRAPHY() antlr.TerminalNode { + return s.GetToken(TSqlParserGEOGRAPHY, 0) +} + +func (s *Data_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Data_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Data_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterData_type(s) + } +} + +func (s *Data_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitData_type(s) + } +} + +func (s *Data_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitData_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Data_type() (localctx IData_typeContext) { + localctx = NewData_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1222, TSqlParserRULE_data_type) + var _la int + + p.SetState(14547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1837, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14516) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Data_typeContext).scaled = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserBINARY_KEYWORD || _la == TSqlParserVARBINARY_KEYWORD || ((int64((_la-1166)) & ^0x3f) == 0 && ((int64(1)<<(_la-1166))&8195) != 0)) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Data_typeContext).scaled = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14517) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14518) + p.Match(TSqlParserMAX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14519) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14520) + + var _x = p.Id_() + + localctx.(*Data_typeContext).ext_type = _x + } + { + p.SetState(14521) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14522) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Data_typeContext).scale = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14523) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14524) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Data_typeContext).prec = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14525) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14527) + + var _x = p.Id_() + + localctx.(*Data_typeContext).ext_type = _x + } + { + p.SetState(14528) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14529) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Data_typeContext).scale = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14530) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14532) + + var _x = p.Id_() + + localctx.(*Data_typeContext).ext_type = _x + } + { + p.SetState(14533) + p.Match(TSqlParserIDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14539) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1835, p.GetParserRuleContext()) == 1 { + { + p.SetState(14534) + p.Match(TSqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14535) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Data_typeContext).seed = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14536) + p.Match(TSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14537) + + var _m = p.Match(TSqlParserDECIMAL) + + localctx.(*Data_typeContext).inc = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14538) + p.Match(TSqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14541) + + var _m = p.Match(TSqlParserDOUBLE) + + localctx.(*Data_typeContext).double_prec = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14543) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1836, p.GetParserRuleContext()) == 1 { + { + p.SetState(14542) + p.Match(TSqlParserPRECISION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14545) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Data_typeContext).spatial_type = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserGEOGRAPHY || _la == TSqlParserGEOMETRY) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Data_typeContext).spatial_type = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(14546) + + var _x = p.Id_() + + localctx.(*Data_typeContext).unscaled_type = _x + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstantContext is an interface to support dynamic dispatch. +type IConstantContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDollar returns the dollar token. + GetDollar() antlr.Token + + // SetDollar sets the dollar token. + SetDollar(antlr.Token) + + // Getter signatures + STRING() antlr.TerminalNode + BINARY() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + REAL() antlr.TerminalNode + FLOAT() antlr.TerminalNode + AllMINUS() []antlr.TerminalNode + MINUS(i int) antlr.TerminalNode + DOLLAR() antlr.TerminalNode + PLUS() antlr.TerminalNode + Parameter() IParameterContext + + // IsConstantContext differentiates from other interfaces. + IsConstantContext() +} + +type ConstantContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dollar antlr.Token +} + +func NewEmptyConstantContext() *ConstantContext { + var p = new(ConstantContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_constant + return p +} + +func InitEmptyConstantContext(p *ConstantContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_constant +} + +func (*ConstantContext) IsConstantContext() {} + +func NewConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantContext { + var p = new(ConstantContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_constant + + return p +} + +func (s *ConstantContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstantContext) GetDollar() antlr.Token { return s.dollar } + +func (s *ConstantContext) SetDollar(v antlr.Token) { s.dollar = v } + +func (s *ConstantContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *ConstantContext) BINARY() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY, 0) +} + +func (s *ConstantContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *ConstantContext) REAL() antlr.TerminalNode { + return s.GetToken(TSqlParserREAL, 0) +} + +func (s *ConstantContext) FLOAT() antlr.TerminalNode { + return s.GetToken(TSqlParserFLOAT, 0) +} + +func (s *ConstantContext) AllMINUS() []antlr.TerminalNode { + return s.GetTokens(TSqlParserMINUS) +} + +func (s *ConstantContext) MINUS(i int) antlr.TerminalNode { + return s.GetToken(TSqlParserMINUS, i) +} + +func (s *ConstantContext) DOLLAR() antlr.TerminalNode { + return s.GetToken(TSqlParserDOLLAR, 0) +} + +func (s *ConstantContext) PLUS() antlr.TerminalNode { + return s.GetToken(TSqlParserPLUS, 0) +} + +func (s *ConstantContext) Parameter() IParameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *ConstantContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstantContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterConstant(s) + } +} + +func (s *ConstantContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitConstant(s) + } +} + +func (s *ConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitConstant(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Constant() (localctx IConstantContext) { + localctx = NewConstantContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1224, TSqlParserRULE_constant) + var _la int + + p.SetState(14564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1841, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14549) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14550) + p.Match(TSqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + p.SetState(14552) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMINUS { + { + p.SetState(14551) + p.Match(TSqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14554) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1182)) & ^0x3f) == 0 && ((int64(1)<<(_la-1182))&49) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + p.SetState(14556) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserMINUS { + { + p.SetState(14555) + p.Match(TSqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14558) + + var _m = p.Match(TSqlParserDOLLAR) + + localctx.(*ConstantContext).dollar = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPLUS || _la == TSqlParserMINUS { + { + p.SetState(14559) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserPLUS || _la == TSqlParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(14562) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDECIMAL || _la == TSqlParserFLOAT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14563) + p.Parameter() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimitive_constantContext is an interface to support dynamic dispatch. +type IPrimitive_constantContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDollar returns the dollar token. + GetDollar() antlr.Token + + // SetDollar sets the dollar token. + SetDollar(antlr.Token) + + // Getter signatures + STRING() antlr.TerminalNode + BINARY() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + REAL() antlr.TerminalNode + FLOAT() antlr.TerminalNode + DOLLAR() antlr.TerminalNode + MINUS() antlr.TerminalNode + PLUS() antlr.TerminalNode + Parameter() IParameterContext + + // IsPrimitive_constantContext differentiates from other interfaces. + IsPrimitive_constantContext() +} + +type Primitive_constantContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dollar antlr.Token +} + +func NewEmptyPrimitive_constantContext() *Primitive_constantContext { + var p = new(Primitive_constantContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_primitive_constant + return p +} + +func InitEmptyPrimitive_constantContext(p *Primitive_constantContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_primitive_constant +} + +func (*Primitive_constantContext) IsPrimitive_constantContext() {} + +func NewPrimitive_constantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primitive_constantContext { + var p = new(Primitive_constantContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_primitive_constant + + return p +} + +func (s *Primitive_constantContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primitive_constantContext) GetDollar() antlr.Token { return s.dollar } + +func (s *Primitive_constantContext) SetDollar(v antlr.Token) { s.dollar = v } + +func (s *Primitive_constantContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Primitive_constantContext) BINARY() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY, 0) +} + +func (s *Primitive_constantContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *Primitive_constantContext) REAL() antlr.TerminalNode { + return s.GetToken(TSqlParserREAL, 0) +} + +func (s *Primitive_constantContext) FLOAT() antlr.TerminalNode { + return s.GetToken(TSqlParserFLOAT, 0) +} + +func (s *Primitive_constantContext) DOLLAR() antlr.TerminalNode { + return s.GetToken(TSqlParserDOLLAR, 0) +} + +func (s *Primitive_constantContext) MINUS() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUS, 0) +} + +func (s *Primitive_constantContext) PLUS() antlr.TerminalNode { + return s.GetToken(TSqlParserPLUS, 0) +} + +func (s *Primitive_constantContext) Parameter() IParameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *Primitive_constantContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primitive_constantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primitive_constantContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterPrimitive_constant(s) + } +} + +func (s *Primitive_constantContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitPrimitive_constant(s) + } +} + +func (s *Primitive_constantContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitPrimitive_constant(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Primitive_constant() (localctx IPrimitive_constantContext) { + localctx = NewPrimitive_constantContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1226, TSqlParserRULE_primitive_constant) + var _la int + + p.SetState(14575) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserSTRING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14566) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserBINARY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14567) + p.Match(TSqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDECIMAL, TSqlParserFLOAT, TSqlParserREAL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14568) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1182)) & ^0x3f) == 0 && ((int64(1)<<(_la-1182))&49) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserDOLLAR: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14569) + + var _m = p.Match(TSqlParserDOLLAR) + + localctx.(*Primitive_constantContext).dollar = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserPLUS || _la == TSqlParserMINUS { + { + p.SetState(14570) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserPLUS || _la == TSqlParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(14573) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserDECIMAL || _la == TSqlParserFLOAT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case TSqlParserPLACEHOLDER: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14574) + p.Parameter() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKeywordContext is an interface to support dynamic dispatch. +type IKeywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ABORT() antlr.TerminalNode + ABSOLUTE() antlr.TerminalNode + ACCENT_SENSITIVITY() antlr.TerminalNode + ACCESS() antlr.TerminalNode + ACTION() antlr.TerminalNode + ACTIVATION() antlr.TerminalNode + ACTIVE() antlr.TerminalNode + ADD() antlr.TerminalNode + ADDRESS() antlr.TerminalNode + AES_128() antlr.TerminalNode + AES_192() antlr.TerminalNode + AES_256() antlr.TerminalNode + AFFINITY() antlr.TerminalNode + AFTER() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + ALGORITHM() antlr.TerminalNode + ALL_CONSTRAINTS() antlr.TerminalNode + ALL_ERRORMSGS() antlr.TerminalNode + ALL_INDEXES() antlr.TerminalNode + ALL_LEVELS() antlr.TerminalNode + ALLOW_ENCRYPTED_VALUE_MODIFICATIONS() antlr.TerminalNode + ALLOW_PAGE_LOCKS() antlr.TerminalNode + ALLOW_ROW_LOCKS() antlr.TerminalNode + ALLOW_SNAPSHOT_ISOLATION() antlr.TerminalNode + ALLOWED() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + ANSI_DEFAULTS() antlr.TerminalNode + ANSI_NULL_DEFAULT() antlr.TerminalNode + ANSI_NULL_DFLT_OFF() antlr.TerminalNode + ANSI_NULL_DFLT_ON() antlr.TerminalNode + ANSI_NULLS() antlr.TerminalNode + ANSI_PADDING() antlr.TerminalNode + ANSI_WARNINGS() antlr.TerminalNode + APP_NAME() antlr.TerminalNode + APPLICATION_LOG() antlr.TerminalNode + APPLOCK_MODE() antlr.TerminalNode + APPLOCK_TEST() antlr.TerminalNode + APPLY() antlr.TerminalNode + ARITHABORT() antlr.TerminalNode + ARITHIGNORE() antlr.TerminalNode + ASCII() antlr.TerminalNode + ASSEMBLY() antlr.TerminalNode + ASSEMBLYPROPERTY() antlr.TerminalNode + AT_KEYWORD() antlr.TerminalNode + AUDIT() antlr.TerminalNode + AUDIT_GUID() antlr.TerminalNode + AUTO() antlr.TerminalNode + AUTO_CLEANUP() antlr.TerminalNode + AUTO_CLOSE() antlr.TerminalNode + AUTO_CREATE_STATISTICS() antlr.TerminalNode + AUTO_DROP() antlr.TerminalNode + AUTO_SHRINK() antlr.TerminalNode + AUTO_UPDATE_STATISTICS() antlr.TerminalNode + AUTO_UPDATE_STATISTICS_ASYNC() antlr.TerminalNode + AUTOGROW_ALL_FILES() antlr.TerminalNode + AUTOGROW_SINGLE_FILE() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + AVG() antlr.TerminalNode + BACKUP_CLONEDB() antlr.TerminalNode + BACKUP_PRIORITY() antlr.TerminalNode + BASE64() antlr.TerminalNode + BEGIN_DIALOG() antlr.TerminalNode + BIGINT() antlr.TerminalNode + BINARY_KEYWORD() antlr.TerminalNode + BINARY_CHECKSUM() antlr.TerminalNode + BINDING() antlr.TerminalNode + BLOB_STORAGE() antlr.TerminalNode + BROKER() antlr.TerminalNode + BROKER_INSTANCE() antlr.TerminalNode + BULK_LOGGED() antlr.TerminalNode + CALLER() antlr.TerminalNode + CAP_CPU_PERCENT() antlr.TerminalNode + CAST() antlr.TerminalNode + TRY_CAST() antlr.TerminalNode + CATALOG() antlr.TerminalNode + CATCH() antlr.TerminalNode + CERT_ID() antlr.TerminalNode + CERTENCODED() antlr.TerminalNode + CERTPRIVATEKEY() antlr.TerminalNode + CHANGE() antlr.TerminalNode + CHANGE_RETENTION() antlr.TerminalNode + CHANGE_TRACKING() antlr.TerminalNode + CHAR() antlr.TerminalNode + CHARINDEX() antlr.TerminalNode + CHECKALLOC() antlr.TerminalNode + CHECKCATALOG() antlr.TerminalNode + CHECKCONSTRAINTS() antlr.TerminalNode + CHECKDB() antlr.TerminalNode + CHECKFILEGROUP() antlr.TerminalNode + CHECKSUM() antlr.TerminalNode + CHECKSUM_AGG() antlr.TerminalNode + CHECKTABLE() antlr.TerminalNode + CLEANTABLE() antlr.TerminalNode + CLEANUP() antlr.TerminalNode + CLONEDATABASE() antlr.TerminalNode + COL_LENGTH() antlr.TerminalNode + COL_NAME() antlr.TerminalNode + COLLECTION() antlr.TerminalNode + COLUMN_ENCRYPTION_KEY() antlr.TerminalNode + COLUMN_MASTER_KEY() antlr.TerminalNode + COLUMNPROPERTY() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + COLUMNSTORE() antlr.TerminalNode + COLUMNSTORE_ARCHIVE() antlr.TerminalNode + COMMITTED() antlr.TerminalNode + COMPATIBILITY_LEVEL() antlr.TerminalNode + COMPRESS_ALL_ROW_GROUPS() antlr.TerminalNode + COMPRESSION_DELAY() antlr.TerminalNode + CONCAT() antlr.TerminalNode + CONCAT_WS() antlr.TerminalNode + CONCAT_NULL_YIELDS_NULL() antlr.TerminalNode + CONTENT() antlr.TerminalNode + CONTROL() antlr.TerminalNode + COOKIE() antlr.TerminalNode + COUNT() antlr.TerminalNode + COUNT_BIG() antlr.TerminalNode + COUNTER() antlr.TerminalNode + CPU() antlr.TerminalNode + CREATE_NEW() antlr.TerminalNode + CREATION_DISPOSITION() antlr.TerminalNode + CREDENTIAL() antlr.TerminalNode + CRYPTOGRAPHIC() antlr.TerminalNode + CUME_DIST() antlr.TerminalNode + CURSOR_CLOSE_ON_COMMIT() antlr.TerminalNode + CURSOR_DEFAULT() antlr.TerminalNode + CURSOR_STATUS() antlr.TerminalNode + DATA() antlr.TerminalNode + DATA_PURITY() antlr.TerminalNode + DATABASE_PRINCIPAL_ID() antlr.TerminalNode + DATABASEPROPERTYEX() antlr.TerminalNode + DATALENGTH() antlr.TerminalNode + DATE_CORRELATION_OPTIMIZATION() antlr.TerminalNode + DATEADD() antlr.TerminalNode + DATEDIFF() antlr.TerminalNode + DATENAME() antlr.TerminalNode + DATEPART() antlr.TerminalNode + DAYS() antlr.TerminalNode + DB_CHAINING() antlr.TerminalNode + DB_FAILOVER() antlr.TerminalNode + DB_ID() antlr.TerminalNode + DB_NAME() antlr.TerminalNode + DBCC() antlr.TerminalNode + DBREINDEX() antlr.TerminalNode + DECRYPTION() antlr.TerminalNode + DEFAULT_DOUBLE_QUOTE() antlr.TerminalNode + DEFAULT_FULLTEXT_LANGUAGE() antlr.TerminalNode + DEFAULT_LANGUAGE() antlr.TerminalNode + DEFINITION() antlr.TerminalNode + DELAY() antlr.TerminalNode + DELAYED_DURABILITY() antlr.TerminalNode + DELETED() antlr.TerminalNode + DENSE_RANK() antlr.TerminalNode + DEPENDENTS() antlr.TerminalNode + DES() antlr.TerminalNode + DESCRIPTION() antlr.TerminalNode + DESX() antlr.TerminalNode + DETERMINISTIC() antlr.TerminalNode + DHCP() antlr.TerminalNode + DIALOG() antlr.TerminalNode + DIFFERENCE() antlr.TerminalNode + DIRECTORY_NAME() antlr.TerminalNode + DISABLE() antlr.TerminalNode + DISABLE_BROKER() antlr.TerminalNode + DISABLED() antlr.TerminalNode + DOCUMENT() antlr.TerminalNode + DROP_EXISTING() antlr.TerminalNode + DROPCLEANBUFFERS() antlr.TerminalNode + DYNAMIC() antlr.TerminalNode + ELEMENTS() antlr.TerminalNode + EMERGENCY() antlr.TerminalNode + EMPTY() antlr.TerminalNode + ENABLE() antlr.TerminalNode + ENABLE_BROKER() antlr.TerminalNode + ENCRYPTED() antlr.TerminalNode + ENCRYPTED_VALUE() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + ENCRYPTION_TYPE() antlr.TerminalNode + ENDPOINT_URL() antlr.TerminalNode + ERROR_BROKER_CONVERSATIONS() antlr.TerminalNode + ESTIMATEONLY() antlr.TerminalNode + EXCLUSIVE() antlr.TerminalNode + EXECUTABLE() antlr.TerminalNode + EXIST() antlr.TerminalNode + EXIST_SQUARE_BRACKET() antlr.TerminalNode + EXPAND() antlr.TerminalNode + EXPIRY_DATE() antlr.TerminalNode + EXPLICIT() antlr.TerminalNode + EXTENDED_LOGICAL_CHECKS() antlr.TerminalNode + FAIL_OPERATION() antlr.TerminalNode + FAILOVER_MODE() antlr.TerminalNode + FAILURE() antlr.TerminalNode + FAILURE_CONDITION_LEVEL() antlr.TerminalNode + FAST() antlr.TerminalNode + FAST_FORWARD() antlr.TerminalNode + FILE_ID() antlr.TerminalNode + FILE_IDEX() antlr.TerminalNode + FILE_NAME() antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + FILEGROUP_ID() antlr.TerminalNode + FILEGROUP_NAME() antlr.TerminalNode + FILEGROUPPROPERTY() antlr.TerminalNode + FILEGROWTH() antlr.TerminalNode + FILENAME() antlr.TerminalNode + FILEPATH() antlr.TerminalNode + FILEPROPERTY() antlr.TerminalNode + FILEPROPERTYEX() antlr.TerminalNode + FILESTREAM() antlr.TerminalNode + FILTER() antlr.TerminalNode + FIRST() antlr.TerminalNode + FIRST_VALUE() antlr.TerminalNode + FMTONLY() antlr.TerminalNode + FOLLOWING() antlr.TerminalNode + FORCE() antlr.TerminalNode + FORCE_FAILOVER_ALLOW_DATA_LOSS() antlr.TerminalNode + FORCED() antlr.TerminalNode + FORCEPLAN() antlr.TerminalNode + FORCESCAN() antlr.TerminalNode + FORMAT() antlr.TerminalNode + FORWARD_ONLY() antlr.TerminalNode + FREE() antlr.TerminalNode + FULLSCAN() antlr.TerminalNode + FULLTEXT() antlr.TerminalNode + FULLTEXTCATALOGPROPERTY() antlr.TerminalNode + FULLTEXTSERVICEPROPERTY() antlr.TerminalNode + GB() antlr.TerminalNode + GENERATED() antlr.TerminalNode + GETDATE() antlr.TerminalNode + GETUTCDATE() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + GO() antlr.TerminalNode + GREATEST() antlr.TerminalNode + GROUP_MAX_REQUESTS() antlr.TerminalNode + GROUPING() antlr.TerminalNode + GROUPING_ID() antlr.TerminalNode + HADR() antlr.TerminalNode + HAS_DBACCESS() antlr.TerminalNode + HAS_PERMS_BY_NAME() antlr.TerminalNode + HASH() antlr.TerminalNode + HEALTH_CHECK_TIMEOUT() antlr.TerminalNode + HIDDEN_KEYWORD() antlr.TerminalNode + HIGH() antlr.TerminalNode + HONOR_BROKER_PRIORITY() antlr.TerminalNode + HOURS() antlr.TerminalNode + IDENT_CURRENT() antlr.TerminalNode + IDENT_INCR() antlr.TerminalNode + IDENT_SEED() antlr.TerminalNode + IDENTITY_VALUE() antlr.TerminalNode + IGNORE_CONSTRAINTS() antlr.TerminalNode + IGNORE_DUP_KEY() antlr.TerminalNode + IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX() antlr.TerminalNode + IGNORE_REPLICATED_TABLE_CACHE() antlr.TerminalNode + IGNORE_TRIGGERS() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + IMPERSONATE() antlr.TerminalNode + IMPLICIT_TRANSACTIONS() antlr.TerminalNode + IMPORTANCE() antlr.TerminalNode + INCLUDE_NULL_VALUES() antlr.TerminalNode + INCREMENTAL() antlr.TerminalNode + INDEX_COL() antlr.TerminalNode + INDEXKEY_PROPERTY() antlr.TerminalNode + INDEXPROPERTY() antlr.TerminalNode + INITIATOR() antlr.TerminalNode + INPUT() antlr.TerminalNode + INSENSITIVE() antlr.TerminalNode + INSERTED() antlr.TerminalNode + INT() antlr.TerminalNode + IP() antlr.TerminalNode + IS_MEMBER() antlr.TerminalNode + IS_ROLEMEMBER() antlr.TerminalNode + IS_SRVROLEMEMBER() antlr.TerminalNode + ISJSON() antlr.TerminalNode + ISOLATION() antlr.TerminalNode + JOB() antlr.TerminalNode + JSON() antlr.TerminalNode + JSON_OBJECT() antlr.TerminalNode + JSON_ARRAY() antlr.TerminalNode + JSON_VALUE() antlr.TerminalNode + JSON_QUERY() antlr.TerminalNode + JSON_MODIFY() antlr.TerminalNode + JSON_PATH_EXISTS() antlr.TerminalNode + KB() antlr.TerminalNode + KEEP() antlr.TerminalNode + KEEPDEFAULTS() antlr.TerminalNode + KEEPFIXED() antlr.TerminalNode + KEEPIDENTITY() antlr.TerminalNode + KEY_SOURCE() antlr.TerminalNode + KEYS() antlr.TerminalNode + KEYSET() antlr.TerminalNode + LAG() antlr.TerminalNode + LAST() antlr.TerminalNode + LAST_VALUE() antlr.TerminalNode + LEAD() antlr.TerminalNode + LEAST() antlr.TerminalNode + LEN() antlr.TerminalNode + LEVEL() antlr.TerminalNode + LIST() antlr.TerminalNode + LISTENER() antlr.TerminalNode + LISTENER_URL() antlr.TerminalNode + LOB_COMPACTION() antlr.TerminalNode + LOCAL() antlr.TerminalNode + LOCATION() antlr.TerminalNode + LOCK() antlr.TerminalNode + LOCK_ESCALATION() antlr.TerminalNode + LOGIN() antlr.TerminalNode + LOGINPROPERTY() antlr.TerminalNode + LOOP() antlr.TerminalNode + LOW() antlr.TerminalNode + LOWER() antlr.TerminalNode + LTRIM() antlr.TerminalNode + MANUAL() antlr.TerminalNode + MARK() antlr.TerminalNode + MASKED() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + MAX() antlr.TerminalNode + MAX_CPU_PERCENT() antlr.TerminalNode + MAX_DOP() antlr.TerminalNode + MAX_FILES() antlr.TerminalNode + MAX_IOPS_PER_VOLUME() antlr.TerminalNode + MAX_MEMORY_PERCENT() antlr.TerminalNode + MAX_PROCESSES() antlr.TerminalNode + MAX_QUEUE_READERS() antlr.TerminalNode + MAX_ROLLOVER_FILES() antlr.TerminalNode + MAXDOP() antlr.TerminalNode + MAXRECURSION() antlr.TerminalNode + MAXSIZE() antlr.TerminalNode + MB() antlr.TerminalNode + MEDIUM() antlr.TerminalNode + MEMORY_OPTIMIZED_DATA() antlr.TerminalNode + MESSAGE() antlr.TerminalNode + MIN() antlr.TerminalNode + MIN_ACTIVE_ROWVERSION() antlr.TerminalNode + MIN_CPU_PERCENT() antlr.TerminalNode + MIN_IOPS_PER_VOLUME() antlr.TerminalNode + MIN_MEMORY_PERCENT() antlr.TerminalNode + MINUTES() antlr.TerminalNode + MIRROR_ADDRESS() antlr.TerminalNode + MIXED_PAGE_ALLOCATION() antlr.TerminalNode + MODE() antlr.TerminalNode + MODIFY() antlr.TerminalNode + MODIFY_SQUARE_BRACKET() antlr.TerminalNode + MOVE() antlr.TerminalNode + MULTI_USER() antlr.TerminalNode + NAME() antlr.TerminalNode + NCHAR() antlr.TerminalNode + NESTED_TRIGGERS() antlr.TerminalNode + NEW_ACCOUNT() antlr.TerminalNode + NEW_BROKER() antlr.TerminalNode + NEW_PASSWORD() antlr.TerminalNode + NEWNAME() antlr.TerminalNode + NEXT() antlr.TerminalNode + NO() antlr.TerminalNode + NO_INFOMSGS() antlr.TerminalNode + NO_QUERYSTORE() antlr.TerminalNode + NO_STATISTICS() antlr.TerminalNode + NO_TRUNCATE() antlr.TerminalNode + NO_WAIT() antlr.TerminalNode + NOCOUNT() antlr.TerminalNode + NODES() antlr.TerminalNode + NOEXEC() antlr.TerminalNode + NOEXPAND() antlr.TerminalNode + NOINDEX() antlr.TerminalNode + NOLOCK() antlr.TerminalNode + NON_TRANSACTED_ACCESS() antlr.TerminalNode + NORECOMPUTE() antlr.TerminalNode + NORECOVERY() antlr.TerminalNode + NOTIFICATIONS() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + NTILE() antlr.TerminalNode + NULL_DOUBLE_QUOTE() antlr.TerminalNode + NUMANODE() antlr.TerminalNode + NUMBER() antlr.TerminalNode + NUMERIC_ROUNDABORT() antlr.TerminalNode + OBJECT() antlr.TerminalNode + OBJECT_DEFINITION() antlr.TerminalNode + OBJECT_ID() antlr.TerminalNode + OBJECT_NAME() antlr.TerminalNode + OBJECT_SCHEMA_NAME() antlr.TerminalNode + OBJECTPROPERTY() antlr.TerminalNode + OBJECTPROPERTYEX() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + OFFSET() antlr.TerminalNode + OLD_ACCOUNT() antlr.TerminalNode + ONLINE() antlr.TerminalNode + ONLY() antlr.TerminalNode + OPEN_EXISTING() antlr.TerminalNode + OPENJSON() antlr.TerminalNode + OPTIMISTIC() antlr.TerminalNode + OPTIMIZE() antlr.TerminalNode + OPTIMIZE_FOR_SEQUENTIAL_KEY() antlr.TerminalNode + ORIGINAL_DB_NAME() antlr.TerminalNode + ORIGINAL_LOGIN() antlr.TerminalNode + OUT() antlr.TerminalNode + OUTPUT() antlr.TerminalNode + OVERRIDE() antlr.TerminalNode + OWNER() antlr.TerminalNode + OWNERSHIP() antlr.TerminalNode + PAD_INDEX() antlr.TerminalNode + PAGE_VERIFY() antlr.TerminalNode + PAGECOUNT() antlr.TerminalNode + PAGLOCK() antlr.TerminalNode + PARAMETERIZATION() antlr.TerminalNode + PARSENAME() antlr.TerminalNode + PARSEONLY() antlr.TerminalNode + PARTITION() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + PARTNER() antlr.TerminalNode + PATH() antlr.TerminalNode + PATINDEX() antlr.TerminalNode + PAUSE() antlr.TerminalNode + PDW_SHOWSPACEUSED() antlr.TerminalNode + PERCENT_RANK() antlr.TerminalNode + PERCENTILE_CONT() antlr.TerminalNode + PERCENTILE_DISC() antlr.TerminalNode + PERMISSIONS() antlr.TerminalNode + PERSIST_SAMPLE_PERCENT() antlr.TerminalNode + PHYSICAL_ONLY() antlr.TerminalNode + POISON_MESSAGE_HANDLING() antlr.TerminalNode + POOL() antlr.TerminalNode + PORT() antlr.TerminalNode + PRECEDING() antlr.TerminalNode + PRIMARY_ROLE() antlr.TerminalNode + PRIOR() antlr.TerminalNode + PRIORITY() antlr.TerminalNode + PRIORITY_LEVEL() antlr.TerminalNode + PRIVATE() antlr.TerminalNode + PRIVATE_KEY() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + PROCCACHE() antlr.TerminalNode + PROCEDURE_NAME() antlr.TerminalNode + PROPERTY() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + PROVIDER_KEY_NAME() antlr.TerminalNode + PWDCOMPARE() antlr.TerminalNode + PWDENCRYPT() antlr.TerminalNode + QUERY() antlr.TerminalNode + QUERY_SQUARE_BRACKET() antlr.TerminalNode + QUEUE() antlr.TerminalNode + QUEUE_DELAY() antlr.TerminalNode + QUOTED_IDENTIFIER() antlr.TerminalNode + QUOTENAME() antlr.TerminalNode + RANDOMIZED() antlr.TerminalNode + RANGE() antlr.TerminalNode + RANK() antlr.TerminalNode + RC2() antlr.TerminalNode + RC4() antlr.TerminalNode + RC4_128() antlr.TerminalNode + READ_COMMITTED_SNAPSHOT() antlr.TerminalNode + READ_ONLY() antlr.TerminalNode + READ_ONLY_ROUTING_LIST() antlr.TerminalNode + READ_WRITE() antlr.TerminalNode + READCOMMITTED() antlr.TerminalNode + READCOMMITTEDLOCK() antlr.TerminalNode + READONLY() antlr.TerminalNode + READPAST() antlr.TerminalNode + READUNCOMMITTED() antlr.TerminalNode + READWRITE() antlr.TerminalNode + REBUILD() antlr.TerminalNode + RECEIVE() antlr.TerminalNode + RECOMPILE() antlr.TerminalNode + RECOVERY() antlr.TerminalNode + RECURSIVE_TRIGGERS() antlr.TerminalNode + RELATIVE() antlr.TerminalNode + REMOTE() antlr.TerminalNode + REMOTE_PROC_TRANSACTIONS() antlr.TerminalNode + REMOTE_SERVICE_NAME() antlr.TerminalNode + REMOVE() antlr.TerminalNode + REORGANIZE() antlr.TerminalNode + REPAIR_ALLOW_DATA_LOSS() antlr.TerminalNode + REPAIR_FAST() antlr.TerminalNode + REPAIR_REBUILD() antlr.TerminalNode + REPEATABLE() antlr.TerminalNode + REPEATABLEREAD() antlr.TerminalNode + REPLACE() antlr.TerminalNode + REPLICA() antlr.TerminalNode + REPLICATE() antlr.TerminalNode + REQUEST_MAX_CPU_TIME_SEC() antlr.TerminalNode + REQUEST_MAX_MEMORY_GRANT_PERCENT() antlr.TerminalNode + REQUEST_MEMORY_GRANT_TIMEOUT_SEC() antlr.TerminalNode + REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT() antlr.TerminalNode + RESAMPLE() antlr.TerminalNode + RESERVE_DISK_SPACE() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + RESOURCE_MANAGER_LOCATION() antlr.TerminalNode + RESTRICTED_USER() antlr.TerminalNode + RESUMABLE() antlr.TerminalNode + RETENTION() antlr.TerminalNode + REVERSE() antlr.TerminalNode + ROBUST() antlr.TerminalNode + ROOT() antlr.TerminalNode + ROUTE() antlr.TerminalNode + ROW() antlr.TerminalNode + ROW_NUMBER() antlr.TerminalNode + ROWGUID() antlr.TerminalNode + ROWLOCK() antlr.TerminalNode + ROWS() antlr.TerminalNode + RTRIM() antlr.TerminalNode + SAMPLE() antlr.TerminalNode + SCHEMA_ID() antlr.TerminalNode + SCHEMA_NAME() antlr.TerminalNode + SCHEMABINDING() antlr.TerminalNode + SCOPE_IDENTITY() antlr.TerminalNode + SCOPED() antlr.TerminalNode + SCROLL() antlr.TerminalNode + SCROLL_LOCKS() antlr.TerminalNode + SEARCH() antlr.TerminalNode + SECONDARY() antlr.TerminalNode + SECONDARY_ONLY() antlr.TerminalNode + SECONDARY_ROLE() antlr.TerminalNode + SECONDS() antlr.TerminalNode + SECRET() antlr.TerminalNode + SECURABLES() antlr.TerminalNode + SECURITY() antlr.TerminalNode + SECURITY_LOG() antlr.TerminalNode + SEEDING_MODE() antlr.TerminalNode + SELF() antlr.TerminalNode + SEMI_SENSITIVE() antlr.TerminalNode + SEND() antlr.TerminalNode + SENT() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + SEQUENCE_NUMBER() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + SERVERPROPERTY() antlr.TerminalNode + SERVICEBROKER() antlr.TerminalNode + SESSIONPROPERTY() antlr.TerminalNode + SESSION_TIMEOUT() antlr.TerminalNode + SETERROR() antlr.TerminalNode + SHARE() antlr.TerminalNode + SHARED() antlr.TerminalNode + SHOWCONTIG() antlr.TerminalNode + SHOWPLAN() antlr.TerminalNode + SHOWPLAN_ALL() antlr.TerminalNode + SHOWPLAN_TEXT() antlr.TerminalNode + SHOWPLAN_XML() antlr.TerminalNode + SIGNATURE() antlr.TerminalNode + SIMPLE() antlr.TerminalNode + SINGLE_USER() antlr.TerminalNode + SIZE() antlr.TerminalNode + SMALLINT() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + SORT_IN_TEMPDB() antlr.TerminalNode + SOUNDEX() antlr.TerminalNode + SPACE_KEYWORD() antlr.TerminalNode + SPARSE() antlr.TerminalNode + SPATIAL_WINDOW_MAX_CELLS() antlr.TerminalNode + SQL_VARIANT_PROPERTY() antlr.TerminalNode + STANDBY() antlr.TerminalNode + START_DATE() antlr.TerminalNode + STATIC() antlr.TerminalNode + STATISTICS_INCREMENTAL() antlr.TerminalNode + STATISTICS_NORECOMPUTE() antlr.TerminalNode + STATS_DATE() antlr.TerminalNode + STATS_STREAM() antlr.TerminalNode + STATUS() antlr.TerminalNode + STATUSONLY() antlr.TerminalNode + STDEV() antlr.TerminalNode + STDEVP() antlr.TerminalNode + STOPLIST() antlr.TerminalNode + STR() antlr.TerminalNode + STRING_AGG() antlr.TerminalNode + STRING_ESCAPE() antlr.TerminalNode + STUFF() antlr.TerminalNode + SUBJECT() antlr.TerminalNode + SUBSCRIBE() antlr.TerminalNode + SUBSCRIPTION() antlr.TerminalNode + SUBSTRING() antlr.TerminalNode + SUM() antlr.TerminalNode + SUSER_ID() antlr.TerminalNode + SUSER_NAME() antlr.TerminalNode + SUSER_SID() antlr.TerminalNode + SUSER_SNAME() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + SYMMETRIC() antlr.TerminalNode + SYNCHRONOUS_COMMIT() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + TABLERESULTS() antlr.TerminalNode + TABLOCK() antlr.TerminalNode + TABLOCKX() antlr.TerminalNode + TAKE() antlr.TerminalNode + TARGET_RECOVERY_TIME() antlr.TerminalNode + TB() antlr.TerminalNode + TEXTIMAGE_ON() antlr.TerminalNode + THROW() antlr.TerminalNode + TIES() antlr.TerminalNode + TIME() antlr.TerminalNode + TIMEOUT() antlr.TerminalNode + TIMER() antlr.TerminalNode + TINYINT() antlr.TerminalNode + TORN_PAGE_DETECTION() antlr.TerminalNode + TRACKING() antlr.TerminalNode + TRANSACTION_ID() antlr.TerminalNode + TRANSFORM_NOISE_WORDS() antlr.TerminalNode + TRANSLATE() antlr.TerminalNode + TRIM() antlr.TerminalNode + TRIPLE_DES() antlr.TerminalNode + TRIPLE_DES_3KEY() antlr.TerminalNode + TRUSTWORTHY() antlr.TerminalNode + TRY() antlr.TerminalNode + TSQL() antlr.TerminalNode + TWO_DIGIT_YEAR_CUTOFF() antlr.TerminalNode + TYPE() antlr.TerminalNode + TYPE_ID() antlr.TerminalNode + TYPE_NAME() antlr.TerminalNode + TYPE_WARNING() antlr.TerminalNode + TYPEPROPERTY() antlr.TerminalNode + UNBOUNDED() antlr.TerminalNode + UNCOMMITTED() antlr.TerminalNode + UNICODE() antlr.TerminalNode + UNKNOWN() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + UNMASK() antlr.TerminalNode + UOW() antlr.TerminalNode + UPDLOCK() antlr.TerminalNode + UPPER() antlr.TerminalNode + USER_ID() antlr.TerminalNode + USER_NAME() antlr.TerminalNode + USING() antlr.TerminalNode + VALID_XML() antlr.TerminalNode + VALIDATION() antlr.TerminalNode + VALUE() antlr.TerminalNode + VALUE_SQUARE_BRACKET() antlr.TerminalNode + VAR() antlr.TerminalNode + VARBINARY_KEYWORD() antlr.TerminalNode + VARP() antlr.TerminalNode + VERIFY_CLONEDB() antlr.TerminalNode + VERSION() antlr.TerminalNode + VIEW_METADATA() antlr.TerminalNode + VIEWS() antlr.TerminalNode + WAIT() antlr.TerminalNode + WELL_FORMED_XML() antlr.TerminalNode + WITHOUT_ARRAY_WRAPPER() antlr.TerminalNode + WORK() antlr.TerminalNode + WORKLOAD() antlr.TerminalNode + XLOCK() antlr.TerminalNode + XML() antlr.TerminalNode + XML_COMPRESSION() antlr.TerminalNode + XMLDATA() antlr.TerminalNode + XMLNAMESPACES() antlr.TerminalNode + XMLSCHEMA() antlr.TerminalNode + XSINIL() antlr.TerminalNode + ZONE() antlr.TerminalNode + ABORT_AFTER_WAIT() antlr.TerminalNode + ABSENT() antlr.TerminalNode + ADMINISTER() antlr.TerminalNode + AES() antlr.TerminalNode + ALLOW_CONNECTIONS() antlr.TerminalNode + ALLOW_MULTIPLE_EVENT_LOSS() antlr.TerminalNode + ALLOW_SINGLE_EVENT_LOSS() antlr.TerminalNode + ANONYMOUS() antlr.TerminalNode + APPEND() antlr.TerminalNode + APPLICATION() antlr.TerminalNode + ASYMMETRIC() antlr.TerminalNode + ASYNCHRONOUS_COMMIT() antlr.TerminalNode + AUTHENTICATE() antlr.TerminalNode + AUTHENTICATION() antlr.TerminalNode + AUTOMATED_BACKUP_PREFERENCE() antlr.TerminalNode + AUTOMATIC() antlr.TerminalNode + AVAILABILITY_MODE() antlr.TerminalNode + BEFORE() antlr.TerminalNode + BLOCK() antlr.TerminalNode + BLOCKERS() antlr.TerminalNode + BLOCKSIZE() antlr.TerminalNode + BLOCKING_HIERARCHY() antlr.TerminalNode + BUFFER() antlr.TerminalNode + BUFFERCOUNT() antlr.TerminalNode + CACHE() antlr.TerminalNode + CALLED() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + CHANGETABLE() antlr.TerminalNode + CHANGES() antlr.TerminalNode + CHECK_POLICY() antlr.TerminalNode + CHECK_EXPIRATION() antlr.TerminalNode + CLASSIFIER_FUNCTION() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + COMPRESS() antlr.TerminalNode + COMPRESSION() antlr.TerminalNode + CONNECT() antlr.TerminalNode + CONNECTION() antlr.TerminalNode + CONFIGURATION() antlr.TerminalNode + CONNECTIONPROPERTY() antlr.TerminalNode + CONTAINMENT() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + CONTEXT_INFO() antlr.TerminalNode + CONTINUE_AFTER_ERROR() antlr.TerminalNode + CONTRACT() antlr.TerminalNode + CONTRACT_NAME() antlr.TerminalNode + CONVERSATION() antlr.TerminalNode + COPY_ONLY() antlr.TerminalNode + CURRENT_REQUEST_ID() antlr.TerminalNode + CURRENT_TRANSACTION_ID() antlr.TerminalNode + CYCLE() antlr.TerminalNode + DATA_COMPRESSION() antlr.TerminalNode + DATA_SOURCE() antlr.TerminalNode + DATABASE_MIRRORING() antlr.TerminalNode + DATASPACE() antlr.TerminalNode + DDL() antlr.TerminalNode + DECOMPRESS() antlr.TerminalNode + DEFAULT_DATABASE() antlr.TerminalNode + DEFAULT_SCHEMA() antlr.TerminalNode + DIAGNOSTICS() antlr.TerminalNode + DIFFERENTIAL() antlr.TerminalNode + DISTRIBUTION() antlr.TerminalNode + DTC_SUPPORT() antlr.TerminalNode + ENABLED() antlr.TerminalNode + ENDPOINT() antlr.TerminalNode + ERROR() antlr.TerminalNode + ERROR_LINE() antlr.TerminalNode + ERROR_MESSAGE() antlr.TerminalNode + ERROR_NUMBER() antlr.TerminalNode + ERROR_PROCEDURE() antlr.TerminalNode + ERROR_SEVERITY() antlr.TerminalNode + ERROR_STATE() antlr.TerminalNode + EVENT() antlr.TerminalNode + EVENTDATA() antlr.TerminalNode + EVENT_RETENTION_MODE() antlr.TerminalNode + EXECUTABLE_FILE() antlr.TerminalNode + EXPIREDATE() antlr.TerminalNode + EXTENSION() antlr.TerminalNode + EXTERNAL_ACCESS() antlr.TerminalNode + FAILOVER() antlr.TerminalNode + FAILURECONDITIONLEVEL() antlr.TerminalNode + FAN_IN() antlr.TerminalNode + FILE_SNAPSHOT() antlr.TerminalNode + FORCESEEK() antlr.TerminalNode + FORCE_SERVICE_ALLOW_DATA_LOSS() antlr.TerminalNode + FORMATMESSAGE() antlr.TerminalNode + GET() antlr.TerminalNode + GET_FILESTREAM_TRANSACTION_CONTEXT() antlr.TerminalNode + GETANCESTOR() antlr.TerminalNode + GETANSINULL() antlr.TerminalNode + GETDESCENDANT() antlr.TerminalNode + GETLEVEL() antlr.TerminalNode + GETREPARENTEDVALUE() antlr.TerminalNode + GETROOT() antlr.TerminalNode + GOVERNOR() antlr.TerminalNode + HASHED() antlr.TerminalNode + HEALTHCHECKTIMEOUT() antlr.TerminalNode + HEAP() antlr.TerminalNode + HIERARCHYID() antlr.TerminalNode + HOST_ID() antlr.TerminalNode + HOST_NAME() antlr.TerminalNode + IIF() antlr.TerminalNode + IO() antlr.TerminalNode + INCLUDE() antlr.TerminalNode + INCREMENT() antlr.TerminalNode + INFINITE() antlr.TerminalNode + INIT() antlr.TerminalNode + INSTEAD() antlr.TerminalNode + ISDESCENDANTOF() antlr.TerminalNode + ISNULL() antlr.TerminalNode + ISNUMERIC() antlr.TerminalNode + KERBEROS() antlr.TerminalNode + KEY_PATH() antlr.TerminalNode + KEY_STORE_PROVIDER_NAME() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + LIFETIME() antlr.TerminalNode + LINKED() antlr.TerminalNode + LINUX() antlr.TerminalNode + LISTENER_IP() antlr.TerminalNode + LISTENER_PORT() antlr.TerminalNode + LOCAL_SERVICE_NAME() antlr.TerminalNode + LOG() antlr.TerminalNode + MASK() antlr.TerminalNode + MATCHED() antlr.TerminalNode + MASTER() antlr.TerminalNode + MAX_MEMORY() antlr.TerminalNode + MAXTRANSFER() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + MAX_DISPATCH_LATENCY() antlr.TerminalNode + MAX_DURATION() antlr.TerminalNode + MAX_EVENT_SIZE() antlr.TerminalNode + MAX_SIZE() antlr.TerminalNode + MAX_OUTSTANDING_IO_PER_VOLUME() antlr.TerminalNode + MEDIADESCRIPTION() antlr.TerminalNode + MEDIANAME() antlr.TerminalNode + MEMBER() antlr.TerminalNode + MEMORY_PARTITION_MODE() antlr.TerminalNode + MESSAGE_FORWARDING() antlr.TerminalNode + MESSAGE_FORWARD_SIZE() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + MIRROR() antlr.TerminalNode + MUST_CHANGE() antlr.TerminalNode + NEWID() antlr.TerminalNode + NEWSEQUENTIALID() antlr.TerminalNode + NOFORMAT() antlr.TerminalNode + NOINIT() antlr.TerminalNode + NONE() antlr.TerminalNode + NOREWIND() antlr.TerminalNode + NOSKIP() antlr.TerminalNode + NOUNLOAD() antlr.TerminalNode + NO_CHECKSUM() antlr.TerminalNode + NO_COMPRESSION() antlr.TerminalNode + NO_EVENT_LOSS() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + NTLM() antlr.TerminalNode + OLD_PASSWORD() antlr.TerminalNode + ON_FAILURE() antlr.TerminalNode + OPERATIONS() antlr.TerminalNode + PAGE() antlr.TerminalNode + PARAM_NODE() antlr.TerminalNode + PARTIAL() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + PERMISSION_SET() antlr.TerminalNode + PER_CPU() antlr.TerminalNode + PER_DB() antlr.TerminalNode + PER_NODE() antlr.TerminalNode + PERSISTED() antlr.TerminalNode + PLATFORM() antlr.TerminalNode + POLICY() antlr.TerminalNode + PREDICATE() antlr.TerminalNode + PROCESS() antlr.TerminalNode + PROFILE() antlr.TerminalNode + PYTHON() antlr.TerminalNode + R() antlr.TerminalNode + READ_WRITE_FILEGROUPS() antlr.TerminalNode + REGENERATE() antlr.TerminalNode + RELATED_CONVERSATION() antlr.TerminalNode + RELATED_CONVERSATION_GROUP() antlr.TerminalNode + REQUIRED() antlr.TerminalNode + RESET() antlr.TerminalNode + RESOURCES() antlr.TerminalNode + RESTART() antlr.TerminalNode + RESUME() antlr.TerminalNode + RETAINDAYS() antlr.TerminalNode + RETURNS() antlr.TerminalNode + REWIND() antlr.TerminalNode + ROLE() antlr.TerminalNode + ROUND_ROBIN() antlr.TerminalNode + ROWCOUNT_BIG() antlr.TerminalNode + RSA_512() antlr.TerminalNode + RSA_1024() antlr.TerminalNode + RSA_2048() antlr.TerminalNode + RSA_3072() antlr.TerminalNode + RSA_4096() antlr.TerminalNode + SAFETY() antlr.TerminalNode + SAFE() antlr.TerminalNode + SCHEDULER() antlr.TerminalNode + SCHEME() antlr.TerminalNode + SCRIPT() antlr.TerminalNode + SERVER() antlr.TerminalNode + SERVICE() antlr.TerminalNode + SERVICE_BROKER() antlr.TerminalNode + SERVICE_NAME() antlr.TerminalNode + SESSION() antlr.TerminalNode + SESSION_CONTEXT() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + SHRINKLOG() antlr.TerminalNode + SID() antlr.TerminalNode + SKIP_KEYWORD() antlr.TerminalNode + SOFTNUMA() antlr.TerminalNode + SOURCE() antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + SPLIT() antlr.TerminalNode + SQL() antlr.TerminalNode + SQLDUMPERFLAGS() antlr.TerminalNode + SQLDUMPERPATH() antlr.TerminalNode + SQLDUMPERTIMEOUT() antlr.TerminalNode + STATE() antlr.TerminalNode + STATS() antlr.TerminalNode + START() antlr.TerminalNode + STARTED() antlr.TerminalNode + STARTUP_STATE() antlr.TerminalNode + STOP() antlr.TerminalNode + STOPPED() antlr.TerminalNode + STOP_ON_ERROR() antlr.TerminalNode + SUPPORTED() antlr.TerminalNode + SWITCH() antlr.TerminalNode + TAPE() antlr.TerminalNode + TARGET() antlr.TerminalNode + TCP() antlr.TerminalNode + TOSTRING() antlr.TerminalNode + TRACE() antlr.TerminalNode + TRACK_CAUSALITY() antlr.TerminalNode + TRANSFER() antlr.TerminalNode + UNCHECKED() antlr.TerminalNode + UNLOCK() antlr.TerminalNode + UNSAFE() antlr.TerminalNode + URL() antlr.TerminalNode + USED() antlr.TerminalNode + VERBOSELOGGING() antlr.TerminalNode + VISIBILITY() antlr.TerminalNode + WAIT_AT_LOW_PRIORITY() antlr.TerminalNode + WINDOWS() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + WITNESS() antlr.TerminalNode + XACT_ABORT() antlr.TerminalNode + XACT_STATE() antlr.TerminalNode + ABS() antlr.TerminalNode + ACOS() antlr.TerminalNode + ASIN() antlr.TerminalNode + ATAN() antlr.TerminalNode + ATN2() antlr.TerminalNode + CEILING() antlr.TerminalNode + COS() antlr.TerminalNode + COT() antlr.TerminalNode + DEGREES() antlr.TerminalNode + EXP() antlr.TerminalNode + FLOOR() antlr.TerminalNode + LOG10() antlr.TerminalNode + PI() antlr.TerminalNode + POWER() antlr.TerminalNode + RADIANS() antlr.TerminalNode + RAND() antlr.TerminalNode + ROUND() antlr.TerminalNode + SIGN() antlr.TerminalNode + SIN() antlr.TerminalNode + SQRT() antlr.TerminalNode + SQUARE() antlr.TerminalNode + TAN() antlr.TerminalNode + CURRENT_TIMEZONE() antlr.TerminalNode + CURRENT_TIMEZONE_ID() antlr.TerminalNode + DATE_BUCKET() antlr.TerminalNode + DATEDIFF_BIG() antlr.TerminalNode + DATEFROMPARTS() antlr.TerminalNode + DATETIME2FROMPARTS() antlr.TerminalNode + DATETIMEFROMPARTS() antlr.TerminalNode + DATETIMEOFFSETFROMPARTS() antlr.TerminalNode + DATETRUNC() antlr.TerminalNode + DAY() antlr.TerminalNode + EOMONTH() antlr.TerminalNode + ISDATE() antlr.TerminalNode + MONTH() antlr.TerminalNode + SMALLDATETIMEFROMPARTS() antlr.TerminalNode + SWITCHOFFSET() antlr.TerminalNode + SYSDATETIME() antlr.TerminalNode + SYSDATETIMEOFFSET() antlr.TerminalNode + SYSUTCDATETIME() antlr.TerminalNode + TIMEFROMPARTS() antlr.TerminalNode + TODATETIMEOFFSET() antlr.TerminalNode + YEAR() antlr.TerminalNode + QUARTER() antlr.TerminalNode + DAYOFYEAR() antlr.TerminalNode + WEEK() antlr.TerminalNode + HOUR() antlr.TerminalNode + MINUTE() antlr.TerminalNode + SECOND() antlr.TerminalNode + MILLISECOND() antlr.TerminalNode + MICROSECOND() antlr.TerminalNode + NANOSECOND() antlr.TerminalNode + TZOFFSET() antlr.TerminalNode + ISO_WEEK() antlr.TerminalNode + WEEKDAY() antlr.TerminalNode + YEAR_ABBR() antlr.TerminalNode + QUARTER_ABBR() antlr.TerminalNode + MONTH_ABBR() antlr.TerminalNode + DAYOFYEAR_ABBR() antlr.TerminalNode + DAY_ABBR() antlr.TerminalNode + WEEK_ABBR() antlr.TerminalNode + HOUR_ABBR() antlr.TerminalNode + MINUTE_ABBR() antlr.TerminalNode + SECOND_ABBR() antlr.TerminalNode + MILLISECOND_ABBR() antlr.TerminalNode + MICROSECOND_ABBR() antlr.TerminalNode + NANOSECOND_ABBR() antlr.TerminalNode + TZOFFSET_ABBR() antlr.TerminalNode + ISO_WEEK_ABBR() antlr.TerminalNode + WEEKDAY_ABBR() antlr.TerminalNode + SP_EXECUTESQL() antlr.TerminalNode + VARCHAR() antlr.TerminalNode + NVARCHAR() antlr.TerminalNode + PRECISION() antlr.TerminalNode + FILESTREAM_ON() antlr.TerminalNode + + // IsKeywordContext differentiates from other interfaces. + IsKeywordContext() +} + +type KeywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKeywordContext() *KeywordContext { + var p = new(KeywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_keyword + return p +} + +func InitEmptyKeywordContext(p *KeywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_keyword +} + +func (*KeywordContext) IsKeywordContext() {} + +func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext { + var p = new(KeywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_keyword + + return p +} + +func (s *KeywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *KeywordContext) ABORT() antlr.TerminalNode { + return s.GetToken(TSqlParserABORT, 0) +} + +func (s *KeywordContext) ABSOLUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserABSOLUTE, 0) +} + +func (s *KeywordContext) ACCENT_SENSITIVITY() antlr.TerminalNode { + return s.GetToken(TSqlParserACCENT_SENSITIVITY, 0) +} + +func (s *KeywordContext) ACCESS() antlr.TerminalNode { + return s.GetToken(TSqlParserACCESS, 0) +} + +func (s *KeywordContext) ACTION() antlr.TerminalNode { + return s.GetToken(TSqlParserACTION, 0) +} + +func (s *KeywordContext) ACTIVATION() antlr.TerminalNode { + return s.GetToken(TSqlParserACTIVATION, 0) +} + +func (s *KeywordContext) ACTIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserACTIVE, 0) +} + +func (s *KeywordContext) ADD() antlr.TerminalNode { + return s.GetToken(TSqlParserADD, 0) +} + +func (s *KeywordContext) ADDRESS() antlr.TerminalNode { + return s.GetToken(TSqlParserADDRESS, 0) +} + +func (s *KeywordContext) AES_128() antlr.TerminalNode { + return s.GetToken(TSqlParserAES_128, 0) +} + +func (s *KeywordContext) AES_192() antlr.TerminalNode { + return s.GetToken(TSqlParserAES_192, 0) +} + +func (s *KeywordContext) AES_256() antlr.TerminalNode { + return s.GetToken(TSqlParserAES_256, 0) +} + +func (s *KeywordContext) AFFINITY() antlr.TerminalNode { + return s.GetToken(TSqlParserAFFINITY, 0) +} + +func (s *KeywordContext) AFTER() antlr.TerminalNode { + return s.GetToken(TSqlParserAFTER, 0) +} + +func (s *KeywordContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(TSqlParserAGGREGATE, 0) +} + +func (s *KeywordContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(TSqlParserALGORITHM, 0) +} + +func (s *KeywordContext) ALL_CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(TSqlParserALL_CONSTRAINTS, 0) +} + +func (s *KeywordContext) ALL_ERRORMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserALL_ERRORMSGS, 0) +} + +func (s *KeywordContext) ALL_INDEXES() antlr.TerminalNode { + return s.GetToken(TSqlParserALL_INDEXES, 0) +} + +func (s *KeywordContext) ALL_LEVELS() antlr.TerminalNode { + return s.GetToken(TSqlParserALL_LEVELS, 0) +} + +func (s *KeywordContext) ALLOW_ENCRYPTED_VALUE_MODIFICATIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, 0) +} + +func (s *KeywordContext) ALLOW_PAGE_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_PAGE_LOCKS, 0) +} + +func (s *KeywordContext) ALLOW_ROW_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_ROW_LOCKS, 0) +} + +func (s *KeywordContext) ALLOW_SNAPSHOT_ISOLATION() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_SNAPSHOT_ISOLATION, 0) +} + +func (s *KeywordContext) ALLOWED() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOWED, 0) +} + +func (s *KeywordContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(TSqlParserALWAYS, 0) +} + +func (s *KeywordContext) ANSI_DEFAULTS() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_DEFAULTS, 0) +} + +func (s *KeywordContext) ANSI_NULL_DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_NULL_DEFAULT, 0) +} + +func (s *KeywordContext) ANSI_NULL_DFLT_OFF() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_NULL_DFLT_OFF, 0) +} + +func (s *KeywordContext) ANSI_NULL_DFLT_ON() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_NULL_DFLT_ON, 0) +} + +func (s *KeywordContext) ANSI_NULLS() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_NULLS, 0) +} + +func (s *KeywordContext) ANSI_PADDING() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_PADDING, 0) +} + +func (s *KeywordContext) ANSI_WARNINGS() antlr.TerminalNode { + return s.GetToken(TSqlParserANSI_WARNINGS, 0) +} + +func (s *KeywordContext) APP_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserAPP_NAME, 0) +} + +func (s *KeywordContext) APPLICATION_LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLICATION_LOG, 0) +} + +func (s *KeywordContext) APPLOCK_MODE() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLOCK_MODE, 0) +} + +func (s *KeywordContext) APPLOCK_TEST() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLOCK_TEST, 0) +} + +func (s *KeywordContext) APPLY() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLY, 0) +} + +func (s *KeywordContext) ARITHABORT() antlr.TerminalNode { + return s.GetToken(TSqlParserARITHABORT, 0) +} + +func (s *KeywordContext) ARITHIGNORE() antlr.TerminalNode { + return s.GetToken(TSqlParserARITHIGNORE, 0) +} + +func (s *KeywordContext) ASCII() antlr.TerminalNode { + return s.GetToken(TSqlParserASCII, 0) +} + +func (s *KeywordContext) ASSEMBLY() antlr.TerminalNode { + return s.GetToken(TSqlParserASSEMBLY, 0) +} + +func (s *KeywordContext) ASSEMBLYPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserASSEMBLYPROPERTY, 0) +} + +func (s *KeywordContext) AT_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserAT_KEYWORD, 0) +} + +func (s *KeywordContext) AUDIT() antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT, 0) +} + +func (s *KeywordContext) AUDIT_GUID() antlr.TerminalNode { + return s.GetToken(TSqlParserAUDIT_GUID, 0) +} + +func (s *KeywordContext) AUTO() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO, 0) +} + +func (s *KeywordContext) AUTO_CLEANUP() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_CLEANUP, 0) +} + +func (s *KeywordContext) AUTO_CLOSE() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_CLOSE, 0) +} + +func (s *KeywordContext) AUTO_CREATE_STATISTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_CREATE_STATISTICS, 0) +} + +func (s *KeywordContext) AUTO_DROP() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_DROP, 0) +} + +func (s *KeywordContext) AUTO_SHRINK() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_SHRINK, 0) +} + +func (s *KeywordContext) AUTO_UPDATE_STATISTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_UPDATE_STATISTICS, 0) +} + +func (s *KeywordContext) AUTO_UPDATE_STATISTICS_ASYNC() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, 0) +} + +func (s *KeywordContext) AUTOGROW_ALL_FILES() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTOGROW_ALL_FILES, 0) +} + +func (s *KeywordContext) AUTOGROW_SINGLE_FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTOGROW_SINGLE_FILE, 0) +} + +func (s *KeywordContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(TSqlParserAVAILABILITY, 0) +} + +func (s *KeywordContext) AVG() antlr.TerminalNode { + return s.GetToken(TSqlParserAVG, 0) +} + +func (s *KeywordContext) BACKUP_CLONEDB() antlr.TerminalNode { + return s.GetToken(TSqlParserBACKUP_CLONEDB, 0) +} + +func (s *KeywordContext) BACKUP_PRIORITY() antlr.TerminalNode { + return s.GetToken(TSqlParserBACKUP_PRIORITY, 0) +} + +func (s *KeywordContext) BASE64() antlr.TerminalNode { + return s.GetToken(TSqlParserBASE64, 0) +} + +func (s *KeywordContext) BEGIN_DIALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserBEGIN_DIALOG, 0) +} + +func (s *KeywordContext) BIGINT() antlr.TerminalNode { + return s.GetToken(TSqlParserBIGINT, 0) +} + +func (s *KeywordContext) BINARY_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY_KEYWORD, 0) +} + +func (s *KeywordContext) BINARY_CHECKSUM() antlr.TerminalNode { + return s.GetToken(TSqlParserBINARY_CHECKSUM, 0) +} + +func (s *KeywordContext) BINDING() antlr.TerminalNode { + return s.GetToken(TSqlParserBINDING, 0) +} + +func (s *KeywordContext) BLOB_STORAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserBLOB_STORAGE, 0) +} + +func (s *KeywordContext) BROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserBROKER, 0) +} + +func (s *KeywordContext) BROKER_INSTANCE() antlr.TerminalNode { + return s.GetToken(TSqlParserBROKER_INSTANCE, 0) +} + +func (s *KeywordContext) BULK_LOGGED() antlr.TerminalNode { + return s.GetToken(TSqlParserBULK_LOGGED, 0) +} + +func (s *KeywordContext) CALLER() antlr.TerminalNode { + return s.GetToken(TSqlParserCALLER, 0) +} + +func (s *KeywordContext) CAP_CPU_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserCAP_CPU_PERCENT, 0) +} + +func (s *KeywordContext) CAST() antlr.TerminalNode { + return s.GetToken(TSqlParserCAST, 0) +} + +func (s *KeywordContext) TRY_CAST() antlr.TerminalNode { + return s.GetToken(TSqlParserTRY_CAST, 0) +} + +func (s *KeywordContext) CATALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserCATALOG, 0) +} + +func (s *KeywordContext) CATCH() antlr.TerminalNode { + return s.GetToken(TSqlParserCATCH, 0) +} + +func (s *KeywordContext) CERT_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserCERT_ID, 0) +} + +func (s *KeywordContext) CERTENCODED() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTENCODED, 0) +} + +func (s *KeywordContext) CERTPRIVATEKEY() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTPRIVATEKEY, 0) +} + +func (s *KeywordContext) CHANGE() antlr.TerminalNode { + return s.GetToken(TSqlParserCHANGE, 0) +} + +func (s *KeywordContext) CHANGE_RETENTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCHANGE_RETENTION, 0) +} + +func (s *KeywordContext) CHANGE_TRACKING() antlr.TerminalNode { + return s.GetToken(TSqlParserCHANGE_TRACKING, 0) +} + +func (s *KeywordContext) CHAR() antlr.TerminalNode { + return s.GetToken(TSqlParserCHAR, 0) +} + +func (s *KeywordContext) CHARINDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserCHARINDEX, 0) +} + +func (s *KeywordContext) CHECKALLOC() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKALLOC, 0) +} + +func (s *KeywordContext) CHECKCATALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKCATALOG, 0) +} + +func (s *KeywordContext) CHECKCONSTRAINTS() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKCONSTRAINTS, 0) +} + +func (s *KeywordContext) CHECKDB() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKDB, 0) +} + +func (s *KeywordContext) CHECKFILEGROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKFILEGROUP, 0) +} + +func (s *KeywordContext) CHECKSUM() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKSUM, 0) +} + +func (s *KeywordContext) CHECKSUM_AGG() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKSUM_AGG, 0) +} + +func (s *KeywordContext) CHECKTABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECKTABLE, 0) +} + +func (s *KeywordContext) CLEANTABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserCLEANTABLE, 0) +} + +func (s *KeywordContext) CLEANUP() antlr.TerminalNode { + return s.GetToken(TSqlParserCLEANUP, 0) +} + +func (s *KeywordContext) CLONEDATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserCLONEDATABASE, 0) +} + +func (s *KeywordContext) COL_LENGTH() antlr.TerminalNode { + return s.GetToken(TSqlParserCOL_LENGTH, 0) +} + +func (s *KeywordContext) COL_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserCOL_NAME, 0) +} + +func (s *KeywordContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLLECTION, 0) +} + +func (s *KeywordContext) COLUMN_ENCRYPTION_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMN_ENCRYPTION_KEY, 0) +} + +func (s *KeywordContext) COLUMN_MASTER_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMN_MASTER_KEY, 0) +} + +func (s *KeywordContext) COLUMNPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNPROPERTY, 0) +} + +func (s *KeywordContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNS, 0) +} + +func (s *KeywordContext) COLUMNSTORE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE, 0) +} + +func (s *KeywordContext) COLUMNSTORE_ARCHIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOLUMNSTORE_ARCHIVE, 0) +} + +func (s *KeywordContext) COMMITTED() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMMITTED, 0) +} + +func (s *KeywordContext) COMPATIBILITY_LEVEL() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPATIBILITY_LEVEL, 0) +} + +func (s *KeywordContext) COMPRESS_ALL_ROW_GROUPS() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPRESS_ALL_ROW_GROUPS, 0) +} + +func (s *KeywordContext) COMPRESSION_DELAY() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPRESSION_DELAY, 0) +} + +func (s *KeywordContext) CONCAT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONCAT, 0) +} + +func (s *KeywordContext) CONCAT_WS() antlr.TerminalNode { + return s.GetToken(TSqlParserCONCAT_WS, 0) +} + +func (s *KeywordContext) CONCAT_NULL_YIELDS_NULL() antlr.TerminalNode { + return s.GetToken(TSqlParserCONCAT_NULL_YIELDS_NULL, 0) +} + +func (s *KeywordContext) CONTENT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTENT, 0) +} + +func (s *KeywordContext) CONTROL() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTROL, 0) +} + +func (s *KeywordContext) COOKIE() antlr.TerminalNode { + return s.GetToken(TSqlParserCOOKIE, 0) +} + +func (s *KeywordContext) COUNT() antlr.TerminalNode { + return s.GetToken(TSqlParserCOUNT, 0) +} + +func (s *KeywordContext) COUNT_BIG() antlr.TerminalNode { + return s.GetToken(TSqlParserCOUNT_BIG, 0) +} + +func (s *KeywordContext) COUNTER() antlr.TerminalNode { + return s.GetToken(TSqlParserCOUNTER, 0) +} + +func (s *KeywordContext) CPU() antlr.TerminalNode { + return s.GetToken(TSqlParserCPU, 0) +} + +func (s *KeywordContext) CREATE_NEW() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATE_NEW, 0) +} + +func (s *KeywordContext) CREATION_DISPOSITION() antlr.TerminalNode { + return s.GetToken(TSqlParserCREATION_DISPOSITION, 0) +} + +func (s *KeywordContext) CREDENTIAL() antlr.TerminalNode { + return s.GetToken(TSqlParserCREDENTIAL, 0) +} + +func (s *KeywordContext) CRYPTOGRAPHIC() antlr.TerminalNode { + return s.GetToken(TSqlParserCRYPTOGRAPHIC, 0) +} + +func (s *KeywordContext) CUME_DIST() antlr.TerminalNode { + return s.GetToken(TSqlParserCUME_DIST, 0) +} + +func (s *KeywordContext) CURSOR_CLOSE_ON_COMMIT() antlr.TerminalNode { + return s.GetToken(TSqlParserCURSOR_CLOSE_ON_COMMIT, 0) +} + +func (s *KeywordContext) CURSOR_DEFAULT() antlr.TerminalNode { + return s.GetToken(TSqlParserCURSOR_DEFAULT, 0) +} + +func (s *KeywordContext) CURSOR_STATUS() antlr.TerminalNode { + return s.GetToken(TSqlParserCURSOR_STATUS, 0) +} + +func (s *KeywordContext) DATA() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA, 0) +} + +func (s *KeywordContext) DATA_PURITY() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA_PURITY, 0) +} + +func (s *KeywordContext) DATABASE_PRINCIPAL_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE_PRINCIPAL_ID, 0) +} + +func (s *KeywordContext) DATABASEPROPERTYEX() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASEPROPERTYEX, 0) +} + +func (s *KeywordContext) DATALENGTH() antlr.TerminalNode { + return s.GetToken(TSqlParserDATALENGTH, 0) +} + +func (s *KeywordContext) DATE_CORRELATION_OPTIMIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserDATE_CORRELATION_OPTIMIZATION, 0) +} + +func (s *KeywordContext) DATEADD() antlr.TerminalNode { + return s.GetToken(TSqlParserDATEADD, 0) +} + +func (s *KeywordContext) DATEDIFF() antlr.TerminalNode { + return s.GetToken(TSqlParserDATEDIFF, 0) +} + +func (s *KeywordContext) DATENAME() antlr.TerminalNode { + return s.GetToken(TSqlParserDATENAME, 0) +} + +func (s *KeywordContext) DATEPART() antlr.TerminalNode { + return s.GetToken(TSqlParserDATEPART, 0) +} + +func (s *KeywordContext) DAYS() antlr.TerminalNode { + return s.GetToken(TSqlParserDAYS, 0) +} + +func (s *KeywordContext) DB_CHAINING() antlr.TerminalNode { + return s.GetToken(TSqlParserDB_CHAINING, 0) +} + +func (s *KeywordContext) DB_FAILOVER() antlr.TerminalNode { + return s.GetToken(TSqlParserDB_FAILOVER, 0) +} + +func (s *KeywordContext) DB_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserDB_ID, 0) +} + +func (s *KeywordContext) DB_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserDB_NAME, 0) +} + +func (s *KeywordContext) DBCC() antlr.TerminalNode { + return s.GetToken(TSqlParserDBCC, 0) +} + +func (s *KeywordContext) DBREINDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserDBREINDEX, 0) +} + +func (s *KeywordContext) DECRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserDECRYPTION, 0) +} + +func (s *KeywordContext) DEFAULT_DOUBLE_QUOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_DOUBLE_QUOTE, 0) +} + +func (s *KeywordContext) DEFAULT_FULLTEXT_LANGUAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_FULLTEXT_LANGUAGE, 0) +} + +func (s *KeywordContext) DEFAULT_LANGUAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_LANGUAGE, 0) +} + +func (s *KeywordContext) DEFINITION() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFINITION, 0) +} + +func (s *KeywordContext) DELAY() antlr.TerminalNode { + return s.GetToken(TSqlParserDELAY, 0) +} + +func (s *KeywordContext) DELAYED_DURABILITY() antlr.TerminalNode { + return s.GetToken(TSqlParserDELAYED_DURABILITY, 0) +} + +func (s *KeywordContext) DELETED() antlr.TerminalNode { + return s.GetToken(TSqlParserDELETED, 0) +} + +func (s *KeywordContext) DENSE_RANK() antlr.TerminalNode { + return s.GetToken(TSqlParserDENSE_RANK, 0) +} + +func (s *KeywordContext) DEPENDENTS() antlr.TerminalNode { + return s.GetToken(TSqlParserDEPENDENTS, 0) +} + +func (s *KeywordContext) DES() antlr.TerminalNode { + return s.GetToken(TSqlParserDES, 0) +} + +func (s *KeywordContext) DESCRIPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserDESCRIPTION, 0) +} + +func (s *KeywordContext) DESX() antlr.TerminalNode { + return s.GetToken(TSqlParserDESX, 0) +} + +func (s *KeywordContext) DETERMINISTIC() antlr.TerminalNode { + return s.GetToken(TSqlParserDETERMINISTIC, 0) +} + +func (s *KeywordContext) DHCP() antlr.TerminalNode { + return s.GetToken(TSqlParserDHCP, 0) +} + +func (s *KeywordContext) DIALOG() antlr.TerminalNode { + return s.GetToken(TSqlParserDIALOG, 0) +} + +func (s *KeywordContext) DIFFERENCE() antlr.TerminalNode { + return s.GetToken(TSqlParserDIFFERENCE, 0) +} + +func (s *KeywordContext) DIRECTORY_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserDIRECTORY_NAME, 0) +} + +func (s *KeywordContext) DISABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLE, 0) +} + +func (s *KeywordContext) DISABLE_BROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLE_BROKER, 0) +} + +func (s *KeywordContext) DISABLED() antlr.TerminalNode { + return s.GetToken(TSqlParserDISABLED, 0) +} + +func (s *KeywordContext) DOCUMENT() antlr.TerminalNode { + return s.GetToken(TSqlParserDOCUMENT, 0) +} + +func (s *KeywordContext) DROP_EXISTING() antlr.TerminalNode { + return s.GetToken(TSqlParserDROP_EXISTING, 0) +} + +func (s *KeywordContext) DROPCLEANBUFFERS() antlr.TerminalNode { + return s.GetToken(TSqlParserDROPCLEANBUFFERS, 0) +} + +func (s *KeywordContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(TSqlParserDYNAMIC, 0) +} + +func (s *KeywordContext) ELEMENTS() antlr.TerminalNode { + return s.GetToken(TSqlParserELEMENTS, 0) +} + +func (s *KeywordContext) EMERGENCY() antlr.TerminalNode { + return s.GetToken(TSqlParserEMERGENCY, 0) +} + +func (s *KeywordContext) EMPTY() antlr.TerminalNode { + return s.GetToken(TSqlParserEMPTY, 0) +} + +func (s *KeywordContext) ENABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserENABLE, 0) +} + +func (s *KeywordContext) ENABLE_BROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserENABLE_BROKER, 0) +} + +func (s *KeywordContext) ENCRYPTED() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTED, 0) +} + +func (s *KeywordContext) ENCRYPTED_VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTED_VALUE, 0) +} + +func (s *KeywordContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION, 0) +} + +func (s *KeywordContext) ENCRYPTION_TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserENCRYPTION_TYPE, 0) +} + +func (s *KeywordContext) ENDPOINT_URL() antlr.TerminalNode { + return s.GetToken(TSqlParserENDPOINT_URL, 0) +} + +func (s *KeywordContext) ERROR_BROKER_CONVERSATIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_BROKER_CONVERSATIONS, 0) +} + +func (s *KeywordContext) ESTIMATEONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserESTIMATEONLY, 0) +} + +func (s *KeywordContext) EXCLUSIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXCLUSIVE, 0) +} + +func (s *KeywordContext) EXECUTABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXECUTABLE, 0) +} + +func (s *KeywordContext) EXIST() antlr.TerminalNode { + return s.GetToken(TSqlParserEXIST, 0) +} + +func (s *KeywordContext) EXIST_SQUARE_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserEXIST_SQUARE_BRACKET, 0) +} + +func (s *KeywordContext) EXPAND() antlr.TerminalNode { + return s.GetToken(TSqlParserEXPAND, 0) +} + +func (s *KeywordContext) EXPIRY_DATE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXPIRY_DATE, 0) +} + +func (s *KeywordContext) EXPLICIT() antlr.TerminalNode { + return s.GetToken(TSqlParserEXPLICIT, 0) +} + +func (s *KeywordContext) EXTENDED_LOGICAL_CHECKS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTENDED_LOGICAL_CHECKS, 0) +} + +func (s *KeywordContext) FAIL_OPERATION() antlr.TerminalNode { + return s.GetToken(TSqlParserFAIL_OPERATION, 0) +} + +func (s *KeywordContext) FAILOVER_MODE() antlr.TerminalNode { + return s.GetToken(TSqlParserFAILOVER_MODE, 0) +} + +func (s *KeywordContext) FAILURE() antlr.TerminalNode { + return s.GetToken(TSqlParserFAILURE, 0) +} + +func (s *KeywordContext) FAILURE_CONDITION_LEVEL() antlr.TerminalNode { + return s.GetToken(TSqlParserFAILURE_CONDITION_LEVEL, 0) +} + +func (s *KeywordContext) FAST() antlr.TerminalNode { + return s.GetToken(TSqlParserFAST, 0) +} + +func (s *KeywordContext) FAST_FORWARD() antlr.TerminalNode { + return s.GetToken(TSqlParserFAST_FORWARD, 0) +} + +func (s *KeywordContext) FILE_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE_ID, 0) +} + +func (s *KeywordContext) FILE_IDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE_IDEX, 0) +} + +func (s *KeywordContext) FILE_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE_NAME, 0) +} + +func (s *KeywordContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROUP, 0) +} + +func (s *KeywordContext) FILEGROUP_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROUP_ID, 0) +} + +func (s *KeywordContext) FILEGROUP_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROUP_NAME, 0) +} + +func (s *KeywordContext) FILEGROUPPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROUPPROPERTY, 0) +} + +func (s *KeywordContext) FILEGROWTH() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEGROWTH, 0) +} + +func (s *KeywordContext) FILENAME() antlr.TerminalNode { + return s.GetToken(TSqlParserFILENAME, 0) +} + +func (s *KeywordContext) FILEPATH() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEPATH, 0) +} + +func (s *KeywordContext) FILEPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEPROPERTY, 0) +} + +func (s *KeywordContext) FILEPROPERTYEX() antlr.TerminalNode { + return s.GetToken(TSqlParserFILEPROPERTYEX, 0) +} + +func (s *KeywordContext) FILESTREAM() antlr.TerminalNode { + return s.GetToken(TSqlParserFILESTREAM, 0) +} + +func (s *KeywordContext) FILTER() antlr.TerminalNode { + return s.GetToken(TSqlParserFILTER, 0) +} + +func (s *KeywordContext) FIRST() antlr.TerminalNode { + return s.GetToken(TSqlParserFIRST, 0) +} + +func (s *KeywordContext) FIRST_VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserFIRST_VALUE, 0) +} + +func (s *KeywordContext) FMTONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserFMTONLY, 0) +} + +func (s *KeywordContext) FOLLOWING() antlr.TerminalNode { + return s.GetToken(TSqlParserFOLLOWING, 0) +} + +func (s *KeywordContext) FORCE() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCE, 0) +} + +func (s *KeywordContext) FORCE_FAILOVER_ALLOW_DATA_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, 0) +} + +func (s *KeywordContext) FORCED() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCED, 0) +} + +func (s *KeywordContext) FORCEPLAN() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCEPLAN, 0) +} + +func (s *KeywordContext) FORCESCAN() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCESCAN, 0) +} + +func (s *KeywordContext) FORMAT() antlr.TerminalNode { + return s.GetToken(TSqlParserFORMAT, 0) +} + +func (s *KeywordContext) FORWARD_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserFORWARD_ONLY, 0) +} + +func (s *KeywordContext) FREE() antlr.TerminalNode { + return s.GetToken(TSqlParserFREE, 0) +} + +func (s *KeywordContext) FULLSCAN() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLSCAN, 0) +} + +func (s *KeywordContext) FULLTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXT, 0) +} + +func (s *KeywordContext) FULLTEXTCATALOGPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXTCATALOGPROPERTY, 0) +} + +func (s *KeywordContext) FULLTEXTSERVICEPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserFULLTEXTSERVICEPROPERTY, 0) +} + +func (s *KeywordContext) GB() antlr.TerminalNode { + return s.GetToken(TSqlParserGB, 0) +} + +func (s *KeywordContext) GENERATED() antlr.TerminalNode { + return s.GetToken(TSqlParserGENERATED, 0) +} + +func (s *KeywordContext) GETDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserGETDATE, 0) +} + +func (s *KeywordContext) GETUTCDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserGETUTCDATE, 0) +} + +func (s *KeywordContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(TSqlParserGLOBAL, 0) +} + +func (s *KeywordContext) GO() antlr.TerminalNode { + return s.GetToken(TSqlParserGO, 0) +} + +func (s *KeywordContext) GREATEST() antlr.TerminalNode { + return s.GetToken(TSqlParserGREATEST, 0) +} + +func (s *KeywordContext) GROUP_MAX_REQUESTS() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUP_MAX_REQUESTS, 0) +} + +func (s *KeywordContext) GROUPING() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUPING, 0) +} + +func (s *KeywordContext) GROUPING_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserGROUPING_ID, 0) +} + +func (s *KeywordContext) HADR() antlr.TerminalNode { + return s.GetToken(TSqlParserHADR, 0) +} + +func (s *KeywordContext) HAS_DBACCESS() antlr.TerminalNode { + return s.GetToken(TSqlParserHAS_DBACCESS, 0) +} + +func (s *KeywordContext) HAS_PERMS_BY_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserHAS_PERMS_BY_NAME, 0) +} + +func (s *KeywordContext) HASH() antlr.TerminalNode { + return s.GetToken(TSqlParserHASH, 0) +} + +func (s *KeywordContext) HEALTH_CHECK_TIMEOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserHEALTH_CHECK_TIMEOUT, 0) +} + +func (s *KeywordContext) HIDDEN_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserHIDDEN_KEYWORD, 0) +} + +func (s *KeywordContext) HIGH() antlr.TerminalNode { + return s.GetToken(TSqlParserHIGH, 0) +} + +func (s *KeywordContext) HONOR_BROKER_PRIORITY() antlr.TerminalNode { + return s.GetToken(TSqlParserHONOR_BROKER_PRIORITY, 0) +} + +func (s *KeywordContext) HOURS() antlr.TerminalNode { + return s.GetToken(TSqlParserHOURS, 0) +} + +func (s *KeywordContext) IDENT_CURRENT() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENT_CURRENT, 0) +} + +func (s *KeywordContext) IDENT_INCR() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENT_INCR, 0) +} + +func (s *KeywordContext) IDENT_SEED() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENT_SEED, 0) +} + +func (s *KeywordContext) IDENTITY_VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserIDENTITY_VALUE, 0) +} + +func (s *KeywordContext) IGNORE_CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_CONSTRAINTS, 0) +} + +func (s *KeywordContext) IGNORE_DUP_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_DUP_KEY, 0) +} + +func (s *KeywordContext) IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, 0) +} + +func (s *KeywordContext) IGNORE_REPLICATED_TABLE_CACHE() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_REPLICATED_TABLE_CACHE, 0) +} + +func (s *KeywordContext) IGNORE_TRIGGERS() antlr.TerminalNode { + return s.GetToken(TSqlParserIGNORE_TRIGGERS, 0) +} + +func (s *KeywordContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(TSqlParserIMMEDIATE, 0) +} + +func (s *KeywordContext) IMPERSONATE() antlr.TerminalNode { + return s.GetToken(TSqlParserIMPERSONATE, 0) +} + +func (s *KeywordContext) IMPLICIT_TRANSACTIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserIMPLICIT_TRANSACTIONS, 0) +} + +func (s *KeywordContext) IMPORTANCE() antlr.TerminalNode { + return s.GetToken(TSqlParserIMPORTANCE, 0) +} + +func (s *KeywordContext) INCLUDE_NULL_VALUES() antlr.TerminalNode { + return s.GetToken(TSqlParserINCLUDE_NULL_VALUES, 0) +} + +func (s *KeywordContext) INCREMENTAL() antlr.TerminalNode { + return s.GetToken(TSqlParserINCREMENTAL, 0) +} + +func (s *KeywordContext) INDEX_COL() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEX_COL, 0) +} + +func (s *KeywordContext) INDEXKEY_PROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEXKEY_PROPERTY, 0) +} + +func (s *KeywordContext) INDEXPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserINDEXPROPERTY, 0) +} + +func (s *KeywordContext) INITIATOR() antlr.TerminalNode { + return s.GetToken(TSqlParserINITIATOR, 0) +} + +func (s *KeywordContext) INPUT() antlr.TerminalNode { + return s.GetToken(TSqlParserINPUT, 0) +} + +func (s *KeywordContext) INSENSITIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserINSENSITIVE, 0) +} + +func (s *KeywordContext) INSERTED() antlr.TerminalNode { + return s.GetToken(TSqlParserINSERTED, 0) +} + +func (s *KeywordContext) INT() antlr.TerminalNode { + return s.GetToken(TSqlParserINT, 0) +} + +func (s *KeywordContext) IP() antlr.TerminalNode { + return s.GetToken(TSqlParserIP, 0) +} + +func (s *KeywordContext) IS_MEMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserIS_MEMBER, 0) +} + +func (s *KeywordContext) IS_ROLEMEMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserIS_ROLEMEMBER, 0) +} + +func (s *KeywordContext) IS_SRVROLEMEMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserIS_SRVROLEMEMBER, 0) +} + +func (s *KeywordContext) ISJSON() antlr.TerminalNode { + return s.GetToken(TSqlParserISJSON, 0) +} + +func (s *KeywordContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(TSqlParserISOLATION, 0) +} + +func (s *KeywordContext) JOB() antlr.TerminalNode { + return s.GetToken(TSqlParserJOB, 0) +} + +func (s *KeywordContext) JSON() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON, 0) +} + +func (s *KeywordContext) JSON_OBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON_OBJECT, 0) +} + +func (s *KeywordContext) JSON_ARRAY() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON_ARRAY, 0) +} + +func (s *KeywordContext) JSON_VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON_VALUE, 0) +} + +func (s *KeywordContext) JSON_QUERY() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON_QUERY, 0) +} + +func (s *KeywordContext) JSON_MODIFY() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON_MODIFY, 0) +} + +func (s *KeywordContext) JSON_PATH_EXISTS() antlr.TerminalNode { + return s.GetToken(TSqlParserJSON_PATH_EXISTS, 0) +} + +func (s *KeywordContext) KB() antlr.TerminalNode { + return s.GetToken(TSqlParserKB, 0) +} + +func (s *KeywordContext) KEEP() antlr.TerminalNode { + return s.GetToken(TSqlParserKEEP, 0) +} + +func (s *KeywordContext) KEEPDEFAULTS() antlr.TerminalNode { + return s.GetToken(TSqlParserKEEPDEFAULTS, 0) +} + +func (s *KeywordContext) KEEPFIXED() antlr.TerminalNode { + return s.GetToken(TSqlParserKEEPFIXED, 0) +} + +func (s *KeywordContext) KEEPIDENTITY() antlr.TerminalNode { + return s.GetToken(TSqlParserKEEPIDENTITY, 0) +} + +func (s *KeywordContext) KEY_SOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY_SOURCE, 0) +} + +func (s *KeywordContext) KEYS() antlr.TerminalNode { + return s.GetToken(TSqlParserKEYS, 0) +} + +func (s *KeywordContext) KEYSET() antlr.TerminalNode { + return s.GetToken(TSqlParserKEYSET, 0) +} + +func (s *KeywordContext) LAG() antlr.TerminalNode { + return s.GetToken(TSqlParserLAG, 0) +} + +func (s *KeywordContext) LAST() antlr.TerminalNode { + return s.GetToken(TSqlParserLAST, 0) +} + +func (s *KeywordContext) LAST_VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserLAST_VALUE, 0) +} + +func (s *KeywordContext) LEAD() antlr.TerminalNode { + return s.GetToken(TSqlParserLEAD, 0) +} + +func (s *KeywordContext) LEAST() antlr.TerminalNode { + return s.GetToken(TSqlParserLEAST, 0) +} + +func (s *KeywordContext) LEN() antlr.TerminalNode { + return s.GetToken(TSqlParserLEN, 0) +} + +func (s *KeywordContext) LEVEL() antlr.TerminalNode { + return s.GetToken(TSqlParserLEVEL, 0) +} + +func (s *KeywordContext) LIST() antlr.TerminalNode { + return s.GetToken(TSqlParserLIST, 0) +} + +func (s *KeywordContext) LISTENER() antlr.TerminalNode { + return s.GetToken(TSqlParserLISTENER, 0) +} + +func (s *KeywordContext) LISTENER_URL() antlr.TerminalNode { + return s.GetToken(TSqlParserLISTENER_URL, 0) +} + +func (s *KeywordContext) LOB_COMPACTION() antlr.TerminalNode { + return s.GetToken(TSqlParserLOB_COMPACTION, 0) +} + +func (s *KeywordContext) LOCAL() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL, 0) +} + +func (s *KeywordContext) LOCATION() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCATION, 0) +} + +func (s *KeywordContext) LOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCK, 0) +} + +func (s *KeywordContext) LOCK_ESCALATION() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCK_ESCALATION, 0) +} + +func (s *KeywordContext) LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGIN, 0) +} + +func (s *KeywordContext) LOGINPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserLOGINPROPERTY, 0) +} + +func (s *KeywordContext) LOOP() antlr.TerminalNode { + return s.GetToken(TSqlParserLOOP, 0) +} + +func (s *KeywordContext) LOW() antlr.TerminalNode { + return s.GetToken(TSqlParserLOW, 0) +} + +func (s *KeywordContext) LOWER() antlr.TerminalNode { + return s.GetToken(TSqlParserLOWER, 0) +} + +func (s *KeywordContext) LTRIM() antlr.TerminalNode { + return s.GetToken(TSqlParserLTRIM, 0) +} + +func (s *KeywordContext) MANUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserMANUAL, 0) +} + +func (s *KeywordContext) MARK() antlr.TerminalNode { + return s.GetToken(TSqlParserMARK, 0) +} + +func (s *KeywordContext) MASKED() antlr.TerminalNode { + return s.GetToken(TSqlParserMASKED, 0) +} + +func (s *KeywordContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(TSqlParserMATERIALIZED, 0) +} + +func (s *KeywordContext) MAX() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX, 0) +} + +func (s *KeywordContext) MAX_CPU_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_CPU_PERCENT, 0) +} + +func (s *KeywordContext) MAX_DOP() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_DOP, 0) +} + +func (s *KeywordContext) MAX_FILES() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_FILES, 0) +} + +func (s *KeywordContext) MAX_IOPS_PER_VOLUME() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_IOPS_PER_VOLUME, 0) +} + +func (s *KeywordContext) MAX_MEMORY_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_MEMORY_PERCENT, 0) +} + +func (s *KeywordContext) MAX_PROCESSES() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_PROCESSES, 0) +} + +func (s *KeywordContext) MAX_QUEUE_READERS() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_QUEUE_READERS, 0) +} + +func (s *KeywordContext) MAX_ROLLOVER_FILES() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_ROLLOVER_FILES, 0) +} + +func (s *KeywordContext) MAXDOP() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXDOP, 0) +} + +func (s *KeywordContext) MAXRECURSION() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXRECURSION, 0) +} + +func (s *KeywordContext) MAXSIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXSIZE, 0) +} + +func (s *KeywordContext) MB() antlr.TerminalNode { + return s.GetToken(TSqlParserMB, 0) +} + +func (s *KeywordContext) MEDIUM() antlr.TerminalNode { + return s.GetToken(TSqlParserMEDIUM, 0) +} + +func (s *KeywordContext) MEMORY_OPTIMIZED_DATA() antlr.TerminalNode { + return s.GetToken(TSqlParserMEMORY_OPTIMIZED_DATA, 0) +} + +func (s *KeywordContext) MESSAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE, 0) +} + +func (s *KeywordContext) MIN() antlr.TerminalNode { + return s.GetToken(TSqlParserMIN, 0) +} + +func (s *KeywordContext) MIN_ACTIVE_ROWVERSION() antlr.TerminalNode { + return s.GetToken(TSqlParserMIN_ACTIVE_ROWVERSION, 0) +} + +func (s *KeywordContext) MIN_CPU_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserMIN_CPU_PERCENT, 0) +} + +func (s *KeywordContext) MIN_IOPS_PER_VOLUME() antlr.TerminalNode { + return s.GetToken(TSqlParserMIN_IOPS_PER_VOLUME, 0) +} + +func (s *KeywordContext) MIN_MEMORY_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserMIN_MEMORY_PERCENT, 0) +} + +func (s *KeywordContext) MINUTES() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUTES, 0) +} + +func (s *KeywordContext) MIRROR_ADDRESS() antlr.TerminalNode { + return s.GetToken(TSqlParserMIRROR_ADDRESS, 0) +} + +func (s *KeywordContext) MIXED_PAGE_ALLOCATION() antlr.TerminalNode { + return s.GetToken(TSqlParserMIXED_PAGE_ALLOCATION, 0) +} + +func (s *KeywordContext) MODE() antlr.TerminalNode { + return s.GetToken(TSqlParserMODE, 0) +} + +func (s *KeywordContext) MODIFY() antlr.TerminalNode { + return s.GetToken(TSqlParserMODIFY, 0) +} + +func (s *KeywordContext) MODIFY_SQUARE_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserMODIFY_SQUARE_BRACKET, 0) +} + +func (s *KeywordContext) MOVE() antlr.TerminalNode { + return s.GetToken(TSqlParserMOVE, 0) +} + +func (s *KeywordContext) MULTI_USER() antlr.TerminalNode { + return s.GetToken(TSqlParserMULTI_USER, 0) +} + +func (s *KeywordContext) NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNAME, 0) +} + +func (s *KeywordContext) NCHAR() antlr.TerminalNode { + return s.GetToken(TSqlParserNCHAR, 0) +} + +func (s *KeywordContext) NESTED_TRIGGERS() antlr.TerminalNode { + return s.GetToken(TSqlParserNESTED_TRIGGERS, 0) +} + +func (s *KeywordContext) NEW_ACCOUNT() antlr.TerminalNode { + return s.GetToken(TSqlParserNEW_ACCOUNT, 0) +} + +func (s *KeywordContext) NEW_BROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserNEW_BROKER, 0) +} + +func (s *KeywordContext) NEW_PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserNEW_PASSWORD, 0) +} + +func (s *KeywordContext) NEWNAME() antlr.TerminalNode { + return s.GetToken(TSqlParserNEWNAME, 0) +} + +func (s *KeywordContext) NEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserNEXT, 0) +} + +func (s *KeywordContext) NO() antlr.TerminalNode { + return s.GetToken(TSqlParserNO, 0) +} + +func (s *KeywordContext) NO_INFOMSGS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_INFOMSGS, 0) +} + +func (s *KeywordContext) NO_QUERYSTORE() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_QUERYSTORE, 0) +} + +func (s *KeywordContext) NO_STATISTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_STATISTICS, 0) +} + +func (s *KeywordContext) NO_TRUNCATE() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_TRUNCATE, 0) +} + +func (s *KeywordContext) NO_WAIT() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_WAIT, 0) +} + +func (s *KeywordContext) NOCOUNT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOCOUNT, 0) +} + +func (s *KeywordContext) NODES() antlr.TerminalNode { + return s.GetToken(TSqlParserNODES, 0) +} + +func (s *KeywordContext) NOEXEC() antlr.TerminalNode { + return s.GetToken(TSqlParserNOEXEC, 0) +} + +func (s *KeywordContext) NOEXPAND() antlr.TerminalNode { + return s.GetToken(TSqlParserNOEXPAND, 0) +} + +func (s *KeywordContext) NOINDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserNOINDEX, 0) +} + +func (s *KeywordContext) NOLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserNOLOCK, 0) +} + +func (s *KeywordContext) NON_TRANSACTED_ACCESS() antlr.TerminalNode { + return s.GetToken(TSqlParserNON_TRANSACTED_ACCESS, 0) +} + +func (s *KeywordContext) NORECOMPUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserNORECOMPUTE, 0) +} + +func (s *KeywordContext) NORECOVERY() antlr.TerminalNode { + return s.GetToken(TSqlParserNORECOVERY, 0) +} + +func (s *KeywordContext) NOTIFICATIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserNOTIFICATIONS, 0) +} + +func (s *KeywordContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOWAIT, 0) +} + +func (s *KeywordContext) NTILE() antlr.TerminalNode { + return s.GetToken(TSqlParserNTILE, 0) +} + +func (s *KeywordContext) NULL_DOUBLE_QUOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserNULL_DOUBLE_QUOTE, 0) +} + +func (s *KeywordContext) NUMANODE() antlr.TerminalNode { + return s.GetToken(TSqlParserNUMANODE, 0) +} + +func (s *KeywordContext) NUMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserNUMBER, 0) +} + +func (s *KeywordContext) NUMERIC_ROUNDABORT() antlr.TerminalNode { + return s.GetToken(TSqlParserNUMERIC_ROUNDABORT, 0) +} + +func (s *KeywordContext) OBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT, 0) +} + +func (s *KeywordContext) OBJECT_DEFINITION() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT_DEFINITION, 0) +} + +func (s *KeywordContext) OBJECT_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT_ID, 0) +} + +func (s *KeywordContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT_NAME, 0) +} + +func (s *KeywordContext) OBJECT_SCHEMA_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECT_SCHEMA_NAME, 0) +} + +func (s *KeywordContext) OBJECTPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECTPROPERTY, 0) +} + +func (s *KeywordContext) OBJECTPROPERTYEX() antlr.TerminalNode { + return s.GetToken(TSqlParserOBJECTPROPERTYEX, 0) +} + +func (s *KeywordContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(TSqlParserOFFLINE, 0) +} + +func (s *KeywordContext) OFFSET() antlr.TerminalNode { + return s.GetToken(TSqlParserOFFSET, 0) +} + +func (s *KeywordContext) OLD_ACCOUNT() antlr.TerminalNode { + return s.GetToken(TSqlParserOLD_ACCOUNT, 0) +} + +func (s *KeywordContext) ONLINE() antlr.TerminalNode { + return s.GetToken(TSqlParserONLINE, 0) +} + +func (s *KeywordContext) ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserONLY, 0) +} + +func (s *KeywordContext) OPEN_EXISTING() antlr.TerminalNode { + return s.GetToken(TSqlParserOPEN_EXISTING, 0) +} + +func (s *KeywordContext) OPENJSON() antlr.TerminalNode { + return s.GetToken(TSqlParserOPENJSON, 0) +} + +func (s *KeywordContext) OPTIMISTIC() antlr.TerminalNode { + return s.GetToken(TSqlParserOPTIMISTIC, 0) +} + +func (s *KeywordContext) OPTIMIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserOPTIMIZE, 0) +} + +func (s *KeywordContext) OPTIMIZE_FOR_SEQUENTIAL_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, 0) +} + +func (s *KeywordContext) ORIGINAL_DB_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserORIGINAL_DB_NAME, 0) +} + +func (s *KeywordContext) ORIGINAL_LOGIN() antlr.TerminalNode { + return s.GetToken(TSqlParserORIGINAL_LOGIN, 0) +} + +func (s *KeywordContext) OUT() antlr.TerminalNode { + return s.GetToken(TSqlParserOUT, 0) +} + +func (s *KeywordContext) OUTPUT() antlr.TerminalNode { + return s.GetToken(TSqlParserOUTPUT, 0) +} + +func (s *KeywordContext) OVERRIDE() antlr.TerminalNode { + return s.GetToken(TSqlParserOVERRIDE, 0) +} + +func (s *KeywordContext) OWNER() antlr.TerminalNode { + return s.GetToken(TSqlParserOWNER, 0) +} + +func (s *KeywordContext) OWNERSHIP() antlr.TerminalNode { + return s.GetToken(TSqlParserOWNERSHIP, 0) +} + +func (s *KeywordContext) PAD_INDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserPAD_INDEX, 0) +} + +func (s *KeywordContext) PAGE_VERIFY() antlr.TerminalNode { + return s.GetToken(TSqlParserPAGE_VERIFY, 0) +} + +func (s *KeywordContext) PAGECOUNT() antlr.TerminalNode { + return s.GetToken(TSqlParserPAGECOUNT, 0) +} + +func (s *KeywordContext) PAGLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserPAGLOCK, 0) +} + +func (s *KeywordContext) PARAMETERIZATION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARAMETERIZATION, 0) +} + +func (s *KeywordContext) PARSENAME() antlr.TerminalNode { + return s.GetToken(TSqlParserPARSENAME, 0) +} + +func (s *KeywordContext) PARSEONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserPARSEONLY, 0) +} + +func (s *KeywordContext) PARTITION() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITION, 0) +} + +func (s *KeywordContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTITIONS, 0) +} + +func (s *KeywordContext) PARTNER() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTNER, 0) +} + +func (s *KeywordContext) PATH() antlr.TerminalNode { + return s.GetToken(TSqlParserPATH, 0) +} + +func (s *KeywordContext) PATINDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserPATINDEX, 0) +} + +func (s *KeywordContext) PAUSE() antlr.TerminalNode { + return s.GetToken(TSqlParserPAUSE, 0) +} + +func (s *KeywordContext) PDW_SHOWSPACEUSED() antlr.TerminalNode { + return s.GetToken(TSqlParserPDW_SHOWSPACEUSED, 0) +} + +func (s *KeywordContext) PERCENT_RANK() antlr.TerminalNode { + return s.GetToken(TSqlParserPERCENT_RANK, 0) +} + +func (s *KeywordContext) PERCENTILE_CONT() antlr.TerminalNode { + return s.GetToken(TSqlParserPERCENTILE_CONT, 0) +} + +func (s *KeywordContext) PERCENTILE_DISC() antlr.TerminalNode { + return s.GetToken(TSqlParserPERCENTILE_DISC, 0) +} + +func (s *KeywordContext) PERMISSIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserPERMISSIONS, 0) +} + +func (s *KeywordContext) PERSIST_SAMPLE_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserPERSIST_SAMPLE_PERCENT, 0) +} + +func (s *KeywordContext) PHYSICAL_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserPHYSICAL_ONLY, 0) +} + +func (s *KeywordContext) POISON_MESSAGE_HANDLING() antlr.TerminalNode { + return s.GetToken(TSqlParserPOISON_MESSAGE_HANDLING, 0) +} + +func (s *KeywordContext) POOL() antlr.TerminalNode { + return s.GetToken(TSqlParserPOOL, 0) +} + +func (s *KeywordContext) PORT() antlr.TerminalNode { + return s.GetToken(TSqlParserPORT, 0) +} + +func (s *KeywordContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(TSqlParserPRECEDING, 0) +} + +func (s *KeywordContext) PRIMARY_ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIMARY_ROLE, 0) +} + +func (s *KeywordContext) PRIOR() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIOR, 0) +} + +func (s *KeywordContext) PRIORITY() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIORITY, 0) +} + +func (s *KeywordContext) PRIORITY_LEVEL() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIORITY_LEVEL, 0) +} + +func (s *KeywordContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIVATE, 0) +} + +func (s *KeywordContext) PRIVATE_KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIVATE_KEY, 0) +} + +func (s *KeywordContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(TSqlParserPRIVILEGES, 0) +} + +func (s *KeywordContext) PROCCACHE() antlr.TerminalNode { + return s.GetToken(TSqlParserPROCCACHE, 0) +} + +func (s *KeywordContext) PROCEDURE_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserPROCEDURE_NAME, 0) +} + +func (s *KeywordContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserPROPERTY, 0) +} + +func (s *KeywordContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER, 0) +} + +func (s *KeywordContext) PROVIDER_KEY_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserPROVIDER_KEY_NAME, 0) +} + +func (s *KeywordContext) PWDCOMPARE() antlr.TerminalNode { + return s.GetToken(TSqlParserPWDCOMPARE, 0) +} + +func (s *KeywordContext) PWDENCRYPT() antlr.TerminalNode { + return s.GetToken(TSqlParserPWDENCRYPT, 0) +} + +func (s *KeywordContext) QUERY() antlr.TerminalNode { + return s.GetToken(TSqlParserQUERY, 0) +} + +func (s *KeywordContext) QUERY_SQUARE_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserQUERY_SQUARE_BRACKET, 0) +} + +func (s *KeywordContext) QUEUE() antlr.TerminalNode { + return s.GetToken(TSqlParserQUEUE, 0) +} + +func (s *KeywordContext) QUEUE_DELAY() antlr.TerminalNode { + return s.GetToken(TSqlParserQUEUE_DELAY, 0) +} + +func (s *KeywordContext) QUOTED_IDENTIFIER() antlr.TerminalNode { + return s.GetToken(TSqlParserQUOTED_IDENTIFIER, 0) +} + +func (s *KeywordContext) QUOTENAME() antlr.TerminalNode { + return s.GetToken(TSqlParserQUOTENAME, 0) +} + +func (s *KeywordContext) RANDOMIZED() antlr.TerminalNode { + return s.GetToken(TSqlParserRANDOMIZED, 0) +} + +func (s *KeywordContext) RANGE() antlr.TerminalNode { + return s.GetToken(TSqlParserRANGE, 0) +} + +func (s *KeywordContext) RANK() antlr.TerminalNode { + return s.GetToken(TSqlParserRANK, 0) +} + +func (s *KeywordContext) RC2() antlr.TerminalNode { + return s.GetToken(TSqlParserRC2, 0) +} + +func (s *KeywordContext) RC4() antlr.TerminalNode { + return s.GetToken(TSqlParserRC4, 0) +} + +func (s *KeywordContext) RC4_128() antlr.TerminalNode { + return s.GetToken(TSqlParserRC4_128, 0) +} + +func (s *KeywordContext) READ_COMMITTED_SNAPSHOT() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_COMMITTED_SNAPSHOT, 0) +} + +func (s *KeywordContext) READ_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_ONLY, 0) +} + +func (s *KeywordContext) READ_ONLY_ROUTING_LIST() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_ONLY_ROUTING_LIST, 0) +} + +func (s *KeywordContext) READ_WRITE() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_WRITE, 0) +} + +func (s *KeywordContext) READCOMMITTED() antlr.TerminalNode { + return s.GetToken(TSqlParserREADCOMMITTED, 0) +} + +func (s *KeywordContext) READCOMMITTEDLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserREADCOMMITTEDLOCK, 0) +} + +func (s *KeywordContext) READONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserREADONLY, 0) +} + +func (s *KeywordContext) READPAST() antlr.TerminalNode { + return s.GetToken(TSqlParserREADPAST, 0) +} + +func (s *KeywordContext) READUNCOMMITTED() antlr.TerminalNode { + return s.GetToken(TSqlParserREADUNCOMMITTED, 0) +} + +func (s *KeywordContext) READWRITE() antlr.TerminalNode { + return s.GetToken(TSqlParserREADWRITE, 0) +} + +func (s *KeywordContext) REBUILD() antlr.TerminalNode { + return s.GetToken(TSqlParserREBUILD, 0) +} + +func (s *KeywordContext) RECEIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserRECEIVE, 0) +} + +func (s *KeywordContext) RECOMPILE() antlr.TerminalNode { + return s.GetToken(TSqlParserRECOMPILE, 0) +} + +func (s *KeywordContext) RECOVERY() antlr.TerminalNode { + return s.GetToken(TSqlParserRECOVERY, 0) +} + +func (s *KeywordContext) RECURSIVE_TRIGGERS() antlr.TerminalNode { + return s.GetToken(TSqlParserRECURSIVE_TRIGGERS, 0) +} + +func (s *KeywordContext) RELATIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserRELATIVE, 0) +} + +func (s *KeywordContext) REMOTE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOTE, 0) +} + +func (s *KeywordContext) REMOTE_PROC_TRANSACTIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOTE_PROC_TRANSACTIONS, 0) +} + +func (s *KeywordContext) REMOTE_SERVICE_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOTE_SERVICE_NAME, 0) +} + +func (s *KeywordContext) REMOVE() antlr.TerminalNode { + return s.GetToken(TSqlParserREMOVE, 0) +} + +func (s *KeywordContext) REORGANIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserREORGANIZE, 0) +} + +func (s *KeywordContext) REPAIR_ALLOW_DATA_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_ALLOW_DATA_LOSS, 0) +} + +func (s *KeywordContext) REPAIR_FAST() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_FAST, 0) +} + +func (s *KeywordContext) REPAIR_REBUILD() antlr.TerminalNode { + return s.GetToken(TSqlParserREPAIR_REBUILD, 0) +} + +func (s *KeywordContext) REPEATABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserREPEATABLE, 0) +} + +func (s *KeywordContext) REPEATABLEREAD() antlr.TerminalNode { + return s.GetToken(TSqlParserREPEATABLEREAD, 0) +} + +func (s *KeywordContext) REPLACE() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLACE, 0) +} + +func (s *KeywordContext) REPLICA() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLICA, 0) +} + +func (s *KeywordContext) REPLICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserREPLICATE, 0) +} + +func (s *KeywordContext) REQUEST_MAX_CPU_TIME_SEC() antlr.TerminalNode { + return s.GetToken(TSqlParserREQUEST_MAX_CPU_TIME_SEC, 0) +} + +func (s *KeywordContext) REQUEST_MAX_MEMORY_GRANT_PERCENT() antlr.TerminalNode { + return s.GetToken(TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, 0) +} + +func (s *KeywordContext) REQUEST_MEMORY_GRANT_TIMEOUT_SEC() antlr.TerminalNode { + return s.GetToken(TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, 0) +} + +func (s *KeywordContext) REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT() antlr.TerminalNode { + return s.GetToken(TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, 0) +} + +func (s *KeywordContext) RESAMPLE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESAMPLE, 0) +} + +func (s *KeywordContext) RESERVE_DISK_SPACE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESERVE_DISK_SPACE, 0) +} + +func (s *KeywordContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESOURCE, 0) +} + +func (s *KeywordContext) RESOURCE_MANAGER_LOCATION() antlr.TerminalNode { + return s.GetToken(TSqlParserRESOURCE_MANAGER_LOCATION, 0) +} + +func (s *KeywordContext) RESTRICTED_USER() antlr.TerminalNode { + return s.GetToken(TSqlParserRESTRICTED_USER, 0) +} + +func (s *KeywordContext) RESUMABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserRESUMABLE, 0) +} + +func (s *KeywordContext) RETENTION() antlr.TerminalNode { + return s.GetToken(TSqlParserRETENTION, 0) +} + +func (s *KeywordContext) REVERSE() antlr.TerminalNode { + return s.GetToken(TSqlParserREVERSE, 0) +} + +func (s *KeywordContext) ROBUST() antlr.TerminalNode { + return s.GetToken(TSqlParserROBUST, 0) +} + +func (s *KeywordContext) ROOT() antlr.TerminalNode { + return s.GetToken(TSqlParserROOT, 0) +} + +func (s *KeywordContext) ROUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserROUTE, 0) +} + +func (s *KeywordContext) ROW() antlr.TerminalNode { + return s.GetToken(TSqlParserROW, 0) +} + +func (s *KeywordContext) ROW_NUMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserROW_NUMBER, 0) +} + +func (s *KeywordContext) ROWGUID() antlr.TerminalNode { + return s.GetToken(TSqlParserROWGUID, 0) +} + +func (s *KeywordContext) ROWLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserROWLOCK, 0) +} + +func (s *KeywordContext) ROWS() antlr.TerminalNode { + return s.GetToken(TSqlParserROWS, 0) +} + +func (s *KeywordContext) RTRIM() antlr.TerminalNode { + return s.GetToken(TSqlParserRTRIM, 0) +} + +func (s *KeywordContext) SAMPLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSAMPLE, 0) +} + +func (s *KeywordContext) SCHEMA_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA_ID, 0) +} + +func (s *KeywordContext) SCHEMA_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMA_NAME, 0) +} + +func (s *KeywordContext) SCHEMABINDING() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEMABINDING, 0) +} + +func (s *KeywordContext) SCOPE_IDENTITY() antlr.TerminalNode { + return s.GetToken(TSqlParserSCOPE_IDENTITY, 0) +} + +func (s *KeywordContext) SCOPED() antlr.TerminalNode { + return s.GetToken(TSqlParserSCOPED, 0) +} + +func (s *KeywordContext) SCROLL() antlr.TerminalNode { + return s.GetToken(TSqlParserSCROLL, 0) +} + +func (s *KeywordContext) SCROLL_LOCKS() antlr.TerminalNode { + return s.GetToken(TSqlParserSCROLL_LOCKS, 0) +} + +func (s *KeywordContext) SEARCH() antlr.TerminalNode { + return s.GetToken(TSqlParserSEARCH, 0) +} + +func (s *KeywordContext) SECONDARY() antlr.TerminalNode { + return s.GetToken(TSqlParserSECONDARY, 0) +} + +func (s *KeywordContext) SECONDARY_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserSECONDARY_ONLY, 0) +} + +func (s *KeywordContext) SECONDARY_ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSECONDARY_ROLE, 0) +} + +func (s *KeywordContext) SECONDS() antlr.TerminalNode { + return s.GetToken(TSqlParserSECONDS, 0) +} + +func (s *KeywordContext) SECRET() antlr.TerminalNode { + return s.GetToken(TSqlParserSECRET, 0) +} + +func (s *KeywordContext) SECURABLES() antlr.TerminalNode { + return s.GetToken(TSqlParserSECURABLES, 0) +} + +func (s *KeywordContext) SECURITY() antlr.TerminalNode { + return s.GetToken(TSqlParserSECURITY, 0) +} + +func (s *KeywordContext) SECURITY_LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserSECURITY_LOG, 0) +} + +func (s *KeywordContext) SEEDING_MODE() antlr.TerminalNode { + return s.GetToken(TSqlParserSEEDING_MODE, 0) +} + +func (s *KeywordContext) SELF() antlr.TerminalNode { + return s.GetToken(TSqlParserSELF, 0) +} + +func (s *KeywordContext) SEMI_SENSITIVE() antlr.TerminalNode { + return s.GetToken(TSqlParserSEMI_SENSITIVE, 0) +} + +func (s *KeywordContext) SEND() antlr.TerminalNode { + return s.GetToken(TSqlParserSEND, 0) +} + +func (s *KeywordContext) SENT() antlr.TerminalNode { + return s.GetToken(TSqlParserSENT, 0) +} + +func (s *KeywordContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(TSqlParserSEQUENCE, 0) +} + +func (s *KeywordContext) SEQUENCE_NUMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserSEQUENCE_NUMBER, 0) +} + +func (s *KeywordContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERIALIZABLE, 0) +} + +func (s *KeywordContext) SERVERPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVERPROPERTY, 0) +} + +func (s *KeywordContext) SERVICEBROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICEBROKER, 0) +} + +func (s *KeywordContext) SESSIONPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserSESSIONPROPERTY, 0) +} + +func (s *KeywordContext) SESSION_TIMEOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserSESSION_TIMEOUT, 0) +} + +func (s *KeywordContext) SETERROR() antlr.TerminalNode { + return s.GetToken(TSqlParserSETERROR, 0) +} + +func (s *KeywordContext) SHARE() antlr.TerminalNode { + return s.GetToken(TSqlParserSHARE, 0) +} + +func (s *KeywordContext) SHARED() antlr.TerminalNode { + return s.GetToken(TSqlParserSHARED, 0) +} + +func (s *KeywordContext) SHOWCONTIG() antlr.TerminalNode { + return s.GetToken(TSqlParserSHOWCONTIG, 0) +} + +func (s *KeywordContext) SHOWPLAN() antlr.TerminalNode { + return s.GetToken(TSqlParserSHOWPLAN, 0) +} + +func (s *KeywordContext) SHOWPLAN_ALL() antlr.TerminalNode { + return s.GetToken(TSqlParserSHOWPLAN_ALL, 0) +} + +func (s *KeywordContext) SHOWPLAN_TEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserSHOWPLAN_TEXT, 0) +} + +func (s *KeywordContext) SHOWPLAN_XML() antlr.TerminalNode { + return s.GetToken(TSqlParserSHOWPLAN_XML, 0) +} + +func (s *KeywordContext) SIGNATURE() antlr.TerminalNode { + return s.GetToken(TSqlParserSIGNATURE, 0) +} + +func (s *KeywordContext) SIMPLE() antlr.TerminalNode { + return s.GetToken(TSqlParserSIMPLE, 0) +} + +func (s *KeywordContext) SINGLE_USER() antlr.TerminalNode { + return s.GetToken(TSqlParserSINGLE_USER, 0) +} + +func (s *KeywordContext) SIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserSIZE, 0) +} + +func (s *KeywordContext) SMALLINT() antlr.TerminalNode { + return s.GetToken(TSqlParserSMALLINT, 0) +} + +func (s *KeywordContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(TSqlParserSNAPSHOT, 0) +} + +func (s *KeywordContext) SORT_IN_TEMPDB() antlr.TerminalNode { + return s.GetToken(TSqlParserSORT_IN_TEMPDB, 0) +} + +func (s *KeywordContext) SOUNDEX() antlr.TerminalNode { + return s.GetToken(TSqlParserSOUNDEX, 0) +} + +func (s *KeywordContext) SPACE_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserSPACE_KEYWORD, 0) +} + +func (s *KeywordContext) SPARSE() antlr.TerminalNode { + return s.GetToken(TSqlParserSPARSE, 0) +} + +func (s *KeywordContext) SPATIAL_WINDOW_MAX_CELLS() antlr.TerminalNode { + return s.GetToken(TSqlParserSPATIAL_WINDOW_MAX_CELLS, 0) +} + +func (s *KeywordContext) SQL_VARIANT_PROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserSQL_VARIANT_PROPERTY, 0) +} + +func (s *KeywordContext) STANDBY() antlr.TerminalNode { + return s.GetToken(TSqlParserSTANDBY, 0) +} + +func (s *KeywordContext) START_DATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTART_DATE, 0) +} + +func (s *KeywordContext) STATIC() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATIC, 0) +} + +func (s *KeywordContext) STATISTICS_INCREMENTAL() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS_INCREMENTAL, 0) +} + +func (s *KeywordContext) STATISTICS_NORECOMPUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATISTICS_NORECOMPUTE, 0) +} + +func (s *KeywordContext) STATS_DATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATS_DATE, 0) +} + +func (s *KeywordContext) STATS_STREAM() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATS_STREAM, 0) +} + +func (s *KeywordContext) STATUS() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATUS, 0) +} + +func (s *KeywordContext) STATUSONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATUSONLY, 0) +} + +func (s *KeywordContext) STDEV() antlr.TerminalNode { + return s.GetToken(TSqlParserSTDEV, 0) +} + +func (s *KeywordContext) STDEVP() antlr.TerminalNode { + return s.GetToken(TSqlParserSTDEVP, 0) +} + +func (s *KeywordContext) STOPLIST() antlr.TerminalNode { + return s.GetToken(TSqlParserSTOPLIST, 0) +} + +func (s *KeywordContext) STR() antlr.TerminalNode { + return s.GetToken(TSqlParserSTR, 0) +} + +func (s *KeywordContext) STRING_AGG() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING_AGG, 0) +} + +func (s *KeywordContext) STRING_ESCAPE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING_ESCAPE, 0) +} + +func (s *KeywordContext) STUFF() antlr.TerminalNode { + return s.GetToken(TSqlParserSTUFF, 0) +} + +func (s *KeywordContext) SUBJECT() antlr.TerminalNode { + return s.GetToken(TSqlParserSUBJECT, 0) +} + +func (s *KeywordContext) SUBSCRIBE() antlr.TerminalNode { + return s.GetToken(TSqlParserSUBSCRIBE, 0) +} + +func (s *KeywordContext) SUBSCRIPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserSUBSCRIPTION, 0) +} + +func (s *KeywordContext) SUBSTRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSUBSTRING, 0) +} + +func (s *KeywordContext) SUM() antlr.TerminalNode { + return s.GetToken(TSqlParserSUM, 0) +} + +func (s *KeywordContext) SUSER_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserSUSER_ID, 0) +} + +func (s *KeywordContext) SUSER_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserSUSER_NAME, 0) +} + +func (s *KeywordContext) SUSER_SID() antlr.TerminalNode { + return s.GetToken(TSqlParserSUSER_SID, 0) +} + +func (s *KeywordContext) SUSER_SNAME() antlr.TerminalNode { + return s.GetToken(TSqlParserSUSER_SNAME, 0) +} + +func (s *KeywordContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(TSqlParserSUSPEND, 0) +} + +func (s *KeywordContext) SYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserSYMMETRIC, 0) +} + +func (s *KeywordContext) SYNCHRONOUS_COMMIT() antlr.TerminalNode { + return s.GetToken(TSqlParserSYNCHRONOUS_COMMIT, 0) +} + +func (s *KeywordContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(TSqlParserSYNONYM, 0) +} + +func (s *KeywordContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(TSqlParserSYSTEM, 0) +} + +func (s *KeywordContext) TABLERESULTS() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLERESULTS, 0) +} + +func (s *KeywordContext) TABLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLOCK, 0) +} + +func (s *KeywordContext) TABLOCKX() antlr.TerminalNode { + return s.GetToken(TSqlParserTABLOCKX, 0) +} + +func (s *KeywordContext) TAKE() antlr.TerminalNode { + return s.GetToken(TSqlParserTAKE, 0) +} + +func (s *KeywordContext) TARGET_RECOVERY_TIME() antlr.TerminalNode { + return s.GetToken(TSqlParserTARGET_RECOVERY_TIME, 0) +} + +func (s *KeywordContext) TB() antlr.TerminalNode { + return s.GetToken(TSqlParserTB, 0) +} + +func (s *KeywordContext) TEXTIMAGE_ON() antlr.TerminalNode { + return s.GetToken(TSqlParserTEXTIMAGE_ON, 0) +} + +func (s *KeywordContext) THROW() antlr.TerminalNode { + return s.GetToken(TSqlParserTHROW, 0) +} + +func (s *KeywordContext) TIES() antlr.TerminalNode { + return s.GetToken(TSqlParserTIES, 0) +} + +func (s *KeywordContext) TIME() antlr.TerminalNode { + return s.GetToken(TSqlParserTIME, 0) +} + +func (s *KeywordContext) TIMEOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserTIMEOUT, 0) +} + +func (s *KeywordContext) TIMER() antlr.TerminalNode { + return s.GetToken(TSqlParserTIMER, 0) +} + +func (s *KeywordContext) TINYINT() antlr.TerminalNode { + return s.GetToken(TSqlParserTINYINT, 0) +} + +func (s *KeywordContext) TORN_PAGE_DETECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserTORN_PAGE_DETECTION, 0) +} + +func (s *KeywordContext) TRACKING() antlr.TerminalNode { + return s.GetToken(TSqlParserTRACKING, 0) +} + +func (s *KeywordContext) TRANSACTION_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserTRANSACTION_ID, 0) +} + +func (s *KeywordContext) TRANSFORM_NOISE_WORDS() antlr.TerminalNode { + return s.GetToken(TSqlParserTRANSFORM_NOISE_WORDS, 0) +} + +func (s *KeywordContext) TRANSLATE() antlr.TerminalNode { + return s.GetToken(TSqlParserTRANSLATE, 0) +} + +func (s *KeywordContext) TRIM() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIM, 0) +} + +func (s *KeywordContext) TRIPLE_DES() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIPLE_DES, 0) +} + +func (s *KeywordContext) TRIPLE_DES_3KEY() antlr.TerminalNode { + return s.GetToken(TSqlParserTRIPLE_DES_3KEY, 0) +} + +func (s *KeywordContext) TRUSTWORTHY() antlr.TerminalNode { + return s.GetToken(TSqlParserTRUSTWORTHY, 0) +} + +func (s *KeywordContext) TRY() antlr.TerminalNode { + return s.GetToken(TSqlParserTRY, 0) +} + +func (s *KeywordContext) TSQL() antlr.TerminalNode { + return s.GetToken(TSqlParserTSQL, 0) +} + +func (s *KeywordContext) TWO_DIGIT_YEAR_CUTOFF() antlr.TerminalNode { + return s.GetToken(TSqlParserTWO_DIGIT_YEAR_CUTOFF, 0) +} + +func (s *KeywordContext) TYPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE, 0) +} + +func (s *KeywordContext) TYPE_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE_ID, 0) +} + +func (s *KeywordContext) TYPE_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE_NAME, 0) +} + +func (s *KeywordContext) TYPE_WARNING() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPE_WARNING, 0) +} + +func (s *KeywordContext) TYPEPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserTYPEPROPERTY, 0) +} + +func (s *KeywordContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(TSqlParserUNBOUNDED, 0) +} + +func (s *KeywordContext) UNCOMMITTED() antlr.TerminalNode { + return s.GetToken(TSqlParserUNCOMMITTED, 0) +} + +func (s *KeywordContext) UNICODE() antlr.TerminalNode { + return s.GetToken(TSqlParserUNICODE, 0) +} + +func (s *KeywordContext) UNKNOWN() antlr.TerminalNode { + return s.GetToken(TSqlParserUNKNOWN, 0) +} + +func (s *KeywordContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(TSqlParserUNLIMITED, 0) +} + +func (s *KeywordContext) UNMASK() antlr.TerminalNode { + return s.GetToken(TSqlParserUNMASK, 0) +} + +func (s *KeywordContext) UOW() antlr.TerminalNode { + return s.GetToken(TSqlParserUOW, 0) +} + +func (s *KeywordContext) UPDLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserUPDLOCK, 0) +} + +func (s *KeywordContext) UPPER() antlr.TerminalNode { + return s.GetToken(TSqlParserUPPER, 0) +} + +func (s *KeywordContext) USER_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER_ID, 0) +} + +func (s *KeywordContext) USER_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserUSER_NAME, 0) +} + +func (s *KeywordContext) USING() antlr.TerminalNode { + return s.GetToken(TSqlParserUSING, 0) +} + +func (s *KeywordContext) VALID_XML() antlr.TerminalNode { + return s.GetToken(TSqlParserVALID_XML, 0) +} + +func (s *KeywordContext) VALIDATION() antlr.TerminalNode { + return s.GetToken(TSqlParserVALIDATION, 0) +} + +func (s *KeywordContext) VALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserVALUE, 0) +} + +func (s *KeywordContext) VALUE_SQUARE_BRACKET() antlr.TerminalNode { + return s.GetToken(TSqlParserVALUE_SQUARE_BRACKET, 0) +} + +func (s *KeywordContext) VAR() antlr.TerminalNode { + return s.GetToken(TSqlParserVAR, 0) +} + +func (s *KeywordContext) VARBINARY_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserVARBINARY_KEYWORD, 0) +} + +func (s *KeywordContext) VARP() antlr.TerminalNode { + return s.GetToken(TSqlParserVARP, 0) +} + +func (s *KeywordContext) VERIFY_CLONEDB() antlr.TerminalNode { + return s.GetToken(TSqlParserVERIFY_CLONEDB, 0) +} + +func (s *KeywordContext) VERSION() antlr.TerminalNode { + return s.GetToken(TSqlParserVERSION, 0) +} + +func (s *KeywordContext) VIEW_METADATA() antlr.TerminalNode { + return s.GetToken(TSqlParserVIEW_METADATA, 0) +} + +func (s *KeywordContext) VIEWS() antlr.TerminalNode { + return s.GetToken(TSqlParserVIEWS, 0) +} + +func (s *KeywordContext) WAIT() antlr.TerminalNode { + return s.GetToken(TSqlParserWAIT, 0) +} + +func (s *KeywordContext) WELL_FORMED_XML() antlr.TerminalNode { + return s.GetToken(TSqlParserWELL_FORMED_XML, 0) +} + +func (s *KeywordContext) WITHOUT_ARRAY_WRAPPER() antlr.TerminalNode { + return s.GetToken(TSqlParserWITHOUT_ARRAY_WRAPPER, 0) +} + +func (s *KeywordContext) WORK() antlr.TerminalNode { + return s.GetToken(TSqlParserWORK, 0) +} + +func (s *KeywordContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(TSqlParserWORKLOAD, 0) +} + +func (s *KeywordContext) XLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserXLOCK, 0) +} + +func (s *KeywordContext) XML() antlr.TerminalNode { + return s.GetToken(TSqlParserXML, 0) +} + +func (s *KeywordContext) XML_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserXML_COMPRESSION, 0) +} + +func (s *KeywordContext) XMLDATA() antlr.TerminalNode { + return s.GetToken(TSqlParserXMLDATA, 0) +} + +func (s *KeywordContext) XMLNAMESPACES() antlr.TerminalNode { + return s.GetToken(TSqlParserXMLNAMESPACES, 0) +} + +func (s *KeywordContext) XMLSCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserXMLSCHEMA, 0) +} + +func (s *KeywordContext) XSINIL() antlr.TerminalNode { + return s.GetToken(TSqlParserXSINIL, 0) +} + +func (s *KeywordContext) ZONE() antlr.TerminalNode { + return s.GetToken(TSqlParserZONE, 0) +} + +func (s *KeywordContext) ABORT_AFTER_WAIT() antlr.TerminalNode { + return s.GetToken(TSqlParserABORT_AFTER_WAIT, 0) +} + +func (s *KeywordContext) ABSENT() antlr.TerminalNode { + return s.GetToken(TSqlParserABSENT, 0) +} + +func (s *KeywordContext) ADMINISTER() antlr.TerminalNode { + return s.GetToken(TSqlParserADMINISTER, 0) +} + +func (s *KeywordContext) AES() antlr.TerminalNode { + return s.GetToken(TSqlParserAES, 0) +} + +func (s *KeywordContext) ALLOW_CONNECTIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_CONNECTIONS, 0) +} + +func (s *KeywordContext) ALLOW_MULTIPLE_EVENT_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_MULTIPLE_EVENT_LOSS, 0) +} + +func (s *KeywordContext) ALLOW_SINGLE_EVENT_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserALLOW_SINGLE_EVENT_LOSS, 0) +} + +func (s *KeywordContext) ANONYMOUS() antlr.TerminalNode { + return s.GetToken(TSqlParserANONYMOUS, 0) +} + +func (s *KeywordContext) APPEND() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPEND, 0) +} + +func (s *KeywordContext) APPLICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAPPLICATION, 0) +} + +func (s *KeywordContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(TSqlParserASYMMETRIC, 0) +} + +func (s *KeywordContext) ASYNCHRONOUS_COMMIT() antlr.TerminalNode { + return s.GetToken(TSqlParserASYNCHRONOUS_COMMIT, 0) +} + +func (s *KeywordContext) AUTHENTICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHENTICATE, 0) +} + +func (s *KeywordContext) AUTHENTICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTHENTICATION, 0) +} + +func (s *KeywordContext) AUTOMATED_BACKUP_PREFERENCE() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTOMATED_BACKUP_PREFERENCE, 0) +} + +func (s *KeywordContext) AUTOMATIC() antlr.TerminalNode { + return s.GetToken(TSqlParserAUTOMATIC, 0) +} + +func (s *KeywordContext) AVAILABILITY_MODE() antlr.TerminalNode { + return s.GetToken(TSqlParserAVAILABILITY_MODE, 0) +} + +func (s *KeywordContext) BEFORE() antlr.TerminalNode { + return s.GetToken(TSqlParserBEFORE, 0) +} + +func (s *KeywordContext) BLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserBLOCK, 0) +} + +func (s *KeywordContext) BLOCKERS() antlr.TerminalNode { + return s.GetToken(TSqlParserBLOCKERS, 0) +} + +func (s *KeywordContext) BLOCKSIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserBLOCKSIZE, 0) +} + +func (s *KeywordContext) BLOCKING_HIERARCHY() antlr.TerminalNode { + return s.GetToken(TSqlParserBLOCKING_HIERARCHY, 0) +} + +func (s *KeywordContext) BUFFER() antlr.TerminalNode { + return s.GetToken(TSqlParserBUFFER, 0) +} + +func (s *KeywordContext) BUFFERCOUNT() antlr.TerminalNode { + return s.GetToken(TSqlParserBUFFERCOUNT, 0) +} + +func (s *KeywordContext) CACHE() antlr.TerminalNode { + return s.GetToken(TSqlParserCACHE, 0) +} + +func (s *KeywordContext) CALLED() antlr.TerminalNode { + return s.GetToken(TSqlParserCALLED, 0) +} + +func (s *KeywordContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserCERTIFICATE, 0) +} + +func (s *KeywordContext) CHANGETABLE() antlr.TerminalNode { + return s.GetToken(TSqlParserCHANGETABLE, 0) +} + +func (s *KeywordContext) CHANGES() antlr.TerminalNode { + return s.GetToken(TSqlParserCHANGES, 0) +} + +func (s *KeywordContext) CHECK_POLICY() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECK_POLICY, 0) +} + +func (s *KeywordContext) CHECK_EXPIRATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCHECK_EXPIRATION, 0) +} + +func (s *KeywordContext) CLASSIFIER_FUNCTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCLASSIFIER_FUNCTION, 0) +} + +func (s *KeywordContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(TSqlParserCLUSTER, 0) +} + +func (s *KeywordContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPRESS, 0) +} + +func (s *KeywordContext) COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserCOMPRESSION, 0) +} + +func (s *KeywordContext) CONNECT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONNECT, 0) +} + +func (s *KeywordContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONNECTION, 0) +} + +func (s *KeywordContext) CONFIGURATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONFIGURATION, 0) +} + +func (s *KeywordContext) CONNECTIONPROPERTY() antlr.TerminalNode { + return s.GetToken(TSqlParserCONNECTIONPROPERTY, 0) +} + +func (s *KeywordContext) CONTAINMENT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTAINMENT, 0) +} + +func (s *KeywordContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTEXT, 0) +} + +func (s *KeywordContext) CONTEXT_INFO() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTEXT_INFO, 0) +} + +func (s *KeywordContext) CONTINUE_AFTER_ERROR() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTINUE_AFTER_ERROR, 0) +} + +func (s *KeywordContext) CONTRACT() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTRACT, 0) +} + +func (s *KeywordContext) CONTRACT_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserCONTRACT_NAME, 0) +} + +func (s *KeywordContext) CONVERSATION() antlr.TerminalNode { + return s.GetToken(TSqlParserCONVERSATION, 0) +} + +func (s *KeywordContext) COPY_ONLY() antlr.TerminalNode { + return s.GetToken(TSqlParserCOPY_ONLY, 0) +} + +func (s *KeywordContext) CURRENT_REQUEST_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT_REQUEST_ID, 0) +} + +func (s *KeywordContext) CURRENT_TRANSACTION_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT_TRANSACTION_ID, 0) +} + +func (s *KeywordContext) CYCLE() antlr.TerminalNode { + return s.GetToken(TSqlParserCYCLE, 0) +} + +func (s *KeywordContext) DATA_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA_COMPRESSION, 0) +} + +func (s *KeywordContext) DATA_SOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATA_SOURCE, 0) +} + +func (s *KeywordContext) DATABASE_MIRRORING() antlr.TerminalNode { + return s.GetToken(TSqlParserDATABASE_MIRRORING, 0) +} + +func (s *KeywordContext) DATASPACE() antlr.TerminalNode { + return s.GetToken(TSqlParserDATASPACE, 0) +} + +func (s *KeywordContext) DDL() antlr.TerminalNode { + return s.GetToken(TSqlParserDDL, 0) +} + +func (s *KeywordContext) DECOMPRESS() antlr.TerminalNode { + return s.GetToken(TSqlParserDECOMPRESS, 0) +} + +func (s *KeywordContext) DEFAULT_DATABASE() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_DATABASE, 0) +} + +func (s *KeywordContext) DEFAULT_SCHEMA() antlr.TerminalNode { + return s.GetToken(TSqlParserDEFAULT_SCHEMA, 0) +} + +func (s *KeywordContext) DIAGNOSTICS() antlr.TerminalNode { + return s.GetToken(TSqlParserDIAGNOSTICS, 0) +} + +func (s *KeywordContext) DIFFERENTIAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDIFFERENTIAL, 0) +} + +func (s *KeywordContext) DISTRIBUTION() antlr.TerminalNode { + return s.GetToken(TSqlParserDISTRIBUTION, 0) +} + +func (s *KeywordContext) DTC_SUPPORT() antlr.TerminalNode { + return s.GetToken(TSqlParserDTC_SUPPORT, 0) +} + +func (s *KeywordContext) ENABLED() antlr.TerminalNode { + return s.GetToken(TSqlParserENABLED, 0) +} + +func (s *KeywordContext) ENDPOINT() antlr.TerminalNode { + return s.GetToken(TSqlParserENDPOINT, 0) +} + +func (s *KeywordContext) ERROR() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR, 0) +} + +func (s *KeywordContext) ERROR_LINE() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_LINE, 0) +} + +func (s *KeywordContext) ERROR_MESSAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_MESSAGE, 0) +} + +func (s *KeywordContext) ERROR_NUMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_NUMBER, 0) +} + +func (s *KeywordContext) ERROR_PROCEDURE() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_PROCEDURE, 0) +} + +func (s *KeywordContext) ERROR_SEVERITY() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_SEVERITY, 0) +} + +func (s *KeywordContext) ERROR_STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserERROR_STATE, 0) +} + +func (s *KeywordContext) EVENT() antlr.TerminalNode { + return s.GetToken(TSqlParserEVENT, 0) +} + +func (s *KeywordContext) EVENTDATA() antlr.TerminalNode { + return s.GetToken(TSqlParserEVENTDATA, 0) +} + +func (s *KeywordContext) EVENT_RETENTION_MODE() antlr.TerminalNode { + return s.GetToken(TSqlParserEVENT_RETENTION_MODE, 0) +} + +func (s *KeywordContext) EXECUTABLE_FILE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXECUTABLE_FILE, 0) +} + +func (s *KeywordContext) EXPIREDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserEXPIREDATE, 0) +} + +func (s *KeywordContext) EXTENSION() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTENSION, 0) +} + +func (s *KeywordContext) EXTERNAL_ACCESS() antlr.TerminalNode { + return s.GetToken(TSqlParserEXTERNAL_ACCESS, 0) +} + +func (s *KeywordContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(TSqlParserFAILOVER, 0) +} + +func (s *KeywordContext) FAILURECONDITIONLEVEL() antlr.TerminalNode { + return s.GetToken(TSqlParserFAILURECONDITIONLEVEL, 0) +} + +func (s *KeywordContext) FAN_IN() antlr.TerminalNode { + return s.GetToken(TSqlParserFAN_IN, 0) +} + +func (s *KeywordContext) FILE_SNAPSHOT() antlr.TerminalNode { + return s.GetToken(TSqlParserFILE_SNAPSHOT, 0) +} + +func (s *KeywordContext) FORCESEEK() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCESEEK, 0) +} + +func (s *KeywordContext) FORCE_SERVICE_ALLOW_DATA_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, 0) +} + +func (s *KeywordContext) FORMATMESSAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserFORMATMESSAGE, 0) +} + +func (s *KeywordContext) GET() antlr.TerminalNode { + return s.GetToken(TSqlParserGET, 0) +} + +func (s *KeywordContext) GET_FILESTREAM_TRANSACTION_CONTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, 0) +} + +func (s *KeywordContext) GETANCESTOR() antlr.TerminalNode { + return s.GetToken(TSqlParserGETANCESTOR, 0) +} + +func (s *KeywordContext) GETANSINULL() antlr.TerminalNode { + return s.GetToken(TSqlParserGETANSINULL, 0) +} + +func (s *KeywordContext) GETDESCENDANT() antlr.TerminalNode { + return s.GetToken(TSqlParserGETDESCENDANT, 0) +} + +func (s *KeywordContext) GETLEVEL() antlr.TerminalNode { + return s.GetToken(TSqlParserGETLEVEL, 0) +} + +func (s *KeywordContext) GETREPARENTEDVALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserGETREPARENTEDVALUE, 0) +} + +func (s *KeywordContext) GETROOT() antlr.TerminalNode { + return s.GetToken(TSqlParserGETROOT, 0) +} + +func (s *KeywordContext) GOVERNOR() antlr.TerminalNode { + return s.GetToken(TSqlParserGOVERNOR, 0) +} + +func (s *KeywordContext) HASHED() antlr.TerminalNode { + return s.GetToken(TSqlParserHASHED, 0) +} + +func (s *KeywordContext) HEALTHCHECKTIMEOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserHEALTHCHECKTIMEOUT, 0) +} + +func (s *KeywordContext) HEAP() antlr.TerminalNode { + return s.GetToken(TSqlParserHEAP, 0) +} + +func (s *KeywordContext) HIERARCHYID() antlr.TerminalNode { + return s.GetToken(TSqlParserHIERARCHYID, 0) +} + +func (s *KeywordContext) HOST_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserHOST_ID, 0) +} + +func (s *KeywordContext) HOST_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserHOST_NAME, 0) +} + +func (s *KeywordContext) IIF() antlr.TerminalNode { + return s.GetToken(TSqlParserIIF, 0) +} + +func (s *KeywordContext) IO() antlr.TerminalNode { + return s.GetToken(TSqlParserIO, 0) +} + +func (s *KeywordContext) INCLUDE() antlr.TerminalNode { + return s.GetToken(TSqlParserINCLUDE, 0) +} + +func (s *KeywordContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(TSqlParserINCREMENT, 0) +} + +func (s *KeywordContext) INFINITE() antlr.TerminalNode { + return s.GetToken(TSqlParserINFINITE, 0) +} + +func (s *KeywordContext) INIT() antlr.TerminalNode { + return s.GetToken(TSqlParserINIT, 0) +} + +func (s *KeywordContext) INSTEAD() antlr.TerminalNode { + return s.GetToken(TSqlParserINSTEAD, 0) +} + +func (s *KeywordContext) ISDESCENDANTOF() antlr.TerminalNode { + return s.GetToken(TSqlParserISDESCENDANTOF, 0) +} + +func (s *KeywordContext) ISNULL() antlr.TerminalNode { + return s.GetToken(TSqlParserISNULL, 0) +} + +func (s *KeywordContext) ISNUMERIC() antlr.TerminalNode { + return s.GetToken(TSqlParserISNUMERIC, 0) +} + +func (s *KeywordContext) KERBEROS() antlr.TerminalNode { + return s.GetToken(TSqlParserKERBEROS, 0) +} + +func (s *KeywordContext) KEY_PATH() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY_PATH, 0) +} + +func (s *KeywordContext) KEY_STORE_PROVIDER_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserKEY_STORE_PROVIDER_NAME, 0) +} + +func (s *KeywordContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserLANGUAGE, 0) +} + +func (s *KeywordContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(TSqlParserLIBRARY, 0) +} + +func (s *KeywordContext) LIFETIME() antlr.TerminalNode { + return s.GetToken(TSqlParserLIFETIME, 0) +} + +func (s *KeywordContext) LINKED() antlr.TerminalNode { + return s.GetToken(TSqlParserLINKED, 0) +} + +func (s *KeywordContext) LINUX() antlr.TerminalNode { + return s.GetToken(TSqlParserLINUX, 0) +} + +func (s *KeywordContext) LISTENER_IP() antlr.TerminalNode { + return s.GetToken(TSqlParserLISTENER_IP, 0) +} + +func (s *KeywordContext) LISTENER_PORT() antlr.TerminalNode { + return s.GetToken(TSqlParserLISTENER_PORT, 0) +} + +func (s *KeywordContext) LOCAL_SERVICE_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserLOCAL_SERVICE_NAME, 0) +} + +func (s *KeywordContext) LOG() antlr.TerminalNode { + return s.GetToken(TSqlParserLOG, 0) +} + +func (s *KeywordContext) MASK() antlr.TerminalNode { + return s.GetToken(TSqlParserMASK, 0) +} + +func (s *KeywordContext) MATCHED() antlr.TerminalNode { + return s.GetToken(TSqlParserMATCHED, 0) +} + +func (s *KeywordContext) MASTER() antlr.TerminalNode { + return s.GetToken(TSqlParserMASTER, 0) +} + +func (s *KeywordContext) MAX_MEMORY() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_MEMORY, 0) +} + +func (s *KeywordContext) MAXTRANSFER() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXTRANSFER, 0) +} + +func (s *KeywordContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserMAXVALUE, 0) +} + +func (s *KeywordContext) MAX_DISPATCH_LATENCY() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_DISPATCH_LATENCY, 0) +} + +func (s *KeywordContext) MAX_DURATION() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_DURATION, 0) +} + +func (s *KeywordContext) MAX_EVENT_SIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_EVENT_SIZE, 0) +} + +func (s *KeywordContext) MAX_SIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_SIZE, 0) +} + +func (s *KeywordContext) MAX_OUTSTANDING_IO_PER_VOLUME() antlr.TerminalNode { + return s.GetToken(TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, 0) +} + +func (s *KeywordContext) MEDIADESCRIPTION() antlr.TerminalNode { + return s.GetToken(TSqlParserMEDIADESCRIPTION, 0) +} + +func (s *KeywordContext) MEDIANAME() antlr.TerminalNode { + return s.GetToken(TSqlParserMEDIANAME, 0) +} + +func (s *KeywordContext) MEMBER() antlr.TerminalNode { + return s.GetToken(TSqlParserMEMBER, 0) +} + +func (s *KeywordContext) MEMORY_PARTITION_MODE() antlr.TerminalNode { + return s.GetToken(TSqlParserMEMORY_PARTITION_MODE, 0) +} + +func (s *KeywordContext) MESSAGE_FORWARDING() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE_FORWARDING, 0) +} + +func (s *KeywordContext) MESSAGE_FORWARD_SIZE() antlr.TerminalNode { + return s.GetToken(TSqlParserMESSAGE_FORWARD_SIZE, 0) +} + +func (s *KeywordContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(TSqlParserMINVALUE, 0) +} + +func (s *KeywordContext) MIRROR() antlr.TerminalNode { + return s.GetToken(TSqlParserMIRROR, 0) +} + +func (s *KeywordContext) MUST_CHANGE() antlr.TerminalNode { + return s.GetToken(TSqlParserMUST_CHANGE, 0) +} + +func (s *KeywordContext) NEWID() antlr.TerminalNode { + return s.GetToken(TSqlParserNEWID, 0) +} + +func (s *KeywordContext) NEWSEQUENTIALID() antlr.TerminalNode { + return s.GetToken(TSqlParserNEWSEQUENTIALID, 0) +} + +func (s *KeywordContext) NOFORMAT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOFORMAT, 0) +} + +func (s *KeywordContext) NOINIT() antlr.TerminalNode { + return s.GetToken(TSqlParserNOINIT, 0) +} + +func (s *KeywordContext) NONE() antlr.TerminalNode { + return s.GetToken(TSqlParserNONE, 0) +} + +func (s *KeywordContext) NOREWIND() antlr.TerminalNode { + return s.GetToken(TSqlParserNOREWIND, 0) +} + +func (s *KeywordContext) NOSKIP() antlr.TerminalNode { + return s.GetToken(TSqlParserNOSKIP, 0) +} + +func (s *KeywordContext) NOUNLOAD() antlr.TerminalNode { + return s.GetToken(TSqlParserNOUNLOAD, 0) +} + +func (s *KeywordContext) NO_CHECKSUM() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_CHECKSUM, 0) +} + +func (s *KeywordContext) NO_COMPRESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_COMPRESSION, 0) +} + +func (s *KeywordContext) NO_EVENT_LOSS() antlr.TerminalNode { + return s.GetToken(TSqlParserNO_EVENT_LOSS, 0) +} + +func (s *KeywordContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserNOTIFICATION, 0) +} + +func (s *KeywordContext) NTLM() antlr.TerminalNode { + return s.GetToken(TSqlParserNTLM, 0) +} + +func (s *KeywordContext) OLD_PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserOLD_PASSWORD, 0) +} + +func (s *KeywordContext) ON_FAILURE() antlr.TerminalNode { + return s.GetToken(TSqlParserON_FAILURE, 0) +} + +func (s *KeywordContext) OPERATIONS() antlr.TerminalNode { + return s.GetToken(TSqlParserOPERATIONS, 0) +} + +func (s *KeywordContext) PAGE() antlr.TerminalNode { + return s.GetToken(TSqlParserPAGE, 0) +} + +func (s *KeywordContext) PARAM_NODE() antlr.TerminalNode { + return s.GetToken(TSqlParserPARAM_NODE, 0) +} + +func (s *KeywordContext) PARTIAL() antlr.TerminalNode { + return s.GetToken(TSqlParserPARTIAL, 0) +} + +func (s *KeywordContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserPASSWORD, 0) +} + +func (s *KeywordContext) PERMISSION_SET() antlr.TerminalNode { + return s.GetToken(TSqlParserPERMISSION_SET, 0) +} + +func (s *KeywordContext) PER_CPU() antlr.TerminalNode { + return s.GetToken(TSqlParserPER_CPU, 0) +} + +func (s *KeywordContext) PER_DB() antlr.TerminalNode { + return s.GetToken(TSqlParserPER_DB, 0) +} + +func (s *KeywordContext) PER_NODE() antlr.TerminalNode { + return s.GetToken(TSqlParserPER_NODE, 0) +} + +func (s *KeywordContext) PERSISTED() antlr.TerminalNode { + return s.GetToken(TSqlParserPERSISTED, 0) +} + +func (s *KeywordContext) PLATFORM() antlr.TerminalNode { + return s.GetToken(TSqlParserPLATFORM, 0) +} + +func (s *KeywordContext) POLICY() antlr.TerminalNode { + return s.GetToken(TSqlParserPOLICY, 0) +} + +func (s *KeywordContext) PREDICATE() antlr.TerminalNode { + return s.GetToken(TSqlParserPREDICATE, 0) +} + +func (s *KeywordContext) PROCESS() antlr.TerminalNode { + return s.GetToken(TSqlParserPROCESS, 0) +} + +func (s *KeywordContext) PROFILE() antlr.TerminalNode { + return s.GetToken(TSqlParserPROFILE, 0) +} + +func (s *KeywordContext) PYTHON() antlr.TerminalNode { + return s.GetToken(TSqlParserPYTHON, 0) +} + +func (s *KeywordContext) R() antlr.TerminalNode { + return s.GetToken(TSqlParserR, 0) +} + +func (s *KeywordContext) READ_WRITE_FILEGROUPS() antlr.TerminalNode { + return s.GetToken(TSqlParserREAD_WRITE_FILEGROUPS, 0) +} + +func (s *KeywordContext) REGENERATE() antlr.TerminalNode { + return s.GetToken(TSqlParserREGENERATE, 0) +} + +func (s *KeywordContext) RELATED_CONVERSATION() antlr.TerminalNode { + return s.GetToken(TSqlParserRELATED_CONVERSATION, 0) +} + +func (s *KeywordContext) RELATED_CONVERSATION_GROUP() antlr.TerminalNode { + return s.GetToken(TSqlParserRELATED_CONVERSATION_GROUP, 0) +} + +func (s *KeywordContext) REQUIRED() antlr.TerminalNode { + return s.GetToken(TSqlParserREQUIRED, 0) +} + +func (s *KeywordContext) RESET() antlr.TerminalNode { + return s.GetToken(TSqlParserRESET, 0) +} + +func (s *KeywordContext) RESOURCES() antlr.TerminalNode { + return s.GetToken(TSqlParserRESOURCES, 0) +} + +func (s *KeywordContext) RESTART() antlr.TerminalNode { + return s.GetToken(TSqlParserRESTART, 0) +} + +func (s *KeywordContext) RESUME() antlr.TerminalNode { + return s.GetToken(TSqlParserRESUME, 0) +} + +func (s *KeywordContext) RETAINDAYS() antlr.TerminalNode { + return s.GetToken(TSqlParserRETAINDAYS, 0) +} + +func (s *KeywordContext) RETURNS() antlr.TerminalNode { + return s.GetToken(TSqlParserRETURNS, 0) +} + +func (s *KeywordContext) REWIND() antlr.TerminalNode { + return s.GetToken(TSqlParserREWIND, 0) +} + +func (s *KeywordContext) ROLE() antlr.TerminalNode { + return s.GetToken(TSqlParserROLE, 0) +} + +func (s *KeywordContext) ROUND_ROBIN() antlr.TerminalNode { + return s.GetToken(TSqlParserROUND_ROBIN, 0) +} + +func (s *KeywordContext) ROWCOUNT_BIG() antlr.TerminalNode { + return s.GetToken(TSqlParserROWCOUNT_BIG, 0) +} + +func (s *KeywordContext) RSA_512() antlr.TerminalNode { + return s.GetToken(TSqlParserRSA_512, 0) +} + +func (s *KeywordContext) RSA_1024() antlr.TerminalNode { + return s.GetToken(TSqlParserRSA_1024, 0) +} + +func (s *KeywordContext) RSA_2048() antlr.TerminalNode { + return s.GetToken(TSqlParserRSA_2048, 0) +} + +func (s *KeywordContext) RSA_3072() antlr.TerminalNode { + return s.GetToken(TSqlParserRSA_3072, 0) +} + +func (s *KeywordContext) RSA_4096() antlr.TerminalNode { + return s.GetToken(TSqlParserRSA_4096, 0) +} + +func (s *KeywordContext) SAFETY() antlr.TerminalNode { + return s.GetToken(TSqlParserSAFETY, 0) +} + +func (s *KeywordContext) SAFE() antlr.TerminalNode { + return s.GetToken(TSqlParserSAFE, 0) +} + +func (s *KeywordContext) SCHEDULER() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEDULER, 0) +} + +func (s *KeywordContext) SCHEME() antlr.TerminalNode { + return s.GetToken(TSqlParserSCHEME, 0) +} + +func (s *KeywordContext) SCRIPT() antlr.TerminalNode { + return s.GetToken(TSqlParserSCRIPT, 0) +} + +func (s *KeywordContext) SERVER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVER, 0) +} + +func (s *KeywordContext) SERVICE() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE, 0) +} + +func (s *KeywordContext) SERVICE_BROKER() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE_BROKER, 0) +} + +func (s *KeywordContext) SERVICE_NAME() antlr.TerminalNode { + return s.GetToken(TSqlParserSERVICE_NAME, 0) +} + +func (s *KeywordContext) SESSION() antlr.TerminalNode { + return s.GetToken(TSqlParserSESSION, 0) +} + +func (s *KeywordContext) SESSION_CONTEXT() antlr.TerminalNode { + return s.GetToken(TSqlParserSESSION_CONTEXT, 0) +} + +func (s *KeywordContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(TSqlParserSETTINGS, 0) +} + +func (s *KeywordContext) SHRINKLOG() antlr.TerminalNode { + return s.GetToken(TSqlParserSHRINKLOG, 0) +} + +func (s *KeywordContext) SID() antlr.TerminalNode { + return s.GetToken(TSqlParserSID, 0) +} + +func (s *KeywordContext) SKIP_KEYWORD() antlr.TerminalNode { + return s.GetToken(TSqlParserSKIP_KEYWORD, 0) +} + +func (s *KeywordContext) SOFTNUMA() antlr.TerminalNode { + return s.GetToken(TSqlParserSOFTNUMA, 0) +} + +func (s *KeywordContext) SOURCE() antlr.TerminalNode { + return s.GetToken(TSqlParserSOURCE, 0) +} + +func (s *KeywordContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(TSqlParserSPECIFICATION, 0) +} + +func (s *KeywordContext) SPLIT() antlr.TerminalNode { + return s.GetToken(TSqlParserSPLIT, 0) +} + +func (s *KeywordContext) SQL() antlr.TerminalNode { + return s.GetToken(TSqlParserSQL, 0) +} + +func (s *KeywordContext) SQLDUMPERFLAGS() antlr.TerminalNode { + return s.GetToken(TSqlParserSQLDUMPERFLAGS, 0) +} + +func (s *KeywordContext) SQLDUMPERPATH() antlr.TerminalNode { + return s.GetToken(TSqlParserSQLDUMPERPATH, 0) +} + +func (s *KeywordContext) SQLDUMPERTIMEOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserSQLDUMPERTIMEOUT, 0) +} + +func (s *KeywordContext) STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATE, 0) +} + +func (s *KeywordContext) STATS() antlr.TerminalNode { + return s.GetToken(TSqlParserSTATS, 0) +} + +func (s *KeywordContext) START() antlr.TerminalNode { + return s.GetToken(TSqlParserSTART, 0) +} + +func (s *KeywordContext) STARTED() antlr.TerminalNode { + return s.GetToken(TSqlParserSTARTED, 0) +} + +func (s *KeywordContext) STARTUP_STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserSTARTUP_STATE, 0) +} + +func (s *KeywordContext) STOP() antlr.TerminalNode { + return s.GetToken(TSqlParserSTOP, 0) +} + +func (s *KeywordContext) STOPPED() antlr.TerminalNode { + return s.GetToken(TSqlParserSTOPPED, 0) +} + +func (s *KeywordContext) STOP_ON_ERROR() antlr.TerminalNode { + return s.GetToken(TSqlParserSTOP_ON_ERROR, 0) +} + +func (s *KeywordContext) SUPPORTED() antlr.TerminalNode { + return s.GetToken(TSqlParserSUPPORTED, 0) +} + +func (s *KeywordContext) SWITCH() antlr.TerminalNode { + return s.GetToken(TSqlParserSWITCH, 0) +} + +func (s *KeywordContext) TAPE() antlr.TerminalNode { + return s.GetToken(TSqlParserTAPE, 0) +} + +func (s *KeywordContext) TARGET() antlr.TerminalNode { + return s.GetToken(TSqlParserTARGET, 0) +} + +func (s *KeywordContext) TCP() antlr.TerminalNode { + return s.GetToken(TSqlParserTCP, 0) +} + +func (s *KeywordContext) TOSTRING() antlr.TerminalNode { + return s.GetToken(TSqlParserTOSTRING, 0) +} + +func (s *KeywordContext) TRACE() antlr.TerminalNode { + return s.GetToken(TSqlParserTRACE, 0) +} + +func (s *KeywordContext) TRACK_CAUSALITY() antlr.TerminalNode { + return s.GetToken(TSqlParserTRACK_CAUSALITY, 0) +} + +func (s *KeywordContext) TRANSFER() antlr.TerminalNode { + return s.GetToken(TSqlParserTRANSFER, 0) +} + +func (s *KeywordContext) UNCHECKED() antlr.TerminalNode { + return s.GetToken(TSqlParserUNCHECKED, 0) +} + +func (s *KeywordContext) UNLOCK() antlr.TerminalNode { + return s.GetToken(TSqlParserUNLOCK, 0) +} + +func (s *KeywordContext) UNSAFE() antlr.TerminalNode { + return s.GetToken(TSqlParserUNSAFE, 0) +} + +func (s *KeywordContext) URL() antlr.TerminalNode { + return s.GetToken(TSqlParserURL, 0) +} + +func (s *KeywordContext) USED() antlr.TerminalNode { + return s.GetToken(TSqlParserUSED, 0) +} + +func (s *KeywordContext) VERBOSELOGGING() antlr.TerminalNode { + return s.GetToken(TSqlParserVERBOSELOGGING, 0) +} + +func (s *KeywordContext) VISIBILITY() antlr.TerminalNode { + return s.GetToken(TSqlParserVISIBILITY, 0) +} + +func (s *KeywordContext) WAIT_AT_LOW_PRIORITY() antlr.TerminalNode { + return s.GetToken(TSqlParserWAIT_AT_LOW_PRIORITY, 0) +} + +func (s *KeywordContext) WINDOWS() antlr.TerminalNode { + return s.GetToken(TSqlParserWINDOWS, 0) +} + +func (s *KeywordContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(TSqlParserWITHOUT, 0) +} + +func (s *KeywordContext) WITNESS() antlr.TerminalNode { + return s.GetToken(TSqlParserWITNESS, 0) +} + +func (s *KeywordContext) XACT_ABORT() antlr.TerminalNode { + return s.GetToken(TSqlParserXACT_ABORT, 0) +} + +func (s *KeywordContext) XACT_STATE() antlr.TerminalNode { + return s.GetToken(TSqlParserXACT_STATE, 0) +} + +func (s *KeywordContext) ABS() antlr.TerminalNode { + return s.GetToken(TSqlParserABS, 0) +} + +func (s *KeywordContext) ACOS() antlr.TerminalNode { + return s.GetToken(TSqlParserACOS, 0) +} + +func (s *KeywordContext) ASIN() antlr.TerminalNode { + return s.GetToken(TSqlParserASIN, 0) +} + +func (s *KeywordContext) ATAN() antlr.TerminalNode { + return s.GetToken(TSqlParserATAN, 0) +} + +func (s *KeywordContext) ATN2() antlr.TerminalNode { + return s.GetToken(TSqlParserATN2, 0) +} + +func (s *KeywordContext) CEILING() antlr.TerminalNode { + return s.GetToken(TSqlParserCEILING, 0) +} + +func (s *KeywordContext) COS() antlr.TerminalNode { + return s.GetToken(TSqlParserCOS, 0) +} + +func (s *KeywordContext) COT() antlr.TerminalNode { + return s.GetToken(TSqlParserCOT, 0) +} + +func (s *KeywordContext) DEGREES() antlr.TerminalNode { + return s.GetToken(TSqlParserDEGREES, 0) +} + +func (s *KeywordContext) EXP() antlr.TerminalNode { + return s.GetToken(TSqlParserEXP, 0) +} + +func (s *KeywordContext) FLOOR() antlr.TerminalNode { + return s.GetToken(TSqlParserFLOOR, 0) +} + +func (s *KeywordContext) LOG10() antlr.TerminalNode { + return s.GetToken(TSqlParserLOG10, 0) +} + +func (s *KeywordContext) PI() antlr.TerminalNode { + return s.GetToken(TSqlParserPI, 0) +} + +func (s *KeywordContext) POWER() antlr.TerminalNode { + return s.GetToken(TSqlParserPOWER, 0) +} + +func (s *KeywordContext) RADIANS() antlr.TerminalNode { + return s.GetToken(TSqlParserRADIANS, 0) +} + +func (s *KeywordContext) RAND() antlr.TerminalNode { + return s.GetToken(TSqlParserRAND, 0) +} + +func (s *KeywordContext) ROUND() antlr.TerminalNode { + return s.GetToken(TSqlParserROUND, 0) +} + +func (s *KeywordContext) SIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserSIGN, 0) +} + +func (s *KeywordContext) SIN() antlr.TerminalNode { + return s.GetToken(TSqlParserSIN, 0) +} + +func (s *KeywordContext) SQRT() antlr.TerminalNode { + return s.GetToken(TSqlParserSQRT, 0) +} + +func (s *KeywordContext) SQUARE() antlr.TerminalNode { + return s.GetToken(TSqlParserSQUARE, 0) +} + +func (s *KeywordContext) TAN() antlr.TerminalNode { + return s.GetToken(TSqlParserTAN, 0) +} + +func (s *KeywordContext) CURRENT_TIMEZONE() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT_TIMEZONE, 0) +} + +func (s *KeywordContext) CURRENT_TIMEZONE_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserCURRENT_TIMEZONE_ID, 0) +} + +func (s *KeywordContext) DATE_BUCKET() antlr.TerminalNode { + return s.GetToken(TSqlParserDATE_BUCKET, 0) +} + +func (s *KeywordContext) DATEDIFF_BIG() antlr.TerminalNode { + return s.GetToken(TSqlParserDATEDIFF_BIG, 0) +} + +func (s *KeywordContext) DATEFROMPARTS() antlr.TerminalNode { + return s.GetToken(TSqlParserDATEFROMPARTS, 0) +} + +func (s *KeywordContext) DATETIME2FROMPARTS() antlr.TerminalNode { + return s.GetToken(TSqlParserDATETIME2FROMPARTS, 0) +} + +func (s *KeywordContext) DATETIMEFROMPARTS() antlr.TerminalNode { + return s.GetToken(TSqlParserDATETIMEFROMPARTS, 0) +} + +func (s *KeywordContext) DATETIMEOFFSETFROMPARTS() antlr.TerminalNode { + return s.GetToken(TSqlParserDATETIMEOFFSETFROMPARTS, 0) +} + +func (s *KeywordContext) DATETRUNC() antlr.TerminalNode { + return s.GetToken(TSqlParserDATETRUNC, 0) +} + +func (s *KeywordContext) DAY() antlr.TerminalNode { + return s.GetToken(TSqlParserDAY, 0) +} + +func (s *KeywordContext) EOMONTH() antlr.TerminalNode { + return s.GetToken(TSqlParserEOMONTH, 0) +} + +func (s *KeywordContext) ISDATE() antlr.TerminalNode { + return s.GetToken(TSqlParserISDATE, 0) +} + +func (s *KeywordContext) MONTH() antlr.TerminalNode { + return s.GetToken(TSqlParserMONTH, 0) +} + +func (s *KeywordContext) SMALLDATETIMEFROMPARTS() antlr.TerminalNode { + return s.GetToken(TSqlParserSMALLDATETIMEFROMPARTS, 0) +} + +func (s *KeywordContext) SWITCHOFFSET() antlr.TerminalNode { + return s.GetToken(TSqlParserSWITCHOFFSET, 0) +} + +func (s *KeywordContext) SYSDATETIME() antlr.TerminalNode { + return s.GetToken(TSqlParserSYSDATETIME, 0) +} + +func (s *KeywordContext) SYSDATETIMEOFFSET() antlr.TerminalNode { + return s.GetToken(TSqlParserSYSDATETIMEOFFSET, 0) +} + +func (s *KeywordContext) SYSUTCDATETIME() antlr.TerminalNode { + return s.GetToken(TSqlParserSYSUTCDATETIME, 0) +} + +func (s *KeywordContext) TIMEFROMPARTS() antlr.TerminalNode { + return s.GetToken(TSqlParserTIMEFROMPARTS, 0) +} + +func (s *KeywordContext) TODATETIMEOFFSET() antlr.TerminalNode { + return s.GetToken(TSqlParserTODATETIMEOFFSET, 0) +} + +func (s *KeywordContext) YEAR() antlr.TerminalNode { + return s.GetToken(TSqlParserYEAR, 0) +} + +func (s *KeywordContext) QUARTER() antlr.TerminalNode { + return s.GetToken(TSqlParserQUARTER, 0) +} + +func (s *KeywordContext) DAYOFYEAR() antlr.TerminalNode { + return s.GetToken(TSqlParserDAYOFYEAR, 0) +} + +func (s *KeywordContext) WEEK() antlr.TerminalNode { + return s.GetToken(TSqlParserWEEK, 0) +} + +func (s *KeywordContext) HOUR() antlr.TerminalNode { + return s.GetToken(TSqlParserHOUR, 0) +} + +func (s *KeywordContext) MINUTE() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUTE, 0) +} + +func (s *KeywordContext) SECOND() antlr.TerminalNode { + return s.GetToken(TSqlParserSECOND, 0) +} + +func (s *KeywordContext) MILLISECOND() antlr.TerminalNode { + return s.GetToken(TSqlParserMILLISECOND, 0) +} + +func (s *KeywordContext) MICROSECOND() antlr.TerminalNode { + return s.GetToken(TSqlParserMICROSECOND, 0) +} + +func (s *KeywordContext) NANOSECOND() antlr.TerminalNode { + return s.GetToken(TSqlParserNANOSECOND, 0) +} + +func (s *KeywordContext) TZOFFSET() antlr.TerminalNode { + return s.GetToken(TSqlParserTZOFFSET, 0) +} + +func (s *KeywordContext) ISO_WEEK() antlr.TerminalNode { + return s.GetToken(TSqlParserISO_WEEK, 0) +} + +func (s *KeywordContext) WEEKDAY() antlr.TerminalNode { + return s.GetToken(TSqlParserWEEKDAY, 0) +} + +func (s *KeywordContext) YEAR_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserYEAR_ABBR, 0) +} + +func (s *KeywordContext) QUARTER_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserQUARTER_ABBR, 0) +} + +func (s *KeywordContext) MONTH_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserMONTH_ABBR, 0) +} + +func (s *KeywordContext) DAYOFYEAR_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserDAYOFYEAR_ABBR, 0) +} + +func (s *KeywordContext) DAY_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserDAY_ABBR, 0) +} + +func (s *KeywordContext) WEEK_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserWEEK_ABBR, 0) +} + +func (s *KeywordContext) HOUR_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserHOUR_ABBR, 0) +} + +func (s *KeywordContext) MINUTE_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUTE_ABBR, 0) +} + +func (s *KeywordContext) SECOND_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserSECOND_ABBR, 0) +} + +func (s *KeywordContext) MILLISECOND_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserMILLISECOND_ABBR, 0) +} + +func (s *KeywordContext) MICROSECOND_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserMICROSECOND_ABBR, 0) +} + +func (s *KeywordContext) NANOSECOND_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserNANOSECOND_ABBR, 0) +} + +func (s *KeywordContext) TZOFFSET_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserTZOFFSET_ABBR, 0) +} + +func (s *KeywordContext) ISO_WEEK_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserISO_WEEK_ABBR, 0) +} + +func (s *KeywordContext) WEEKDAY_ABBR() antlr.TerminalNode { + return s.GetToken(TSqlParserWEEKDAY_ABBR, 0) +} + +func (s *KeywordContext) SP_EXECUTESQL() antlr.TerminalNode { + return s.GetToken(TSqlParserSP_EXECUTESQL, 0) +} + +func (s *KeywordContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(TSqlParserVARCHAR, 0) +} + +func (s *KeywordContext) NVARCHAR() antlr.TerminalNode { + return s.GetToken(TSqlParserNVARCHAR, 0) +} + +func (s *KeywordContext) PRECISION() antlr.TerminalNode { + return s.GetToken(TSqlParserPRECISION, 0) +} + +func (s *KeywordContext) FILESTREAM_ON() antlr.TerminalNode { + return s.GetToken(TSqlParserFILESTREAM_ON, 0) +} + +func (s *KeywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KeywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterKeyword(s) + } +} + +func (s *KeywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitKeyword(s) + } +} + +func (s *KeywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitKeyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Keyword() (localctx IKeywordContext) { + localctx = NewKeywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1228, TSqlParserRULE_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14577) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-216243322660847650) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-157807131837333521) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-317512638737156129) != 0) || ((int64((_la-193)) & ^0x3f) == 0 && ((int64(1)<<(_la-193))&-2311191033840100417) != 0) || ((int64((_la-258)) & ^0x3f) == 0 && ((int64(1)<<(_la-258))&-4908943387491794949) != 0) || ((int64((_la-323)) & ^0x3f) == 0 && ((int64(1)<<(_la-323))&8681809714895912701) != 0) || ((int64((_la-387)) & ^0x3f) == 0 && ((int64(1)<<(_la-387))&-9501996711150333) != 0) || ((int64((_la-452)) & ^0x3f) == 0 && ((int64(1)<<(_la-452))&4030651293452449775) != 0) || ((int64((_la-518)) & ^0x3f) == 0 && ((int64(1)<<(_la-518))&-576460752303425549) != 0) || ((int64((_la-582)) & ^0x3f) == 0 && ((int64(1)<<(_la-582))&-3458799990519169025) != 0) || ((int64((_la-646)) & ^0x3f) == 0 && ((int64(1)<<(_la-646))&-4612812620623324673) != 0) || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&-4765371633278913537) != 0) || ((int64((_la-774)) & ^0x3f) == 0 && ((int64(1)<<(_la-774))&-676692233365230081) != 0) || ((int64((_la-839)) & ^0x3f) == 0 && ((int64(1)<<(_la-839))&5764591511395823611) != 0) || ((int64((_la-903)) & ^0x3f) == 0 && ((int64(1)<<(_la-903))&-4398114669571) != 0) || ((int64((_la-967)) & ^0x3f) == 0 && ((int64(1)<<(_la-967))&-19213991565897729) != 0) || ((int64((_la-1031)) & ^0x3f) == 0 && ((int64(1)<<(_la-1031))&-9249659856165133) != 0) || ((int64((_la-1095)) & ^0x3f) == 0 && ((int64(1)<<(_la-1095))&-1) != 0) || ((int64((_la-1159)) & ^0x3f) == 0 && ((int64(1)<<(_la-1159))&511) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IId_Context is an interface to support dynamic dispatch. +type IId_Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ID() antlr.TerminalNode + TEMP_ID() antlr.TerminalNode + DOUBLE_QUOTE_ID() antlr.TerminalNode + DOUBLE_QUOTE_BLANK() antlr.TerminalNode + SQUARE_BRACKET_ID() antlr.TerminalNode + Keyword() IKeywordContext + RAW() antlr.TerminalNode + + // IsId_Context differentiates from other interfaces. + IsId_Context() +} + +type Id_Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyId_Context() *Id_Context { + var p = new(Id_Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_id_ + return p +} + +func InitEmptyId_Context(p *Id_Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_id_ +} + +func (*Id_Context) IsId_Context() {} + +func NewId_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Id_Context { + var p = new(Id_Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_id_ + + return p +} + +func (s *Id_Context) GetParser() antlr.Parser { return s.parser } + +func (s *Id_Context) ID() antlr.TerminalNode { + return s.GetToken(TSqlParserID, 0) +} + +func (s *Id_Context) TEMP_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserTEMP_ID, 0) +} + +func (s *Id_Context) DOUBLE_QUOTE_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_QUOTE_ID, 0) +} + +func (s *Id_Context) DOUBLE_QUOTE_BLANK() antlr.TerminalNode { + return s.GetToken(TSqlParserDOUBLE_QUOTE_BLANK, 0) +} + +func (s *Id_Context) SQUARE_BRACKET_ID() antlr.TerminalNode { + return s.GetToken(TSqlParserSQUARE_BRACKET_ID, 0) +} + +func (s *Id_Context) Keyword() IKeywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeywordContext) +} + +func (s *Id_Context) RAW() antlr.TerminalNode { + return s.GetToken(TSqlParserRAW, 0) +} + +func (s *Id_Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Id_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Id_Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterId_(s) + } +} + +func (s *Id_Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitId_(s) + } +} + +func (s *Id_Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitId_(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Id_() (localctx IId_Context) { + localctx = NewId_Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1230, TSqlParserRULE_id_) + p.SetState(14586) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14579) + p.Match(TSqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserTEMP_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14580) + p.Match(TSqlParserTEMP_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDOUBLE_QUOTE_ID: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14581) + p.Match(TSqlParserDOUBLE_QUOTE_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserDOUBLE_QUOTE_BLANK: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14582) + p.Match(TSqlParserDOUBLE_QUOTE_BLANK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserSQUARE_BRACKET_ID: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14583) + p.Match(TSqlParserSQUARE_BRACKET_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14584) + p.Keyword() + } + + case TSqlParserRAW: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(14585) + p.Match(TSqlParserRAW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimple_idContext is an interface to support dynamic dispatch. +type ISimple_idContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ID() antlr.TerminalNode + + // IsSimple_idContext differentiates from other interfaces. + IsSimple_idContext() +} + +type Simple_idContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySimple_idContext() *Simple_idContext { + var p = new(Simple_idContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_simple_id + return p +} + +func InitEmptySimple_idContext(p *Simple_idContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_simple_id +} + +func (*Simple_idContext) IsSimple_idContext() {} + +func NewSimple_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_idContext { + var p = new(Simple_idContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_simple_id + + return p +} + +func (s *Simple_idContext) GetParser() antlr.Parser { return s.parser } + +func (s *Simple_idContext) ID() antlr.TerminalNode { + return s.GetToken(TSqlParserID, 0) +} + +func (s *Simple_idContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Simple_idContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Simple_idContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterSimple_id(s) + } +} + +func (s *Simple_idContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitSimple_id(s) + } +} + +func (s *Simple_idContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitSimple_id(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Simple_id() (localctx ISimple_idContext) { + localctx = NewSimple_idContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1232, TSqlParserRULE_simple_id) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14588) + p.Match(TSqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IId_or_stringContext is an interface to support dynamic dispatch. +type IId_or_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + STRING() antlr.TerminalNode + + // IsId_or_stringContext differentiates from other interfaces. + IsId_or_stringContext() +} + +type Id_or_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyId_or_stringContext() *Id_or_stringContext { + var p = new(Id_or_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_id_or_string + return p +} + +func InitEmptyId_or_stringContext(p *Id_or_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_id_or_string +} + +func (*Id_or_stringContext) IsId_or_stringContext() {} + +func NewId_or_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Id_or_stringContext { + var p = new(Id_or_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_id_or_string + + return p +} + +func (s *Id_or_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Id_or_stringContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Id_or_stringContext) STRING() antlr.TerminalNode { + return s.GetToken(TSqlParserSTRING, 0) +} + +func (s *Id_or_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Id_or_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Id_or_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterId_or_string(s) + } +} + +func (s *Id_or_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitId_or_string(s) + } +} + +func (s *Id_or_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitId_or_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Id_or_string() (localctx IId_or_stringContext) { + localctx = NewId_or_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1234, TSqlParserRULE_id_or_string) + p.SetState(14592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case TSqlParserABORT, TSqlParserABORT_AFTER_WAIT, TSqlParserABSENT, TSqlParserABSOLUTE, TSqlParserACCENT_SENSITIVITY, TSqlParserACCESS, TSqlParserACTION, TSqlParserACTIVATION, TSqlParserACTIVE, TSqlParserADD, TSqlParserADDRESS, TSqlParserADMINISTER, TSqlParserAES, TSqlParserAES_128, TSqlParserAES_192, TSqlParserAES_256, TSqlParserAFFINITY, TSqlParserAFTER, TSqlParserAGGREGATE, TSqlParserALGORITHM, TSqlParserALLOWED, TSqlParserALLOW_CONNECTIONS, TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS, TSqlParserALLOW_MULTIPLE_EVENT_LOSS, TSqlParserALLOW_PAGE_LOCKS, TSqlParserALLOW_ROW_LOCKS, TSqlParserALLOW_SINGLE_EVENT_LOSS, TSqlParserALLOW_SNAPSHOT_ISOLATION, TSqlParserALL_CONSTRAINTS, TSqlParserALL_ERRORMSGS, TSqlParserALL_INDEXES, TSqlParserALL_LEVELS, TSqlParserALWAYS, TSqlParserANONYMOUS, TSqlParserANSI_DEFAULTS, TSqlParserANSI_NULLS, TSqlParserANSI_NULL_DEFAULT, TSqlParserANSI_NULL_DFLT_OFF, TSqlParserANSI_NULL_DFLT_ON, TSqlParserANSI_PADDING, TSqlParserANSI_WARNINGS, TSqlParserAPPEND, TSqlParserAPPLICATION, TSqlParserAPPLICATION_LOG, TSqlParserAPPLOCK_MODE, TSqlParserAPPLOCK_TEST, TSqlParserAPPLY, TSqlParserAPP_NAME, TSqlParserARITHABORT, TSqlParserARITHIGNORE, TSqlParserASCII, TSqlParserASSEMBLY, TSqlParserASSEMBLYPROPERTY, TSqlParserASYMMETRIC, TSqlParserASYNCHRONOUS_COMMIT, TSqlParserAT_KEYWORD, TSqlParserAUDIT, TSqlParserAUDIT_GUID, TSqlParserAUTHENTICATE, TSqlParserAUTHENTICATION, TSqlParserAUTO, TSqlParserAUTOGROW_ALL_FILES, TSqlParserAUTOGROW_SINGLE_FILE, TSqlParserAUTOMATED_BACKUP_PREFERENCE, TSqlParserAUTOMATIC, TSqlParserAUTO_CLEANUP, TSqlParserAUTO_CLOSE, TSqlParserAUTO_CREATE_STATISTICS, TSqlParserAUTO_DROP, TSqlParserAUTO_SHRINK, TSqlParserAUTO_UPDATE_STATISTICS, TSqlParserAUTO_UPDATE_STATISTICS_ASYNC, TSqlParserAVAILABILITY, TSqlParserAVAILABILITY_MODE, TSqlParserAVG, TSqlParserBACKUP_CLONEDB, TSqlParserBACKUP_PRIORITY, TSqlParserBASE64, TSqlParserBEFORE, TSqlParserBEGIN_DIALOG, TSqlParserBIGINT, TSqlParserBINARY_CHECKSUM, TSqlParserBINARY_KEYWORD, TSqlParserBINDING, TSqlParserBLOB_STORAGE, TSqlParserBLOCK, TSqlParserBLOCKERS, TSqlParserBLOCKING_HIERARCHY, TSqlParserBLOCKSIZE, TSqlParserBROKER, TSqlParserBROKER_INSTANCE, TSqlParserBUFFER, TSqlParserBUFFERCOUNT, TSqlParserBULK_LOGGED, TSqlParserCACHE, TSqlParserCALLED, TSqlParserCALLER, TSqlParserCAP_CPU_PERCENT, TSqlParserCAST, TSqlParserCATALOG, TSqlParserCATCH, TSqlParserCERTENCODED, TSqlParserCERTIFICATE, TSqlParserCERTPRIVATEKEY, TSqlParserCERT_ID, TSqlParserCHANGE, TSqlParserCHANGES, TSqlParserCHANGETABLE, TSqlParserCHANGE_RETENTION, TSqlParserCHANGE_TRACKING, TSqlParserCHAR, TSqlParserCHARINDEX, TSqlParserCHECKALLOC, TSqlParserCHECKCATALOG, TSqlParserCHECKCONSTRAINTS, TSqlParserCHECKDB, TSqlParserCHECKFILEGROUP, TSqlParserCHECKSUM, TSqlParserCHECKSUM_AGG, TSqlParserCHECKTABLE, TSqlParserCHECK_EXPIRATION, TSqlParserCHECK_POLICY, TSqlParserCLASSIFIER_FUNCTION, TSqlParserCLEANTABLE, TSqlParserCLEANUP, TSqlParserCLONEDATABASE, TSqlParserCLUSTER, TSqlParserCOLLECTION, TSqlParserCOLUMNPROPERTY, TSqlParserCOLUMNS, TSqlParserCOLUMNSTORE, TSqlParserCOLUMNSTORE_ARCHIVE, TSqlParserCOLUMN_ENCRYPTION_KEY, TSqlParserCOLUMN_MASTER_KEY, TSqlParserCOL_LENGTH, TSqlParserCOL_NAME, TSqlParserCOMMITTED, TSqlParserCOMPATIBILITY_LEVEL, TSqlParserCOMPRESS, TSqlParserCOMPRESSION, TSqlParserCOMPRESSION_DELAY, TSqlParserCOMPRESS_ALL_ROW_GROUPS, TSqlParserCONCAT, TSqlParserCONCAT_NULL_YIELDS_NULL, TSqlParserCONCAT_WS, TSqlParserCONFIGURATION, TSqlParserCONNECT, TSqlParserCONNECTION, TSqlParserCONNECTIONPROPERTY, TSqlParserCONTAINMENT, TSqlParserCONTENT, TSqlParserCONTEXT, TSqlParserCONTEXT_INFO, TSqlParserCONTINUE_AFTER_ERROR, TSqlParserCONTRACT, TSqlParserCONTRACT_NAME, TSqlParserCONTROL, TSqlParserCONVERSATION, TSqlParserCOOKIE, TSqlParserCOPY_ONLY, TSqlParserCOUNT, TSqlParserCOUNTER, TSqlParserCOUNT_BIG, TSqlParserCPU, TSqlParserCREATE_NEW, TSqlParserCREATION_DISPOSITION, TSqlParserCREDENTIAL, TSqlParserCRYPTOGRAPHIC, TSqlParserCUME_DIST, TSqlParserCURRENT_REQUEST_ID, TSqlParserCURRENT_TRANSACTION_ID, TSqlParserCURSOR_CLOSE_ON_COMMIT, TSqlParserCURSOR_DEFAULT, TSqlParserCURSOR_STATUS, TSqlParserCYCLE, TSqlParserDATA, TSqlParserDATABASEPROPERTYEX, TSqlParserDATABASE_MIRRORING, TSqlParserDATABASE_PRINCIPAL_ID, TSqlParserDATALENGTH, TSqlParserDATASPACE, TSqlParserDATA_COMPRESSION, TSqlParserDATA_PURITY, TSqlParserDATA_SOURCE, TSqlParserDATEADD, TSqlParserDATEDIFF, TSqlParserDATENAME, TSqlParserDATEPART, TSqlParserDATE_CORRELATION_OPTIMIZATION, TSqlParserDAYS, TSqlParserDBCC, TSqlParserDBREINDEX, TSqlParserDB_CHAINING, TSqlParserDB_FAILOVER, TSqlParserDB_ID, TSqlParserDB_NAME, TSqlParserDDL, TSqlParserDECOMPRESS, TSqlParserDECRYPTION, TSqlParserDEFAULT_DATABASE, TSqlParserDEFAULT_DOUBLE_QUOTE, TSqlParserDEFAULT_FULLTEXT_LANGUAGE, TSqlParserDEFAULT_LANGUAGE, TSqlParserDEFAULT_SCHEMA, TSqlParserDEFINITION, TSqlParserDELAY, TSqlParserDELAYED_DURABILITY, TSqlParserDELETED, TSqlParserDENSE_RANK, TSqlParserDEPENDENTS, TSqlParserDES, TSqlParserDESCRIPTION, TSqlParserDESX, TSqlParserDETERMINISTIC, TSqlParserDHCP, TSqlParserDIAGNOSTICS, TSqlParserDIALOG, TSqlParserDIFFERENCE, TSqlParserDIFFERENTIAL, TSqlParserDIRECTORY_NAME, TSqlParserDISABLE, TSqlParserDISABLED, TSqlParserDISABLE_BROKER, TSqlParserDISTRIBUTION, TSqlParserDOCUMENT, TSqlParserDROPCLEANBUFFERS, TSqlParserDROP_EXISTING, TSqlParserDTC_SUPPORT, TSqlParserDYNAMIC, TSqlParserELEMENTS, TSqlParserEMERGENCY, TSqlParserEMPTY, TSqlParserENABLE, TSqlParserENABLED, TSqlParserENABLE_BROKER, TSqlParserENCRYPTED, TSqlParserENCRYPTED_VALUE, TSqlParserENCRYPTION, TSqlParserENCRYPTION_TYPE, TSqlParserENDPOINT, TSqlParserENDPOINT_URL, TSqlParserERROR, TSqlParserERROR_BROKER_CONVERSATIONS, TSqlParserERROR_LINE, TSqlParserERROR_MESSAGE, TSqlParserERROR_NUMBER, TSqlParserERROR_PROCEDURE, TSqlParserERROR_SEVERITY, TSqlParserERROR_STATE, TSqlParserESTIMATEONLY, TSqlParserEVENT, TSqlParserEVENTDATA, TSqlParserEVENT_RETENTION_MODE, TSqlParserEXCLUSIVE, TSqlParserEXECUTABLE, TSqlParserEXECUTABLE_FILE, TSqlParserEXIST, TSqlParserEXIST_SQUARE_BRACKET, TSqlParserEXPAND, TSqlParserEXPIREDATE, TSqlParserEXPIRY_DATE, TSqlParserEXPLICIT, TSqlParserEXTENDED_LOGICAL_CHECKS, TSqlParserEXTENSION, TSqlParserEXTERNAL_ACCESS, TSqlParserFAILOVER, TSqlParserFAILOVER_MODE, TSqlParserFAILURE, TSqlParserFAILURECONDITIONLEVEL, TSqlParserFAILURE_CONDITION_LEVEL, TSqlParserFAIL_OPERATION, TSqlParserFAN_IN, TSqlParserFAST, TSqlParserFAST_FORWARD, TSqlParserFILEGROUP, TSqlParserFILEGROUPPROPERTY, TSqlParserFILEGROUP_ID, TSqlParserFILEGROUP_NAME, TSqlParserFILEGROWTH, TSqlParserFILENAME, TSqlParserFILEPATH, TSqlParserFILEPROPERTY, TSqlParserFILEPROPERTYEX, TSqlParserFILESTREAM, TSqlParserFILESTREAM_ON, TSqlParserFILE_ID, TSqlParserFILE_IDEX, TSqlParserFILE_NAME, TSqlParserFILE_SNAPSHOT, TSqlParserFILTER, TSqlParserFIRST, TSqlParserFIRST_VALUE, TSqlParserFMTONLY, TSqlParserFOLLOWING, TSqlParserFORCE, TSqlParserFORCED, TSqlParserFORCEPLAN, TSqlParserFORCESCAN, TSqlParserFORCESEEK, TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS, TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS, TSqlParserFORMAT, TSqlParserFORMATMESSAGE, TSqlParserFORWARD_ONLY, TSqlParserFREE, TSqlParserFULLSCAN, TSqlParserFULLTEXT, TSqlParserFULLTEXTCATALOGPROPERTY, TSqlParserFULLTEXTSERVICEPROPERTY, TSqlParserGB, TSqlParserGENERATED, TSqlParserGET, TSqlParserGETANCESTOR, TSqlParserGETANSINULL, TSqlParserGETDATE, TSqlParserGETDESCENDANT, TSqlParserGETLEVEL, TSqlParserGETREPARENTEDVALUE, TSqlParserGETROOT, TSqlParserGETUTCDATE, TSqlParserGET_FILESTREAM_TRANSACTION_CONTEXT, TSqlParserGLOBAL, TSqlParserGO, TSqlParserGOVERNOR, TSqlParserGREATEST, TSqlParserGROUPING, TSqlParserGROUPING_ID, TSqlParserGROUP_MAX_REQUESTS, TSqlParserHADR, TSqlParserHASH, TSqlParserHASHED, TSqlParserHAS_DBACCESS, TSqlParserHAS_PERMS_BY_NAME, TSqlParserHEALTHCHECKTIMEOUT, TSqlParserHEALTH_CHECK_TIMEOUT, TSqlParserHEAP, TSqlParserHIDDEN_KEYWORD, TSqlParserHIERARCHYID, TSqlParserHIGH, TSqlParserHONOR_BROKER_PRIORITY, TSqlParserHOST_ID, TSqlParserHOST_NAME, TSqlParserHOURS, TSqlParserIDENTITY_VALUE, TSqlParserIDENT_CURRENT, TSqlParserIDENT_INCR, TSqlParserIDENT_SEED, TSqlParserIGNORE_CONSTRAINTS, TSqlParserIGNORE_DUP_KEY, TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, TSqlParserIGNORE_REPLICATED_TABLE_CACHE, TSqlParserIGNORE_TRIGGERS, TSqlParserIIF, TSqlParserIMMEDIATE, TSqlParserIMPERSONATE, TSqlParserIMPLICIT_TRANSACTIONS, TSqlParserIMPORTANCE, TSqlParserINCLUDE, TSqlParserINCLUDE_NULL_VALUES, TSqlParserINCREMENT, TSqlParserINCREMENTAL, TSqlParserINDEXKEY_PROPERTY, TSqlParserINDEXPROPERTY, TSqlParserINDEX_COL, TSqlParserINFINITE, TSqlParserINIT, TSqlParserINITIATOR, TSqlParserINPUT, TSqlParserINSENSITIVE, TSqlParserINSERTED, TSqlParserINSTEAD, TSqlParserINT, TSqlParserIO, TSqlParserIP, TSqlParserISDESCENDANTOF, TSqlParserISJSON, TSqlParserISNULL, TSqlParserISNUMERIC, TSqlParserISOLATION, TSqlParserIS_MEMBER, TSqlParserIS_ROLEMEMBER, TSqlParserIS_SRVROLEMEMBER, TSqlParserJOB, TSqlParserJSON, TSqlParserJSON_ARRAY, TSqlParserJSON_MODIFY, TSqlParserJSON_OBJECT, TSqlParserJSON_PATH_EXISTS, TSqlParserJSON_QUERY, TSqlParserJSON_VALUE, TSqlParserKB, TSqlParserKEEP, TSqlParserKEEPDEFAULTS, TSqlParserKEEPFIXED, TSqlParserKEEPIDENTITY, TSqlParserKERBEROS, TSqlParserKEYS, TSqlParserKEYSET, TSqlParserKEY_PATH, TSqlParserKEY_SOURCE, TSqlParserKEY_STORE_PROVIDER_NAME, TSqlParserLAG, TSqlParserLANGUAGE, TSqlParserLAST, TSqlParserLAST_VALUE, TSqlParserLEAD, TSqlParserLEAST, TSqlParserLEN, TSqlParserLEVEL, TSqlParserLIBRARY, TSqlParserLIFETIME, TSqlParserLINKED, TSqlParserLINUX, TSqlParserLIST, TSqlParserLISTENER, TSqlParserLISTENER_IP, TSqlParserLISTENER_PORT, TSqlParserLISTENER_URL, TSqlParserLOB_COMPACTION, TSqlParserLOCAL, TSqlParserLOCAL_SERVICE_NAME, TSqlParserLOCATION, TSqlParserLOCK, TSqlParserLOCK_ESCALATION, TSqlParserLOG, TSqlParserLOGIN, TSqlParserLOGINPROPERTY, TSqlParserLOOP, TSqlParserLOW, TSqlParserLOWER, TSqlParserLTRIM, TSqlParserMANUAL, TSqlParserMARK, TSqlParserMASK, TSqlParserMASKED, TSqlParserMASTER, TSqlParserMATCHED, TSqlParserMATERIALIZED, TSqlParserMAX, TSqlParserMAXDOP, TSqlParserMAXRECURSION, TSqlParserMAXSIZE, TSqlParserMAXTRANSFER, TSqlParserMAXVALUE, TSqlParserMAX_CPU_PERCENT, TSqlParserMAX_DISPATCH_LATENCY, TSqlParserMAX_DOP, TSqlParserMAX_DURATION, TSqlParserMAX_EVENT_SIZE, TSqlParserMAX_FILES, TSqlParserMAX_IOPS_PER_VOLUME, TSqlParserMAX_MEMORY, TSqlParserMAX_MEMORY_PERCENT, TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME, TSqlParserMAX_PROCESSES, TSqlParserMAX_QUEUE_READERS, TSqlParserMAX_ROLLOVER_FILES, TSqlParserMAX_SIZE, TSqlParserMB, TSqlParserMEDIADESCRIPTION, TSqlParserMEDIANAME, TSqlParserMEDIUM, TSqlParserMEMBER, TSqlParserMEMORY_OPTIMIZED_DATA, TSqlParserMEMORY_PARTITION_MODE, TSqlParserMESSAGE, TSqlParserMESSAGE_FORWARDING, TSqlParserMESSAGE_FORWARD_SIZE, TSqlParserMIN, TSqlParserMINUTES, TSqlParserMINVALUE, TSqlParserMIN_ACTIVE_ROWVERSION, TSqlParserMIN_CPU_PERCENT, TSqlParserMIN_IOPS_PER_VOLUME, TSqlParserMIN_MEMORY_PERCENT, TSqlParserMIRROR, TSqlParserMIRROR_ADDRESS, TSqlParserMIXED_PAGE_ALLOCATION, TSqlParserMODE, TSqlParserMODIFY, TSqlParserMODIFY_SQUARE_BRACKET, TSqlParserMOVE, TSqlParserMULTI_USER, TSqlParserMUST_CHANGE, TSqlParserNAME, TSqlParserNCHAR, TSqlParserNESTED_TRIGGERS, TSqlParserNEWID, TSqlParserNEWNAME, TSqlParserNEWSEQUENTIALID, TSqlParserNEW_ACCOUNT, TSqlParserNEW_BROKER, TSqlParserNEW_PASSWORD, TSqlParserNEXT, TSqlParserNO, TSqlParserNOCOUNT, TSqlParserNODES, TSqlParserNOEXEC, TSqlParserNOEXPAND, TSqlParserNOFORMAT, TSqlParserNOINDEX, TSqlParserNOINIT, TSqlParserNOLOCK, TSqlParserNONE, TSqlParserNON_TRANSACTED_ACCESS, TSqlParserNORECOMPUTE, TSqlParserNORECOVERY, TSqlParserNOREWIND, TSqlParserNOSKIP, TSqlParserNOTIFICATION, TSqlParserNOTIFICATIONS, TSqlParserNOUNLOAD, TSqlParserNOWAIT, TSqlParserNO_CHECKSUM, TSqlParserNO_COMPRESSION, TSqlParserNO_EVENT_LOSS, TSqlParserNO_INFOMSGS, TSqlParserNO_QUERYSTORE, TSqlParserNO_STATISTICS, TSqlParserNO_TRUNCATE, TSqlParserNO_WAIT, TSqlParserNTILE, TSqlParserNTLM, TSqlParserNULL_DOUBLE_QUOTE, TSqlParserNUMANODE, TSqlParserNUMBER, TSqlParserNUMERIC_ROUNDABORT, TSqlParserOBJECT, TSqlParserOBJECTPROPERTY, TSqlParserOBJECTPROPERTYEX, TSqlParserOBJECT_DEFINITION, TSqlParserOBJECT_ID, TSqlParserOBJECT_NAME, TSqlParserOBJECT_SCHEMA_NAME, TSqlParserOFFLINE, TSqlParserOFFSET, TSqlParserOLD_ACCOUNT, TSqlParserOLD_PASSWORD, TSqlParserONLINE, TSqlParserONLY, TSqlParserON_FAILURE, TSqlParserOPENJSON, TSqlParserOPEN_EXISTING, TSqlParserOPERATIONS, TSqlParserOPTIMISTIC, TSqlParserOPTIMIZE, TSqlParserOPTIMIZE_FOR_SEQUENTIAL_KEY, TSqlParserORIGINAL_DB_NAME, TSqlParserORIGINAL_LOGIN, TSqlParserOUT, TSqlParserOUTPUT, TSqlParserOVERRIDE, TSqlParserOWNER, TSqlParserOWNERSHIP, TSqlParserPAD_INDEX, TSqlParserPAGE, TSqlParserPAGECOUNT, TSqlParserPAGE_VERIFY, TSqlParserPAGLOCK, TSqlParserPARAMETERIZATION, TSqlParserPARAM_NODE, TSqlParserPARSENAME, TSqlParserPARSEONLY, TSqlParserPARTIAL, TSqlParserPARTITION, TSqlParserPARTITIONS, TSqlParserPARTNER, TSqlParserPASSWORD, TSqlParserPATH, TSqlParserPATINDEX, TSqlParserPAUSE, TSqlParserPDW_SHOWSPACEUSED, TSqlParserPERCENTILE_CONT, TSqlParserPERCENTILE_DISC, TSqlParserPERCENT_RANK, TSqlParserPERMISSIONS, TSqlParserPERMISSION_SET, TSqlParserPERSISTED, TSqlParserPERSIST_SAMPLE_PERCENT, TSqlParserPER_CPU, TSqlParserPER_DB, TSqlParserPER_NODE, TSqlParserPHYSICAL_ONLY, TSqlParserPLATFORM, TSqlParserPOISON_MESSAGE_HANDLING, TSqlParserPOLICY, TSqlParserPOOL, TSqlParserPORT, TSqlParserPRECEDING, TSqlParserPRECISION, TSqlParserPREDICATE, TSqlParserPRIMARY_ROLE, TSqlParserPRIOR, TSqlParserPRIORITY, TSqlParserPRIORITY_LEVEL, TSqlParserPRIVATE, TSqlParserPRIVATE_KEY, TSqlParserPRIVILEGES, TSqlParserPROCCACHE, TSqlParserPROCEDURE_NAME, TSqlParserPROCESS, TSqlParserPROFILE, TSqlParserPROPERTY, TSqlParserPROVIDER, TSqlParserPROVIDER_KEY_NAME, TSqlParserPWDCOMPARE, TSqlParserPWDENCRYPT, TSqlParserPYTHON, TSqlParserQUERY, TSqlParserQUERY_SQUARE_BRACKET, TSqlParserQUEUE, TSqlParserQUEUE_DELAY, TSqlParserQUOTED_IDENTIFIER, TSqlParserQUOTENAME, TSqlParserR, TSqlParserRANDOMIZED, TSqlParserRANGE, TSqlParserRANK, TSqlParserRAW, TSqlParserRC2, TSqlParserRC4, TSqlParserRC4_128, TSqlParserREADCOMMITTED, TSqlParserREADCOMMITTEDLOCK, TSqlParserREADONLY, TSqlParserREADPAST, TSqlParserREADUNCOMMITTED, TSqlParserREADWRITE, TSqlParserREAD_COMMITTED_SNAPSHOT, TSqlParserREAD_ONLY, TSqlParserREAD_ONLY_ROUTING_LIST, TSqlParserREAD_WRITE, TSqlParserREAD_WRITE_FILEGROUPS, TSqlParserREBUILD, TSqlParserRECEIVE, TSqlParserRECOMPILE, TSqlParserRECOVERY, TSqlParserRECURSIVE_TRIGGERS, TSqlParserREGENERATE, TSqlParserRELATED_CONVERSATION, TSqlParserRELATED_CONVERSATION_GROUP, TSqlParserRELATIVE, TSqlParserREMOTE, TSqlParserREMOTE_PROC_TRANSACTIONS, TSqlParserREMOTE_SERVICE_NAME, TSqlParserREMOVE, TSqlParserREORGANIZE, TSqlParserREPAIR_ALLOW_DATA_LOSS, TSqlParserREPAIR_FAST, TSqlParserREPAIR_REBUILD, TSqlParserREPEATABLE, TSqlParserREPEATABLEREAD, TSqlParserREPLACE, TSqlParserREPLICA, TSqlParserREPLICATE, TSqlParserREQUEST_MAX_CPU_TIME_SEC, TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT, TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC, TSqlParserREQUIRED, TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT, TSqlParserRESAMPLE, TSqlParserRESERVE_DISK_SPACE, TSqlParserRESET, TSqlParserRESOURCE, TSqlParserRESOURCES, TSqlParserRESOURCE_MANAGER_LOCATION, TSqlParserRESTART, TSqlParserRESTRICTED_USER, TSqlParserRESUMABLE, TSqlParserRESUME, TSqlParserRETAINDAYS, TSqlParserRETENTION, TSqlParserRETURNS, TSqlParserREVERSE, TSqlParserREWIND, TSqlParserROBUST, TSqlParserROLE, TSqlParserROOT, TSqlParserROUND_ROBIN, TSqlParserROUTE, TSqlParserROW, TSqlParserROWCOUNT_BIG, TSqlParserROWGUID, TSqlParserROWLOCK, TSqlParserROWS, TSqlParserROW_NUMBER, TSqlParserRSA_1024, TSqlParserRSA_2048, TSqlParserRSA_3072, TSqlParserRSA_4096, TSqlParserRSA_512, TSqlParserRTRIM, TSqlParserSAFE, TSqlParserSAFETY, TSqlParserSAMPLE, TSqlParserSCHEDULER, TSqlParserSCHEMABINDING, TSqlParserSCHEMA_ID, TSqlParserSCHEMA_NAME, TSqlParserSCHEME, TSqlParserSCOPED, TSqlParserSCOPE_IDENTITY, TSqlParserSCRIPT, TSqlParserSCROLL, TSqlParserSCROLL_LOCKS, TSqlParserSEARCH, TSqlParserSECONDARY, TSqlParserSECONDARY_ONLY, TSqlParserSECONDARY_ROLE, TSqlParserSECONDS, TSqlParserSECRET, TSqlParserSECURABLES, TSqlParserSECURITY, TSqlParserSECURITY_LOG, TSqlParserSEEDING_MODE, TSqlParserSELF, TSqlParserSEMI_SENSITIVE, TSqlParserSEND, TSqlParserSENT, TSqlParserSEQUENCE, TSqlParserSEQUENCE_NUMBER, TSqlParserSERIALIZABLE, TSqlParserSERVER, TSqlParserSERVERPROPERTY, TSqlParserSERVICE, TSqlParserSERVICEBROKER, TSqlParserSERVICE_BROKER, TSqlParserSERVICE_NAME, TSqlParserSESSION, TSqlParserSESSIONPROPERTY, TSqlParserSESSION_CONTEXT, TSqlParserSESSION_TIMEOUT, TSqlParserSETERROR, TSqlParserSETTINGS, TSqlParserSHARE, TSqlParserSHARED, TSqlParserSHOWCONTIG, TSqlParserSHOWPLAN, TSqlParserSHOWPLAN_ALL, TSqlParserSHOWPLAN_TEXT, TSqlParserSHOWPLAN_XML, TSqlParserSHRINKLOG, TSqlParserSID, TSqlParserSIGNATURE, TSqlParserSIMPLE, TSqlParserSINGLE_USER, TSqlParserSIZE, TSqlParserSKIP_KEYWORD, TSqlParserSMALLINT, TSqlParserSNAPSHOT, TSqlParserSOFTNUMA, TSqlParserSORT_IN_TEMPDB, TSqlParserSOUNDEX, TSqlParserSOURCE, TSqlParserSPACE_KEYWORD, TSqlParserSPARSE, TSqlParserSPATIAL_WINDOW_MAX_CELLS, TSqlParserSPECIFICATION, TSqlParserSPLIT, TSqlParserSQL, TSqlParserSQLDUMPERFLAGS, TSqlParserSQLDUMPERPATH, TSqlParserSQLDUMPERTIMEOUT, TSqlParserSQL_VARIANT_PROPERTY, TSqlParserSTANDBY, TSqlParserSTART, TSqlParserSTARTED, TSqlParserSTARTUP_STATE, TSqlParserSTART_DATE, TSqlParserSTATE, TSqlParserSTATIC, TSqlParserSTATISTICS_INCREMENTAL, TSqlParserSTATISTICS_NORECOMPUTE, TSqlParserSTATS, TSqlParserSTATS_DATE, TSqlParserSTATS_STREAM, TSqlParserSTATUS, TSqlParserSTATUSONLY, TSqlParserSTDEV, TSqlParserSTDEVP, TSqlParserSTOP, TSqlParserSTOPLIST, TSqlParserSTOPPED, TSqlParserSTOP_ON_ERROR, TSqlParserSTR, TSqlParserSTRING_AGG, TSqlParserSTRING_ESCAPE, TSqlParserSTUFF, TSqlParserSUBJECT, TSqlParserSUBSCRIBE, TSqlParserSUBSCRIPTION, TSqlParserSUBSTRING, TSqlParserSUM, TSqlParserSUPPORTED, TSqlParserSUSER_ID, TSqlParserSUSER_NAME, TSqlParserSUSER_SID, TSqlParserSUSER_SNAME, TSqlParserSUSPEND, TSqlParserSWITCH, TSqlParserSYMMETRIC, TSqlParserSYNCHRONOUS_COMMIT, TSqlParserSYNONYM, TSqlParserSYSTEM, TSqlParserTABLERESULTS, TSqlParserTABLOCK, TSqlParserTABLOCKX, TSqlParserTAKE, TSqlParserTAPE, TSqlParserTARGET, TSqlParserTARGET_RECOVERY_TIME, TSqlParserTB, TSqlParserTCP, TSqlParserTEXTIMAGE_ON, TSqlParserTHROW, TSqlParserTIES, TSqlParserTIME, TSqlParserTIMEOUT, TSqlParserTIMER, TSqlParserTINYINT, TSqlParserTORN_PAGE_DETECTION, TSqlParserTOSTRING, TSqlParserTRACE, TSqlParserTRACKING, TSqlParserTRACK_CAUSALITY, TSqlParserTRANSACTION_ID, TSqlParserTRANSFER, TSqlParserTRANSFORM_NOISE_WORDS, TSqlParserTRANSLATE, TSqlParserTRIM, TSqlParserTRIPLE_DES, TSqlParserTRIPLE_DES_3KEY, TSqlParserTRUSTWORTHY, TSqlParserTRY, TSqlParserTRY_CAST, TSqlParserTSQL, TSqlParserTWO_DIGIT_YEAR_CUTOFF, TSqlParserTYPE, TSqlParserTYPEPROPERTY, TSqlParserTYPE_ID, TSqlParserTYPE_NAME, TSqlParserTYPE_WARNING, TSqlParserUNBOUNDED, TSqlParserUNCHECKED, TSqlParserUNCOMMITTED, TSqlParserUNICODE, TSqlParserUNKNOWN, TSqlParserUNLIMITED, TSqlParserUNLOCK, TSqlParserUNMASK, TSqlParserUNSAFE, TSqlParserUOW, TSqlParserUPDLOCK, TSqlParserUPPER, TSqlParserURL, TSqlParserUSED, TSqlParserUSER_ID, TSqlParserUSER_NAME, TSqlParserUSING, TSqlParserVALIDATION, TSqlParserVALID_XML, TSqlParserVALUE, TSqlParserVALUE_SQUARE_BRACKET, TSqlParserVAR, TSqlParserVARBINARY_KEYWORD, TSqlParserVARP, TSqlParserVERBOSELOGGING, TSqlParserVERIFY_CLONEDB, TSqlParserVERSION, TSqlParserVIEWS, TSqlParserVIEW_METADATA, TSqlParserVISIBILITY, TSqlParserWAIT, TSqlParserWAIT_AT_LOW_PRIORITY, TSqlParserWELL_FORMED_XML, TSqlParserWINDOWS, TSqlParserWITHOUT, TSqlParserWITHOUT_ARRAY_WRAPPER, TSqlParserWITNESS, TSqlParserWORK, TSqlParserWORKLOAD, TSqlParserXACT_ABORT, TSqlParserXACT_STATE, TSqlParserXLOCK, TSqlParserXML, TSqlParserXMLDATA, TSqlParserXMLNAMESPACES, TSqlParserXMLSCHEMA, TSqlParserXML_COMPRESSION, TSqlParserXSINIL, TSqlParserZONE, TSqlParserABS, TSqlParserACOS, TSqlParserASIN, TSqlParserATAN, TSqlParserATN2, TSqlParserCEILING, TSqlParserCOS, TSqlParserCOT, TSqlParserDEGREES, TSqlParserEXP, TSqlParserFLOOR, TSqlParserLOG10, TSqlParserPI, TSqlParserPOWER, TSqlParserRADIANS, TSqlParserRAND, TSqlParserROUND, TSqlParserSIGN, TSqlParserSIN, TSqlParserSQRT, TSqlParserSQUARE, TSqlParserTAN, TSqlParserCURRENT_TIMEZONE, TSqlParserCURRENT_TIMEZONE_ID, TSqlParserDATE_BUCKET, TSqlParserDATEDIFF_BIG, TSqlParserDATEFROMPARTS, TSqlParserDATETIME2FROMPARTS, TSqlParserDATETIMEFROMPARTS, TSqlParserDATETIMEOFFSETFROMPARTS, TSqlParserDATETRUNC, TSqlParserDAY, TSqlParserEOMONTH, TSqlParserISDATE, TSqlParserMONTH, TSqlParserSMALLDATETIMEFROMPARTS, TSqlParserSWITCHOFFSET, TSqlParserSYSDATETIME, TSqlParserSYSDATETIMEOFFSET, TSqlParserSYSUTCDATETIME, TSqlParserTIMEFROMPARTS, TSqlParserTODATETIMEOFFSET, TSqlParserYEAR, TSqlParserQUARTER, TSqlParserDAYOFYEAR, TSqlParserWEEK, TSqlParserHOUR, TSqlParserMINUTE, TSqlParserSECOND, TSqlParserMILLISECOND, TSqlParserMICROSECOND, TSqlParserNANOSECOND, TSqlParserTZOFFSET, TSqlParserISO_WEEK, TSqlParserWEEKDAY, TSqlParserYEAR_ABBR, TSqlParserQUARTER_ABBR, TSqlParserMONTH_ABBR, TSqlParserDAYOFYEAR_ABBR, TSqlParserDAY_ABBR, TSqlParserWEEK_ABBR, TSqlParserHOUR_ABBR, TSqlParserMINUTE_ABBR, TSqlParserSECOND_ABBR, TSqlParserMILLISECOND_ABBR, TSqlParserMICROSECOND_ABBR, TSqlParserNANOSECOND_ABBR, TSqlParserTZOFFSET_ABBR, TSqlParserISO_WEEK_ABBR, TSqlParserWEEKDAY_ABBR, TSqlParserSP_EXECUTESQL, TSqlParserVARCHAR, TSqlParserNVARCHAR, TSqlParserDOUBLE_QUOTE_ID, TSqlParserDOUBLE_QUOTE_BLANK, TSqlParserSQUARE_BRACKET_ID, TSqlParserTEMP_ID, TSqlParserID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14590) + p.Id_() + } + + case TSqlParserSTRING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14591) + p.Match(TSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComparison_operatorContext is an interface to support dynamic dispatch. +type IComparison_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQUAL() antlr.TerminalNode + GREATER() antlr.TerminalNode + LESS() antlr.TerminalNode + EXCLAMATION() antlr.TerminalNode + + // IsComparison_operatorContext differentiates from other interfaces. + IsComparison_operatorContext() +} + +type Comparison_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComparison_operatorContext() *Comparison_operatorContext { + var p = new(Comparison_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_comparison_operator + return p +} + +func InitEmptyComparison_operatorContext(p *Comparison_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_comparison_operator +} + +func (*Comparison_operatorContext) IsComparison_operatorContext() {} + +func NewComparison_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comparison_operatorContext { + var p = new(Comparison_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_comparison_operator + + return p +} + +func (s *Comparison_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Comparison_operatorContext) EQUAL() antlr.TerminalNode { + return s.GetToken(TSqlParserEQUAL, 0) +} + +func (s *Comparison_operatorContext) GREATER() antlr.TerminalNode { + return s.GetToken(TSqlParserGREATER, 0) +} + +func (s *Comparison_operatorContext) LESS() antlr.TerminalNode { + return s.GetToken(TSqlParserLESS, 0) +} + +func (s *Comparison_operatorContext) EXCLAMATION() antlr.TerminalNode { + return s.GetToken(TSqlParserEXCLAMATION, 0) +} + +func (s *Comparison_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Comparison_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Comparison_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterComparison_operator(s) + } +} + +func (s *Comparison_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitComparison_operator(s) + } +} + +func (s *Comparison_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitComparison_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Comparison_operator() (localctx IComparison_operatorContext) { + localctx = NewComparison_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1236, TSqlParserRULE_comparison_operator) + p.SetState(14609) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1846, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14594) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14595) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14596) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14597) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14598) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14599) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14600) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14601) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14602) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(14603) + p.Match(TSqlParserEXCLAMATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14604) + p.Match(TSqlParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(14605) + p.Match(TSqlParserEXCLAMATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14606) + p.Match(TSqlParserGREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(14607) + p.Match(TSqlParserEXCLAMATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14608) + p.Match(TSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssignment_operatorContext is an interface to support dynamic dispatch. +type IAssignment_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PLUS_ASSIGN() antlr.TerminalNode + MINUS_ASSIGN() antlr.TerminalNode + MULT_ASSIGN() antlr.TerminalNode + DIV_ASSIGN() antlr.TerminalNode + MOD_ASSIGN() antlr.TerminalNode + AND_ASSIGN() antlr.TerminalNode + XOR_ASSIGN() antlr.TerminalNode + OR_ASSIGN() antlr.TerminalNode + + // IsAssignment_operatorContext differentiates from other interfaces. + IsAssignment_operatorContext() +} + +type Assignment_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignment_operatorContext() *Assignment_operatorContext { + var p = new(Assignment_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_assignment_operator + return p +} + +func InitEmptyAssignment_operatorContext(p *Assignment_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_assignment_operator +} + +func (*Assignment_operatorContext) IsAssignment_operatorContext() {} + +func NewAssignment_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assignment_operatorContext { + var p = new(Assignment_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_assignment_operator + + return p +} + +func (s *Assignment_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Assignment_operatorContext) PLUS_ASSIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserPLUS_ASSIGN, 0) +} + +func (s *Assignment_operatorContext) MINUS_ASSIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserMINUS_ASSIGN, 0) +} + +func (s *Assignment_operatorContext) MULT_ASSIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserMULT_ASSIGN, 0) +} + +func (s *Assignment_operatorContext) DIV_ASSIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserDIV_ASSIGN, 0) +} + +func (s *Assignment_operatorContext) MOD_ASSIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserMOD_ASSIGN, 0) +} + +func (s *Assignment_operatorContext) AND_ASSIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserAND_ASSIGN, 0) +} + +func (s *Assignment_operatorContext) XOR_ASSIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserXOR_ASSIGN, 0) +} + +func (s *Assignment_operatorContext) OR_ASSIGN() antlr.TerminalNode { + return s.GetToken(TSqlParserOR_ASSIGN, 0) +} + +func (s *Assignment_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Assignment_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Assignment_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterAssignment_operator(s) + } +} + +func (s *Assignment_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitAssignment_operator(s) + } +} + +func (s *Assignment_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitAssignment_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) Assignment_operator() (localctx IAssignment_operatorContext) { + localctx = NewAssignment_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1238, TSqlParserRULE_assignment_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14611) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1192)) & ^0x3f) == 0 && ((int64(1)<<(_la-1192))&255) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFile_sizeContext is an interface to support dynamic dispatch. +type IFile_sizeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECIMAL() antlr.TerminalNode + KB() antlr.TerminalNode + MB() antlr.TerminalNode + GB() antlr.TerminalNode + TB() antlr.TerminalNode + MODULE() antlr.TerminalNode + + // IsFile_sizeContext differentiates from other interfaces. + IsFile_sizeContext() +} + +type File_sizeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_sizeContext() *File_sizeContext { + var p = new(File_sizeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_file_size + return p +} + +func InitEmptyFile_sizeContext(p *File_sizeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = TSqlParserRULE_file_size +} + +func (*File_sizeContext) IsFile_sizeContext() {} + +func NewFile_sizeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_sizeContext { + var p = new(File_sizeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = TSqlParserRULE_file_size + + return p +} + +func (s *File_sizeContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_sizeContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(TSqlParserDECIMAL, 0) +} + +func (s *File_sizeContext) KB() antlr.TerminalNode { + return s.GetToken(TSqlParserKB, 0) +} + +func (s *File_sizeContext) MB() antlr.TerminalNode { + return s.GetToken(TSqlParserMB, 0) +} + +func (s *File_sizeContext) GB() antlr.TerminalNode { + return s.GetToken(TSqlParserGB, 0) +} + +func (s *File_sizeContext) TB() antlr.TerminalNode { + return s.GetToken(TSqlParserTB, 0) +} + +func (s *File_sizeContext) MODULE() antlr.TerminalNode { + return s.GetToken(TSqlParserMODULE, 0) +} + +func (s *File_sizeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_sizeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_sizeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.EnterFile_size(s) + } +} + +func (s *File_sizeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(TSqlParserListener); ok { + listenerT.ExitFile_size(s) + } +} + +func (s *File_sizeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case TSqlParserVisitor: + return t.VisitFile_size(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *TSqlParser) File_size() (localctx IFile_sizeContext) { + localctx = NewFile_sizeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1240, TSqlParserRULE_file_size) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14613) + p.Match(TSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == TSqlParserGB || _la == TSqlParserKB || _la == TSqlParserMB || _la == TSqlParserTB || _la == TSqlParserMODULE { + { + p.SetState(14614) + _la = p.GetTokenStream().LA(1) + + if !(_la == TSqlParserGB || _la == TSqlParserKB || _la == TSqlParserMB || _la == TSqlParserTB || _la == TSqlParserMODULE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +func (p *TSqlParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { + switch ruleIndex { + case 47: + var t *Assembly_optionContext = nil + if localctx != nil { + t = localctx.(*Assembly_optionContext) + } + return p.Assembly_option_Sempred(t, predIndex) + + case 463: + var t *ExpressionContext = nil + if localctx != nil { + t = localctx.(*ExpressionContext) + } + return p.Expression_Sempred(t, predIndex) + + case 475: + var t *Search_conditionContext = nil + if localctx != nil { + t = localctx.(*Search_conditionContext) + } + return p.Search_condition_Sempred(t, predIndex) + + default: + panic("No predicate with index: " + fmt.Sprint(ruleIndex)) + } +} + +func (p *TSqlParser) Assembly_option_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 0: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *TSqlParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 1: + return p.Precpred(p.GetParserRuleContext(), 5) + + case 2: + return p.Precpred(p.GetParserRuleContext(), 4) + + case 3: + return p.Precpred(p.GetParserRuleContext(), 11) + + case 4: + return p.Precpred(p.GetParserRuleContext(), 10) + + case 5: + return p.Precpred(p.GetParserRuleContext(), 9) + + case 6: + return p.Precpred(p.GetParserRuleContext(), 3) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *TSqlParser) Search_condition_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 7: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 8: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} diff --git a/tsql/tsqlparser_base_listener.go b/tsql/tsqlparser_base_listener.go new file mode 100644 index 0000000..cce61af --- /dev/null +++ b/tsql/tsqlparser_base_listener.go @@ -0,0 +1,5239 @@ +// Code generated from TSqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package tsql // TSqlParser +import "github.com/antlr4-go/antlr/v4" + +// BaseTSqlParserListener is a complete listener for a parse tree produced by TSqlParser. +type BaseTSqlParserListener struct{} + +var _ TSqlParserListener = &BaseTSqlParserListener{} + +// VisitTerminal is called when a terminal node is visited. +func (s *BaseTSqlParserListener) VisitTerminal(node antlr.TerminalNode) {} + +// VisitErrorNode is called when an error node is visited. +func (s *BaseTSqlParserListener) VisitErrorNode(node antlr.ErrorNode) {} + +// EnterEveryRule is called when any rule is entered. +func (s *BaseTSqlParserListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} + +// ExitEveryRule is called when any rule is exited. +func (s *BaseTSqlParserListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} + +// EnterTsql_file is called when production tsql_file is entered. +func (s *BaseTSqlParserListener) EnterTsql_file(ctx *Tsql_fileContext) {} + +// ExitTsql_file is called when production tsql_file is exited. +func (s *BaseTSqlParserListener) ExitTsql_file(ctx *Tsql_fileContext) {} + +// EnterBatch_without_go is called when production batch_without_go is entered. +func (s *BaseTSqlParserListener) EnterBatch_without_go(ctx *Batch_without_goContext) {} + +// ExitBatch_without_go is called when production batch_without_go is exited. +func (s *BaseTSqlParserListener) ExitBatch_without_go(ctx *Batch_without_goContext) {} + +// EnterBatch_level_statement is called when production batch_level_statement is entered. +func (s *BaseTSqlParserListener) EnterBatch_level_statement(ctx *Batch_level_statementContext) {} + +// ExitBatch_level_statement is called when production batch_level_statement is exited. +func (s *BaseTSqlParserListener) ExitBatch_level_statement(ctx *Batch_level_statementContext) {} + +// EnterSql_clauses is called when production sql_clauses is entered. +func (s *BaseTSqlParserListener) EnterSql_clauses(ctx *Sql_clausesContext) {} + +// ExitSql_clauses is called when production sql_clauses is exited. +func (s *BaseTSqlParserListener) ExitSql_clauses(ctx *Sql_clausesContext) {} + +// EnterDml_clause is called when production dml_clause is entered. +func (s *BaseTSqlParserListener) EnterDml_clause(ctx *Dml_clauseContext) {} + +// ExitDml_clause is called when production dml_clause is exited. +func (s *BaseTSqlParserListener) ExitDml_clause(ctx *Dml_clauseContext) {} + +// EnterDdl_clause is called when production ddl_clause is entered. +func (s *BaseTSqlParserListener) EnterDdl_clause(ctx *Ddl_clauseContext) {} + +// ExitDdl_clause is called when production ddl_clause is exited. +func (s *BaseTSqlParserListener) ExitDdl_clause(ctx *Ddl_clauseContext) {} + +// EnterBackup_statement is called when production backup_statement is entered. +func (s *BaseTSqlParserListener) EnterBackup_statement(ctx *Backup_statementContext) {} + +// ExitBackup_statement is called when production backup_statement is exited. +func (s *BaseTSqlParserListener) ExitBackup_statement(ctx *Backup_statementContext) {} + +// EnterCfl_statement is called when production cfl_statement is entered. +func (s *BaseTSqlParserListener) EnterCfl_statement(ctx *Cfl_statementContext) {} + +// ExitCfl_statement is called when production cfl_statement is exited. +func (s *BaseTSqlParserListener) ExitCfl_statement(ctx *Cfl_statementContext) {} + +// EnterBlock_statement is called when production block_statement is entered. +func (s *BaseTSqlParserListener) EnterBlock_statement(ctx *Block_statementContext) {} + +// ExitBlock_statement is called when production block_statement is exited. +func (s *BaseTSqlParserListener) ExitBlock_statement(ctx *Block_statementContext) {} + +// EnterBreak_statement is called when production break_statement is entered. +func (s *BaseTSqlParserListener) EnterBreak_statement(ctx *Break_statementContext) {} + +// ExitBreak_statement is called when production break_statement is exited. +func (s *BaseTSqlParserListener) ExitBreak_statement(ctx *Break_statementContext) {} + +// EnterContinue_statement is called when production continue_statement is entered. +func (s *BaseTSqlParserListener) EnterContinue_statement(ctx *Continue_statementContext) {} + +// ExitContinue_statement is called when production continue_statement is exited. +func (s *BaseTSqlParserListener) ExitContinue_statement(ctx *Continue_statementContext) {} + +// EnterGoto_statement is called when production goto_statement is entered. +func (s *BaseTSqlParserListener) EnterGoto_statement(ctx *Goto_statementContext) {} + +// ExitGoto_statement is called when production goto_statement is exited. +func (s *BaseTSqlParserListener) ExitGoto_statement(ctx *Goto_statementContext) {} + +// EnterReturn_statement is called when production return_statement is entered. +func (s *BaseTSqlParserListener) EnterReturn_statement(ctx *Return_statementContext) {} + +// ExitReturn_statement is called when production return_statement is exited. +func (s *BaseTSqlParserListener) ExitReturn_statement(ctx *Return_statementContext) {} + +// EnterIf_statement is called when production if_statement is entered. +func (s *BaseTSqlParserListener) EnterIf_statement(ctx *If_statementContext) {} + +// ExitIf_statement is called when production if_statement is exited. +func (s *BaseTSqlParserListener) ExitIf_statement(ctx *If_statementContext) {} + +// EnterThrow_statement is called when production throw_statement is entered. +func (s *BaseTSqlParserListener) EnterThrow_statement(ctx *Throw_statementContext) {} + +// ExitThrow_statement is called when production throw_statement is exited. +func (s *BaseTSqlParserListener) ExitThrow_statement(ctx *Throw_statementContext) {} + +// EnterThrow_error_number is called when production throw_error_number is entered. +func (s *BaseTSqlParserListener) EnterThrow_error_number(ctx *Throw_error_numberContext) {} + +// ExitThrow_error_number is called when production throw_error_number is exited. +func (s *BaseTSqlParserListener) ExitThrow_error_number(ctx *Throw_error_numberContext) {} + +// EnterThrow_message is called when production throw_message is entered. +func (s *BaseTSqlParserListener) EnterThrow_message(ctx *Throw_messageContext) {} + +// ExitThrow_message is called when production throw_message is exited. +func (s *BaseTSqlParserListener) ExitThrow_message(ctx *Throw_messageContext) {} + +// EnterThrow_state is called when production throw_state is entered. +func (s *BaseTSqlParserListener) EnterThrow_state(ctx *Throw_stateContext) {} + +// ExitThrow_state is called when production throw_state is exited. +func (s *BaseTSqlParserListener) ExitThrow_state(ctx *Throw_stateContext) {} + +// EnterTry_catch_statement is called when production try_catch_statement is entered. +func (s *BaseTSqlParserListener) EnterTry_catch_statement(ctx *Try_catch_statementContext) {} + +// ExitTry_catch_statement is called when production try_catch_statement is exited. +func (s *BaseTSqlParserListener) ExitTry_catch_statement(ctx *Try_catch_statementContext) {} + +// EnterWaitfor_statement is called when production waitfor_statement is entered. +func (s *BaseTSqlParserListener) EnterWaitfor_statement(ctx *Waitfor_statementContext) {} + +// ExitWaitfor_statement is called when production waitfor_statement is exited. +func (s *BaseTSqlParserListener) ExitWaitfor_statement(ctx *Waitfor_statementContext) {} + +// EnterWhile_statement is called when production while_statement is entered. +func (s *BaseTSqlParserListener) EnterWhile_statement(ctx *While_statementContext) {} + +// ExitWhile_statement is called when production while_statement is exited. +func (s *BaseTSqlParserListener) ExitWhile_statement(ctx *While_statementContext) {} + +// EnterPrint_statement is called when production print_statement is entered. +func (s *BaseTSqlParserListener) EnterPrint_statement(ctx *Print_statementContext) {} + +// ExitPrint_statement is called when production print_statement is exited. +func (s *BaseTSqlParserListener) ExitPrint_statement(ctx *Print_statementContext) {} + +// EnterRaiseerror_statement is called when production raiseerror_statement is entered. +func (s *BaseTSqlParserListener) EnterRaiseerror_statement(ctx *Raiseerror_statementContext) {} + +// ExitRaiseerror_statement is called when production raiseerror_statement is exited. +func (s *BaseTSqlParserListener) ExitRaiseerror_statement(ctx *Raiseerror_statementContext) {} + +// EnterEmpty_statement is called when production empty_statement is entered. +func (s *BaseTSqlParserListener) EnterEmpty_statement(ctx *Empty_statementContext) {} + +// ExitEmpty_statement is called when production empty_statement is exited. +func (s *BaseTSqlParserListener) ExitEmpty_statement(ctx *Empty_statementContext) {} + +// EnterAnother_statement is called when production another_statement is entered. +func (s *BaseTSqlParserListener) EnterAnother_statement(ctx *Another_statementContext) {} + +// ExitAnother_statement is called when production another_statement is exited. +func (s *BaseTSqlParserListener) ExitAnother_statement(ctx *Another_statementContext) {} + +// EnterAlter_application_role is called when production alter_application_role is entered. +func (s *BaseTSqlParserListener) EnterAlter_application_role(ctx *Alter_application_roleContext) {} + +// ExitAlter_application_role is called when production alter_application_role is exited. +func (s *BaseTSqlParserListener) ExitAlter_application_role(ctx *Alter_application_roleContext) {} + +// EnterAlter_xml_schema_collection is called when production alter_xml_schema_collection is entered. +func (s *BaseTSqlParserListener) EnterAlter_xml_schema_collection(ctx *Alter_xml_schema_collectionContext) { +} + +// ExitAlter_xml_schema_collection is called when production alter_xml_schema_collection is exited. +func (s *BaseTSqlParserListener) ExitAlter_xml_schema_collection(ctx *Alter_xml_schema_collectionContext) { +} + +// EnterCreate_application_role is called when production create_application_role is entered. +func (s *BaseTSqlParserListener) EnterCreate_application_role(ctx *Create_application_roleContext) {} + +// ExitCreate_application_role is called when production create_application_role is exited. +func (s *BaseTSqlParserListener) ExitCreate_application_role(ctx *Create_application_roleContext) {} + +// EnterDrop_aggregate is called when production drop_aggregate is entered. +func (s *BaseTSqlParserListener) EnterDrop_aggregate(ctx *Drop_aggregateContext) {} + +// ExitDrop_aggregate is called when production drop_aggregate is exited. +func (s *BaseTSqlParserListener) ExitDrop_aggregate(ctx *Drop_aggregateContext) {} + +// EnterDrop_application_role is called when production drop_application_role is entered. +func (s *BaseTSqlParserListener) EnterDrop_application_role(ctx *Drop_application_roleContext) {} + +// ExitDrop_application_role is called when production drop_application_role is exited. +func (s *BaseTSqlParserListener) ExitDrop_application_role(ctx *Drop_application_roleContext) {} + +// EnterAlter_assembly is called when production alter_assembly is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly(ctx *Alter_assemblyContext) {} + +// ExitAlter_assembly is called when production alter_assembly is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly(ctx *Alter_assemblyContext) {} + +// EnterAlter_assembly_start is called when production alter_assembly_start is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_start(ctx *Alter_assembly_startContext) {} + +// ExitAlter_assembly_start is called when production alter_assembly_start is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_start(ctx *Alter_assembly_startContext) {} + +// EnterAlter_assembly_clause is called when production alter_assembly_clause is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_clause(ctx *Alter_assembly_clauseContext) {} + +// ExitAlter_assembly_clause is called when production alter_assembly_clause is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_clause(ctx *Alter_assembly_clauseContext) {} + +// EnterAlter_assembly_from_clause is called when production alter_assembly_from_clause is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_from_clause(ctx *Alter_assembly_from_clauseContext) { +} + +// ExitAlter_assembly_from_clause is called when production alter_assembly_from_clause is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_from_clause(ctx *Alter_assembly_from_clauseContext) { +} + +// EnterAlter_assembly_from_clause_start is called when production alter_assembly_from_clause_start is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_from_clause_start(ctx *Alter_assembly_from_clause_startContext) { +} + +// ExitAlter_assembly_from_clause_start is called when production alter_assembly_from_clause_start is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_from_clause_start(ctx *Alter_assembly_from_clause_startContext) { +} + +// EnterAlter_assembly_drop_clause is called when production alter_assembly_drop_clause is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_drop_clause(ctx *Alter_assembly_drop_clauseContext) { +} + +// ExitAlter_assembly_drop_clause is called when production alter_assembly_drop_clause is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_drop_clause(ctx *Alter_assembly_drop_clauseContext) { +} + +// EnterAlter_assembly_drop_multiple_files is called when production alter_assembly_drop_multiple_files is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_drop_multiple_files(ctx *Alter_assembly_drop_multiple_filesContext) { +} + +// ExitAlter_assembly_drop_multiple_files is called when production alter_assembly_drop_multiple_files is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_drop_multiple_files(ctx *Alter_assembly_drop_multiple_filesContext) { +} + +// EnterAlter_assembly_drop is called when production alter_assembly_drop is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_drop(ctx *Alter_assembly_dropContext) {} + +// ExitAlter_assembly_drop is called when production alter_assembly_drop is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_drop(ctx *Alter_assembly_dropContext) {} + +// EnterAlter_assembly_add_clause is called when production alter_assembly_add_clause is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_add_clause(ctx *Alter_assembly_add_clauseContext) { +} + +// ExitAlter_assembly_add_clause is called when production alter_assembly_add_clause is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_add_clause(ctx *Alter_assembly_add_clauseContext) { +} + +// EnterAlter_asssembly_add_clause_start is called when production alter_asssembly_add_clause_start is entered. +func (s *BaseTSqlParserListener) EnterAlter_asssembly_add_clause_start(ctx *Alter_asssembly_add_clause_startContext) { +} + +// ExitAlter_asssembly_add_clause_start is called when production alter_asssembly_add_clause_start is exited. +func (s *BaseTSqlParserListener) ExitAlter_asssembly_add_clause_start(ctx *Alter_asssembly_add_clause_startContext) { +} + +// EnterAlter_assembly_client_file_clause is called when production alter_assembly_client_file_clause is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_client_file_clause(ctx *Alter_assembly_client_file_clauseContext) { +} + +// ExitAlter_assembly_client_file_clause is called when production alter_assembly_client_file_clause is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_client_file_clause(ctx *Alter_assembly_client_file_clauseContext) { +} + +// EnterAlter_assembly_file_name is called when production alter_assembly_file_name is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_file_name(ctx *Alter_assembly_file_nameContext) { +} + +// ExitAlter_assembly_file_name is called when production alter_assembly_file_name is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_file_name(ctx *Alter_assembly_file_nameContext) {} + +// EnterAlter_assembly_file_bits is called when production alter_assembly_file_bits is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_file_bits(ctx *Alter_assembly_file_bitsContext) { +} + +// ExitAlter_assembly_file_bits is called when production alter_assembly_file_bits is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_file_bits(ctx *Alter_assembly_file_bitsContext) {} + +// EnterAlter_assembly_as is called when production alter_assembly_as is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_as(ctx *Alter_assembly_asContext) {} + +// ExitAlter_assembly_as is called when production alter_assembly_as is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_as(ctx *Alter_assembly_asContext) {} + +// EnterAlter_assembly_with_clause is called when production alter_assembly_with_clause is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_with_clause(ctx *Alter_assembly_with_clauseContext) { +} + +// ExitAlter_assembly_with_clause is called when production alter_assembly_with_clause is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_with_clause(ctx *Alter_assembly_with_clauseContext) { +} + +// EnterAlter_assembly_with is called when production alter_assembly_with is entered. +func (s *BaseTSqlParserListener) EnterAlter_assembly_with(ctx *Alter_assembly_withContext) {} + +// ExitAlter_assembly_with is called when production alter_assembly_with is exited. +func (s *BaseTSqlParserListener) ExitAlter_assembly_with(ctx *Alter_assembly_withContext) {} + +// EnterClient_assembly_specifier is called when production client_assembly_specifier is entered. +func (s *BaseTSqlParserListener) EnterClient_assembly_specifier(ctx *Client_assembly_specifierContext) { +} + +// ExitClient_assembly_specifier is called when production client_assembly_specifier is exited. +func (s *BaseTSqlParserListener) ExitClient_assembly_specifier(ctx *Client_assembly_specifierContext) { +} + +// EnterAssembly_option is called when production assembly_option is entered. +func (s *BaseTSqlParserListener) EnterAssembly_option(ctx *Assembly_optionContext) {} + +// ExitAssembly_option is called when production assembly_option is exited. +func (s *BaseTSqlParserListener) ExitAssembly_option(ctx *Assembly_optionContext) {} + +// EnterNetwork_file_share is called when production network_file_share is entered. +func (s *BaseTSqlParserListener) EnterNetwork_file_share(ctx *Network_file_shareContext) {} + +// ExitNetwork_file_share is called when production network_file_share is exited. +func (s *BaseTSqlParserListener) ExitNetwork_file_share(ctx *Network_file_shareContext) {} + +// EnterNetwork_computer is called when production network_computer is entered. +func (s *BaseTSqlParserListener) EnterNetwork_computer(ctx *Network_computerContext) {} + +// ExitNetwork_computer is called when production network_computer is exited. +func (s *BaseTSqlParserListener) ExitNetwork_computer(ctx *Network_computerContext) {} + +// EnterNetwork_file_start is called when production network_file_start is entered. +func (s *BaseTSqlParserListener) EnterNetwork_file_start(ctx *Network_file_startContext) {} + +// ExitNetwork_file_start is called when production network_file_start is exited. +func (s *BaseTSqlParserListener) ExitNetwork_file_start(ctx *Network_file_startContext) {} + +// EnterFile_path is called when production file_path is entered. +func (s *BaseTSqlParserListener) EnterFile_path(ctx *File_pathContext) {} + +// ExitFile_path is called when production file_path is exited. +func (s *BaseTSqlParserListener) ExitFile_path(ctx *File_pathContext) {} + +// EnterFile_directory_path_separator is called when production file_directory_path_separator is entered. +func (s *BaseTSqlParserListener) EnterFile_directory_path_separator(ctx *File_directory_path_separatorContext) { +} + +// ExitFile_directory_path_separator is called when production file_directory_path_separator is exited. +func (s *BaseTSqlParserListener) ExitFile_directory_path_separator(ctx *File_directory_path_separatorContext) { +} + +// EnterLocal_file is called when production local_file is entered. +func (s *BaseTSqlParserListener) EnterLocal_file(ctx *Local_fileContext) {} + +// ExitLocal_file is called when production local_file is exited. +func (s *BaseTSqlParserListener) ExitLocal_file(ctx *Local_fileContext) {} + +// EnterLocal_drive is called when production local_drive is entered. +func (s *BaseTSqlParserListener) EnterLocal_drive(ctx *Local_driveContext) {} + +// ExitLocal_drive is called when production local_drive is exited. +func (s *BaseTSqlParserListener) ExitLocal_drive(ctx *Local_driveContext) {} + +// EnterMultiple_local_files is called when production multiple_local_files is entered. +func (s *BaseTSqlParserListener) EnterMultiple_local_files(ctx *Multiple_local_filesContext) {} + +// ExitMultiple_local_files is called when production multiple_local_files is exited. +func (s *BaseTSqlParserListener) ExitMultiple_local_files(ctx *Multiple_local_filesContext) {} + +// EnterMultiple_local_file_start is called when production multiple_local_file_start is entered. +func (s *BaseTSqlParserListener) EnterMultiple_local_file_start(ctx *Multiple_local_file_startContext) { +} + +// ExitMultiple_local_file_start is called when production multiple_local_file_start is exited. +func (s *BaseTSqlParserListener) ExitMultiple_local_file_start(ctx *Multiple_local_file_startContext) { +} + +// EnterCreate_assembly is called when production create_assembly is entered. +func (s *BaseTSqlParserListener) EnterCreate_assembly(ctx *Create_assemblyContext) {} + +// ExitCreate_assembly is called when production create_assembly is exited. +func (s *BaseTSqlParserListener) ExitCreate_assembly(ctx *Create_assemblyContext) {} + +// EnterDrop_assembly is called when production drop_assembly is entered. +func (s *BaseTSqlParserListener) EnterDrop_assembly(ctx *Drop_assemblyContext) {} + +// ExitDrop_assembly is called when production drop_assembly is exited. +func (s *BaseTSqlParserListener) ExitDrop_assembly(ctx *Drop_assemblyContext) {} + +// EnterAlter_asymmetric_key is called when production alter_asymmetric_key is entered. +func (s *BaseTSqlParserListener) EnterAlter_asymmetric_key(ctx *Alter_asymmetric_keyContext) {} + +// ExitAlter_asymmetric_key is called when production alter_asymmetric_key is exited. +func (s *BaseTSqlParserListener) ExitAlter_asymmetric_key(ctx *Alter_asymmetric_keyContext) {} + +// EnterAlter_asymmetric_key_start is called when production alter_asymmetric_key_start is entered. +func (s *BaseTSqlParserListener) EnterAlter_asymmetric_key_start(ctx *Alter_asymmetric_key_startContext) { +} + +// ExitAlter_asymmetric_key_start is called when production alter_asymmetric_key_start is exited. +func (s *BaseTSqlParserListener) ExitAlter_asymmetric_key_start(ctx *Alter_asymmetric_key_startContext) { +} + +// EnterAsymmetric_key_option is called when production asymmetric_key_option is entered. +func (s *BaseTSqlParserListener) EnterAsymmetric_key_option(ctx *Asymmetric_key_optionContext) {} + +// ExitAsymmetric_key_option is called when production asymmetric_key_option is exited. +func (s *BaseTSqlParserListener) ExitAsymmetric_key_option(ctx *Asymmetric_key_optionContext) {} + +// EnterAsymmetric_key_option_start is called when production asymmetric_key_option_start is entered. +func (s *BaseTSqlParserListener) EnterAsymmetric_key_option_start(ctx *Asymmetric_key_option_startContext) { +} + +// ExitAsymmetric_key_option_start is called when production asymmetric_key_option_start is exited. +func (s *BaseTSqlParserListener) ExitAsymmetric_key_option_start(ctx *Asymmetric_key_option_startContext) { +} + +// EnterAsymmetric_key_password_change_option is called when production asymmetric_key_password_change_option is entered. +func (s *BaseTSqlParserListener) EnterAsymmetric_key_password_change_option(ctx *Asymmetric_key_password_change_optionContext) { +} + +// ExitAsymmetric_key_password_change_option is called when production asymmetric_key_password_change_option is exited. +func (s *BaseTSqlParserListener) ExitAsymmetric_key_password_change_option(ctx *Asymmetric_key_password_change_optionContext) { +} + +// EnterCreate_asymmetric_key is called when production create_asymmetric_key is entered. +func (s *BaseTSqlParserListener) EnterCreate_asymmetric_key(ctx *Create_asymmetric_keyContext) {} + +// ExitCreate_asymmetric_key is called when production create_asymmetric_key is exited. +func (s *BaseTSqlParserListener) ExitCreate_asymmetric_key(ctx *Create_asymmetric_keyContext) {} + +// EnterDrop_asymmetric_key is called when production drop_asymmetric_key is entered. +func (s *BaseTSqlParserListener) EnterDrop_asymmetric_key(ctx *Drop_asymmetric_keyContext) {} + +// ExitDrop_asymmetric_key is called when production drop_asymmetric_key is exited. +func (s *BaseTSqlParserListener) ExitDrop_asymmetric_key(ctx *Drop_asymmetric_keyContext) {} + +// EnterAlter_authorization is called when production alter_authorization is entered. +func (s *BaseTSqlParserListener) EnterAlter_authorization(ctx *Alter_authorizationContext) {} + +// ExitAlter_authorization is called when production alter_authorization is exited. +func (s *BaseTSqlParserListener) ExitAlter_authorization(ctx *Alter_authorizationContext) {} + +// EnterAuthorization_grantee is called when production authorization_grantee is entered. +func (s *BaseTSqlParserListener) EnterAuthorization_grantee(ctx *Authorization_granteeContext) {} + +// ExitAuthorization_grantee is called when production authorization_grantee is exited. +func (s *BaseTSqlParserListener) ExitAuthorization_grantee(ctx *Authorization_granteeContext) {} + +// EnterEntity_to is called when production entity_to is entered. +func (s *BaseTSqlParserListener) EnterEntity_to(ctx *Entity_toContext) {} + +// ExitEntity_to is called when production entity_to is exited. +func (s *BaseTSqlParserListener) ExitEntity_to(ctx *Entity_toContext) {} + +// EnterColon_colon is called when production colon_colon is entered. +func (s *BaseTSqlParserListener) EnterColon_colon(ctx *Colon_colonContext) {} + +// ExitColon_colon is called when production colon_colon is exited. +func (s *BaseTSqlParserListener) ExitColon_colon(ctx *Colon_colonContext) {} + +// EnterAlter_authorization_start is called when production alter_authorization_start is entered. +func (s *BaseTSqlParserListener) EnterAlter_authorization_start(ctx *Alter_authorization_startContext) { +} + +// ExitAlter_authorization_start is called when production alter_authorization_start is exited. +func (s *BaseTSqlParserListener) ExitAlter_authorization_start(ctx *Alter_authorization_startContext) { +} + +// EnterAlter_authorization_for_sql_database is called when production alter_authorization_for_sql_database is entered. +func (s *BaseTSqlParserListener) EnterAlter_authorization_for_sql_database(ctx *Alter_authorization_for_sql_databaseContext) { +} + +// ExitAlter_authorization_for_sql_database is called when production alter_authorization_for_sql_database is exited. +func (s *BaseTSqlParserListener) ExitAlter_authorization_for_sql_database(ctx *Alter_authorization_for_sql_databaseContext) { +} + +// EnterAlter_authorization_for_azure_dw is called when production alter_authorization_for_azure_dw is entered. +func (s *BaseTSqlParserListener) EnterAlter_authorization_for_azure_dw(ctx *Alter_authorization_for_azure_dwContext) { +} + +// ExitAlter_authorization_for_azure_dw is called when production alter_authorization_for_azure_dw is exited. +func (s *BaseTSqlParserListener) ExitAlter_authorization_for_azure_dw(ctx *Alter_authorization_for_azure_dwContext) { +} + +// EnterAlter_authorization_for_parallel_dw is called when production alter_authorization_for_parallel_dw is entered. +func (s *BaseTSqlParserListener) EnterAlter_authorization_for_parallel_dw(ctx *Alter_authorization_for_parallel_dwContext) { +} + +// ExitAlter_authorization_for_parallel_dw is called when production alter_authorization_for_parallel_dw is exited. +func (s *BaseTSqlParserListener) ExitAlter_authorization_for_parallel_dw(ctx *Alter_authorization_for_parallel_dwContext) { +} + +// EnterClass_type is called when production class_type is entered. +func (s *BaseTSqlParserListener) EnterClass_type(ctx *Class_typeContext) {} + +// ExitClass_type is called when production class_type is exited. +func (s *BaseTSqlParserListener) ExitClass_type(ctx *Class_typeContext) {} + +// EnterClass_type_for_sql_database is called when production class_type_for_sql_database is entered. +func (s *BaseTSqlParserListener) EnterClass_type_for_sql_database(ctx *Class_type_for_sql_databaseContext) { +} + +// ExitClass_type_for_sql_database is called when production class_type_for_sql_database is exited. +func (s *BaseTSqlParserListener) ExitClass_type_for_sql_database(ctx *Class_type_for_sql_databaseContext) { +} + +// EnterClass_type_for_azure_dw is called when production class_type_for_azure_dw is entered. +func (s *BaseTSqlParserListener) EnterClass_type_for_azure_dw(ctx *Class_type_for_azure_dwContext) {} + +// ExitClass_type_for_azure_dw is called when production class_type_for_azure_dw is exited. +func (s *BaseTSqlParserListener) ExitClass_type_for_azure_dw(ctx *Class_type_for_azure_dwContext) {} + +// EnterClass_type_for_parallel_dw is called when production class_type_for_parallel_dw is entered. +func (s *BaseTSqlParserListener) EnterClass_type_for_parallel_dw(ctx *Class_type_for_parallel_dwContext) { +} + +// ExitClass_type_for_parallel_dw is called when production class_type_for_parallel_dw is exited. +func (s *BaseTSqlParserListener) ExitClass_type_for_parallel_dw(ctx *Class_type_for_parallel_dwContext) { +} + +// EnterClass_type_for_grant is called when production class_type_for_grant is entered. +func (s *BaseTSqlParserListener) EnterClass_type_for_grant(ctx *Class_type_for_grantContext) {} + +// ExitClass_type_for_grant is called when production class_type_for_grant is exited. +func (s *BaseTSqlParserListener) ExitClass_type_for_grant(ctx *Class_type_for_grantContext) {} + +// EnterDrop_availability_group is called when production drop_availability_group is entered. +func (s *BaseTSqlParserListener) EnterDrop_availability_group(ctx *Drop_availability_groupContext) {} + +// ExitDrop_availability_group is called when production drop_availability_group is exited. +func (s *BaseTSqlParserListener) ExitDrop_availability_group(ctx *Drop_availability_groupContext) {} + +// EnterAlter_availability_group is called when production alter_availability_group is entered. +func (s *BaseTSqlParserListener) EnterAlter_availability_group(ctx *Alter_availability_groupContext) { +} + +// ExitAlter_availability_group is called when production alter_availability_group is exited. +func (s *BaseTSqlParserListener) ExitAlter_availability_group(ctx *Alter_availability_groupContext) {} + +// EnterAlter_availability_group_start is called when production alter_availability_group_start is entered. +func (s *BaseTSqlParserListener) EnterAlter_availability_group_start(ctx *Alter_availability_group_startContext) { +} + +// ExitAlter_availability_group_start is called when production alter_availability_group_start is exited. +func (s *BaseTSqlParserListener) ExitAlter_availability_group_start(ctx *Alter_availability_group_startContext) { +} + +// EnterAlter_availability_group_options is called when production alter_availability_group_options is entered. +func (s *BaseTSqlParserListener) EnterAlter_availability_group_options(ctx *Alter_availability_group_optionsContext) { +} + +// ExitAlter_availability_group_options is called when production alter_availability_group_options is exited. +func (s *BaseTSqlParserListener) ExitAlter_availability_group_options(ctx *Alter_availability_group_optionsContext) { +} + +// EnterIp_v4_failover is called when production ip_v4_failover is entered. +func (s *BaseTSqlParserListener) EnterIp_v4_failover(ctx *Ip_v4_failoverContext) {} + +// ExitIp_v4_failover is called when production ip_v4_failover is exited. +func (s *BaseTSqlParserListener) ExitIp_v4_failover(ctx *Ip_v4_failoverContext) {} + +// EnterIp_v6_failover is called when production ip_v6_failover is entered. +func (s *BaseTSqlParserListener) EnterIp_v6_failover(ctx *Ip_v6_failoverContext) {} + +// ExitIp_v6_failover is called when production ip_v6_failover is exited. +func (s *BaseTSqlParserListener) ExitIp_v6_failover(ctx *Ip_v6_failoverContext) {} + +// EnterCreate_or_alter_broker_priority is called when production create_or_alter_broker_priority is entered. +func (s *BaseTSqlParserListener) EnterCreate_or_alter_broker_priority(ctx *Create_or_alter_broker_priorityContext) { +} + +// ExitCreate_or_alter_broker_priority is called when production create_or_alter_broker_priority is exited. +func (s *BaseTSqlParserListener) ExitCreate_or_alter_broker_priority(ctx *Create_or_alter_broker_priorityContext) { +} + +// EnterDrop_broker_priority is called when production drop_broker_priority is entered. +func (s *BaseTSqlParserListener) EnterDrop_broker_priority(ctx *Drop_broker_priorityContext) {} + +// ExitDrop_broker_priority is called when production drop_broker_priority is exited. +func (s *BaseTSqlParserListener) ExitDrop_broker_priority(ctx *Drop_broker_priorityContext) {} + +// EnterAlter_certificate is called when production alter_certificate is entered. +func (s *BaseTSqlParserListener) EnterAlter_certificate(ctx *Alter_certificateContext) {} + +// ExitAlter_certificate is called when production alter_certificate is exited. +func (s *BaseTSqlParserListener) ExitAlter_certificate(ctx *Alter_certificateContext) {} + +// EnterAlter_column_encryption_key is called when production alter_column_encryption_key is entered. +func (s *BaseTSqlParserListener) EnterAlter_column_encryption_key(ctx *Alter_column_encryption_keyContext) { +} + +// ExitAlter_column_encryption_key is called when production alter_column_encryption_key is exited. +func (s *BaseTSqlParserListener) ExitAlter_column_encryption_key(ctx *Alter_column_encryption_keyContext) { +} + +// EnterCreate_column_encryption_key is called when production create_column_encryption_key is entered. +func (s *BaseTSqlParserListener) EnterCreate_column_encryption_key(ctx *Create_column_encryption_keyContext) { +} + +// ExitCreate_column_encryption_key is called when production create_column_encryption_key is exited. +func (s *BaseTSqlParserListener) ExitCreate_column_encryption_key(ctx *Create_column_encryption_keyContext) { +} + +// EnterDrop_certificate is called when production drop_certificate is entered. +func (s *BaseTSqlParserListener) EnterDrop_certificate(ctx *Drop_certificateContext) {} + +// ExitDrop_certificate is called when production drop_certificate is exited. +func (s *BaseTSqlParserListener) ExitDrop_certificate(ctx *Drop_certificateContext) {} + +// EnterDrop_column_encryption_key is called when production drop_column_encryption_key is entered. +func (s *BaseTSqlParserListener) EnterDrop_column_encryption_key(ctx *Drop_column_encryption_keyContext) { +} + +// ExitDrop_column_encryption_key is called when production drop_column_encryption_key is exited. +func (s *BaseTSqlParserListener) ExitDrop_column_encryption_key(ctx *Drop_column_encryption_keyContext) { +} + +// EnterDrop_column_master_key is called when production drop_column_master_key is entered. +func (s *BaseTSqlParserListener) EnterDrop_column_master_key(ctx *Drop_column_master_keyContext) {} + +// ExitDrop_column_master_key is called when production drop_column_master_key is exited. +func (s *BaseTSqlParserListener) ExitDrop_column_master_key(ctx *Drop_column_master_keyContext) {} + +// EnterDrop_contract is called when production drop_contract is entered. +func (s *BaseTSqlParserListener) EnterDrop_contract(ctx *Drop_contractContext) {} + +// ExitDrop_contract is called when production drop_contract is exited. +func (s *BaseTSqlParserListener) ExitDrop_contract(ctx *Drop_contractContext) {} + +// EnterDrop_credential is called when production drop_credential is entered. +func (s *BaseTSqlParserListener) EnterDrop_credential(ctx *Drop_credentialContext) {} + +// ExitDrop_credential is called when production drop_credential is exited. +func (s *BaseTSqlParserListener) ExitDrop_credential(ctx *Drop_credentialContext) {} + +// EnterDrop_cryptograhic_provider is called when production drop_cryptograhic_provider is entered. +func (s *BaseTSqlParserListener) EnterDrop_cryptograhic_provider(ctx *Drop_cryptograhic_providerContext) { +} + +// ExitDrop_cryptograhic_provider is called when production drop_cryptograhic_provider is exited. +func (s *BaseTSqlParserListener) ExitDrop_cryptograhic_provider(ctx *Drop_cryptograhic_providerContext) { +} + +// EnterDrop_database is called when production drop_database is entered. +func (s *BaseTSqlParserListener) EnterDrop_database(ctx *Drop_databaseContext) {} + +// ExitDrop_database is called when production drop_database is exited. +func (s *BaseTSqlParserListener) ExitDrop_database(ctx *Drop_databaseContext) {} + +// EnterDrop_database_audit_specification is called when production drop_database_audit_specification is entered. +func (s *BaseTSqlParserListener) EnterDrop_database_audit_specification(ctx *Drop_database_audit_specificationContext) { +} + +// ExitDrop_database_audit_specification is called when production drop_database_audit_specification is exited. +func (s *BaseTSqlParserListener) ExitDrop_database_audit_specification(ctx *Drop_database_audit_specificationContext) { +} + +// EnterDrop_database_encryption_key is called when production drop_database_encryption_key is entered. +func (s *BaseTSqlParserListener) EnterDrop_database_encryption_key(ctx *Drop_database_encryption_keyContext) { +} + +// ExitDrop_database_encryption_key is called when production drop_database_encryption_key is exited. +func (s *BaseTSqlParserListener) ExitDrop_database_encryption_key(ctx *Drop_database_encryption_keyContext) { +} + +// EnterDrop_database_scoped_credential is called when production drop_database_scoped_credential is entered. +func (s *BaseTSqlParserListener) EnterDrop_database_scoped_credential(ctx *Drop_database_scoped_credentialContext) { +} + +// ExitDrop_database_scoped_credential is called when production drop_database_scoped_credential is exited. +func (s *BaseTSqlParserListener) ExitDrop_database_scoped_credential(ctx *Drop_database_scoped_credentialContext) { +} + +// EnterDrop_default is called when production drop_default is entered. +func (s *BaseTSqlParserListener) EnterDrop_default(ctx *Drop_defaultContext) {} + +// ExitDrop_default is called when production drop_default is exited. +func (s *BaseTSqlParserListener) ExitDrop_default(ctx *Drop_defaultContext) {} + +// EnterDrop_endpoint is called when production drop_endpoint is entered. +func (s *BaseTSqlParserListener) EnterDrop_endpoint(ctx *Drop_endpointContext) {} + +// ExitDrop_endpoint is called when production drop_endpoint is exited. +func (s *BaseTSqlParserListener) ExitDrop_endpoint(ctx *Drop_endpointContext) {} + +// EnterDrop_external_data_source is called when production drop_external_data_source is entered. +func (s *BaseTSqlParserListener) EnterDrop_external_data_source(ctx *Drop_external_data_sourceContext) { +} + +// ExitDrop_external_data_source is called when production drop_external_data_source is exited. +func (s *BaseTSqlParserListener) ExitDrop_external_data_source(ctx *Drop_external_data_sourceContext) { +} + +// EnterDrop_external_file_format is called when production drop_external_file_format is entered. +func (s *BaseTSqlParserListener) EnterDrop_external_file_format(ctx *Drop_external_file_formatContext) { +} + +// ExitDrop_external_file_format is called when production drop_external_file_format is exited. +func (s *BaseTSqlParserListener) ExitDrop_external_file_format(ctx *Drop_external_file_formatContext) { +} + +// EnterDrop_external_library is called when production drop_external_library is entered. +func (s *BaseTSqlParserListener) EnterDrop_external_library(ctx *Drop_external_libraryContext) {} + +// ExitDrop_external_library is called when production drop_external_library is exited. +func (s *BaseTSqlParserListener) ExitDrop_external_library(ctx *Drop_external_libraryContext) {} + +// EnterDrop_external_resource_pool is called when production drop_external_resource_pool is entered. +func (s *BaseTSqlParserListener) EnterDrop_external_resource_pool(ctx *Drop_external_resource_poolContext) { +} + +// ExitDrop_external_resource_pool is called when production drop_external_resource_pool is exited. +func (s *BaseTSqlParserListener) ExitDrop_external_resource_pool(ctx *Drop_external_resource_poolContext) { +} + +// EnterDrop_external_table is called when production drop_external_table is entered. +func (s *BaseTSqlParserListener) EnterDrop_external_table(ctx *Drop_external_tableContext) {} + +// ExitDrop_external_table is called when production drop_external_table is exited. +func (s *BaseTSqlParserListener) ExitDrop_external_table(ctx *Drop_external_tableContext) {} + +// EnterDrop_event_notifications is called when production drop_event_notifications is entered. +func (s *BaseTSqlParserListener) EnterDrop_event_notifications(ctx *Drop_event_notificationsContext) { +} + +// ExitDrop_event_notifications is called when production drop_event_notifications is exited. +func (s *BaseTSqlParserListener) ExitDrop_event_notifications(ctx *Drop_event_notificationsContext) {} + +// EnterDrop_event_session is called when production drop_event_session is entered. +func (s *BaseTSqlParserListener) EnterDrop_event_session(ctx *Drop_event_sessionContext) {} + +// ExitDrop_event_session is called when production drop_event_session is exited. +func (s *BaseTSqlParserListener) ExitDrop_event_session(ctx *Drop_event_sessionContext) {} + +// EnterDrop_fulltext_catalog is called when production drop_fulltext_catalog is entered. +func (s *BaseTSqlParserListener) EnterDrop_fulltext_catalog(ctx *Drop_fulltext_catalogContext) {} + +// ExitDrop_fulltext_catalog is called when production drop_fulltext_catalog is exited. +func (s *BaseTSqlParserListener) ExitDrop_fulltext_catalog(ctx *Drop_fulltext_catalogContext) {} + +// EnterDrop_fulltext_index is called when production drop_fulltext_index is entered. +func (s *BaseTSqlParserListener) EnterDrop_fulltext_index(ctx *Drop_fulltext_indexContext) {} + +// ExitDrop_fulltext_index is called when production drop_fulltext_index is exited. +func (s *BaseTSqlParserListener) ExitDrop_fulltext_index(ctx *Drop_fulltext_indexContext) {} + +// EnterDrop_fulltext_stoplist is called when production drop_fulltext_stoplist is entered. +func (s *BaseTSqlParserListener) EnterDrop_fulltext_stoplist(ctx *Drop_fulltext_stoplistContext) {} + +// ExitDrop_fulltext_stoplist is called when production drop_fulltext_stoplist is exited. +func (s *BaseTSqlParserListener) ExitDrop_fulltext_stoplist(ctx *Drop_fulltext_stoplistContext) {} + +// EnterDrop_login is called when production drop_login is entered. +func (s *BaseTSqlParserListener) EnterDrop_login(ctx *Drop_loginContext) {} + +// ExitDrop_login is called when production drop_login is exited. +func (s *BaseTSqlParserListener) ExitDrop_login(ctx *Drop_loginContext) {} + +// EnterDrop_master_key is called when production drop_master_key is entered. +func (s *BaseTSqlParserListener) EnterDrop_master_key(ctx *Drop_master_keyContext) {} + +// ExitDrop_master_key is called when production drop_master_key is exited. +func (s *BaseTSqlParserListener) ExitDrop_master_key(ctx *Drop_master_keyContext) {} + +// EnterDrop_message_type is called when production drop_message_type is entered. +func (s *BaseTSqlParserListener) EnterDrop_message_type(ctx *Drop_message_typeContext) {} + +// ExitDrop_message_type is called when production drop_message_type is exited. +func (s *BaseTSqlParserListener) ExitDrop_message_type(ctx *Drop_message_typeContext) {} + +// EnterDrop_partition_function is called when production drop_partition_function is entered. +func (s *BaseTSqlParserListener) EnterDrop_partition_function(ctx *Drop_partition_functionContext) {} + +// ExitDrop_partition_function is called when production drop_partition_function is exited. +func (s *BaseTSqlParserListener) ExitDrop_partition_function(ctx *Drop_partition_functionContext) {} + +// EnterDrop_partition_scheme is called when production drop_partition_scheme is entered. +func (s *BaseTSqlParserListener) EnterDrop_partition_scheme(ctx *Drop_partition_schemeContext) {} + +// ExitDrop_partition_scheme is called when production drop_partition_scheme is exited. +func (s *BaseTSqlParserListener) ExitDrop_partition_scheme(ctx *Drop_partition_schemeContext) {} + +// EnterDrop_queue is called when production drop_queue is entered. +func (s *BaseTSqlParserListener) EnterDrop_queue(ctx *Drop_queueContext) {} + +// ExitDrop_queue is called when production drop_queue is exited. +func (s *BaseTSqlParserListener) ExitDrop_queue(ctx *Drop_queueContext) {} + +// EnterDrop_remote_service_binding is called when production drop_remote_service_binding is entered. +func (s *BaseTSqlParserListener) EnterDrop_remote_service_binding(ctx *Drop_remote_service_bindingContext) { +} + +// ExitDrop_remote_service_binding is called when production drop_remote_service_binding is exited. +func (s *BaseTSqlParserListener) ExitDrop_remote_service_binding(ctx *Drop_remote_service_bindingContext) { +} + +// EnterDrop_resource_pool is called when production drop_resource_pool is entered. +func (s *BaseTSqlParserListener) EnterDrop_resource_pool(ctx *Drop_resource_poolContext) {} + +// ExitDrop_resource_pool is called when production drop_resource_pool is exited. +func (s *BaseTSqlParserListener) ExitDrop_resource_pool(ctx *Drop_resource_poolContext) {} + +// EnterDrop_db_role is called when production drop_db_role is entered. +func (s *BaseTSqlParserListener) EnterDrop_db_role(ctx *Drop_db_roleContext) {} + +// ExitDrop_db_role is called when production drop_db_role is exited. +func (s *BaseTSqlParserListener) ExitDrop_db_role(ctx *Drop_db_roleContext) {} + +// EnterDrop_route is called when production drop_route is entered. +func (s *BaseTSqlParserListener) EnterDrop_route(ctx *Drop_routeContext) {} + +// ExitDrop_route is called when production drop_route is exited. +func (s *BaseTSqlParserListener) ExitDrop_route(ctx *Drop_routeContext) {} + +// EnterDrop_rule is called when production drop_rule is entered. +func (s *BaseTSqlParserListener) EnterDrop_rule(ctx *Drop_ruleContext) {} + +// ExitDrop_rule is called when production drop_rule is exited. +func (s *BaseTSqlParserListener) ExitDrop_rule(ctx *Drop_ruleContext) {} + +// EnterDrop_schema is called when production drop_schema is entered. +func (s *BaseTSqlParserListener) EnterDrop_schema(ctx *Drop_schemaContext) {} + +// ExitDrop_schema is called when production drop_schema is exited. +func (s *BaseTSqlParserListener) ExitDrop_schema(ctx *Drop_schemaContext) {} + +// EnterDrop_search_property_list is called when production drop_search_property_list is entered. +func (s *BaseTSqlParserListener) EnterDrop_search_property_list(ctx *Drop_search_property_listContext) { +} + +// ExitDrop_search_property_list is called when production drop_search_property_list is exited. +func (s *BaseTSqlParserListener) ExitDrop_search_property_list(ctx *Drop_search_property_listContext) { +} + +// EnterDrop_security_policy is called when production drop_security_policy is entered. +func (s *BaseTSqlParserListener) EnterDrop_security_policy(ctx *Drop_security_policyContext) {} + +// ExitDrop_security_policy is called when production drop_security_policy is exited. +func (s *BaseTSqlParserListener) ExitDrop_security_policy(ctx *Drop_security_policyContext) {} + +// EnterDrop_sequence is called when production drop_sequence is entered. +func (s *BaseTSqlParserListener) EnterDrop_sequence(ctx *Drop_sequenceContext) {} + +// ExitDrop_sequence is called when production drop_sequence is exited. +func (s *BaseTSqlParserListener) ExitDrop_sequence(ctx *Drop_sequenceContext) {} + +// EnterDrop_server_audit is called when production drop_server_audit is entered. +func (s *BaseTSqlParserListener) EnterDrop_server_audit(ctx *Drop_server_auditContext) {} + +// ExitDrop_server_audit is called when production drop_server_audit is exited. +func (s *BaseTSqlParserListener) ExitDrop_server_audit(ctx *Drop_server_auditContext) {} + +// EnterDrop_server_audit_specification is called when production drop_server_audit_specification is entered. +func (s *BaseTSqlParserListener) EnterDrop_server_audit_specification(ctx *Drop_server_audit_specificationContext) { +} + +// ExitDrop_server_audit_specification is called when production drop_server_audit_specification is exited. +func (s *BaseTSqlParserListener) ExitDrop_server_audit_specification(ctx *Drop_server_audit_specificationContext) { +} + +// EnterDrop_server_role is called when production drop_server_role is entered. +func (s *BaseTSqlParserListener) EnterDrop_server_role(ctx *Drop_server_roleContext) {} + +// ExitDrop_server_role is called when production drop_server_role is exited. +func (s *BaseTSqlParserListener) ExitDrop_server_role(ctx *Drop_server_roleContext) {} + +// EnterDrop_service is called when production drop_service is entered. +func (s *BaseTSqlParserListener) EnterDrop_service(ctx *Drop_serviceContext) {} + +// ExitDrop_service is called when production drop_service is exited. +func (s *BaseTSqlParserListener) ExitDrop_service(ctx *Drop_serviceContext) {} + +// EnterDrop_signature is called when production drop_signature is entered. +func (s *BaseTSqlParserListener) EnterDrop_signature(ctx *Drop_signatureContext) {} + +// ExitDrop_signature is called when production drop_signature is exited. +func (s *BaseTSqlParserListener) ExitDrop_signature(ctx *Drop_signatureContext) {} + +// EnterDrop_statistics_name_azure_dw_and_pdw is called when production drop_statistics_name_azure_dw_and_pdw is entered. +func (s *BaseTSqlParserListener) EnterDrop_statistics_name_azure_dw_and_pdw(ctx *Drop_statistics_name_azure_dw_and_pdwContext) { +} + +// ExitDrop_statistics_name_azure_dw_and_pdw is called when production drop_statistics_name_azure_dw_and_pdw is exited. +func (s *BaseTSqlParserListener) ExitDrop_statistics_name_azure_dw_and_pdw(ctx *Drop_statistics_name_azure_dw_and_pdwContext) { +} + +// EnterDrop_symmetric_key is called when production drop_symmetric_key is entered. +func (s *BaseTSqlParserListener) EnterDrop_symmetric_key(ctx *Drop_symmetric_keyContext) {} + +// ExitDrop_symmetric_key is called when production drop_symmetric_key is exited. +func (s *BaseTSqlParserListener) ExitDrop_symmetric_key(ctx *Drop_symmetric_keyContext) {} + +// EnterDrop_synonym is called when production drop_synonym is entered. +func (s *BaseTSqlParserListener) EnterDrop_synonym(ctx *Drop_synonymContext) {} + +// ExitDrop_synonym is called when production drop_synonym is exited. +func (s *BaseTSqlParserListener) ExitDrop_synonym(ctx *Drop_synonymContext) {} + +// EnterDrop_user is called when production drop_user is entered. +func (s *BaseTSqlParserListener) EnterDrop_user(ctx *Drop_userContext) {} + +// ExitDrop_user is called when production drop_user is exited. +func (s *BaseTSqlParserListener) ExitDrop_user(ctx *Drop_userContext) {} + +// EnterDrop_workload_group is called when production drop_workload_group is entered. +func (s *BaseTSqlParserListener) EnterDrop_workload_group(ctx *Drop_workload_groupContext) {} + +// ExitDrop_workload_group is called when production drop_workload_group is exited. +func (s *BaseTSqlParserListener) ExitDrop_workload_group(ctx *Drop_workload_groupContext) {} + +// EnterDrop_xml_schema_collection is called when production drop_xml_schema_collection is entered. +func (s *BaseTSqlParserListener) EnterDrop_xml_schema_collection(ctx *Drop_xml_schema_collectionContext) { +} + +// ExitDrop_xml_schema_collection is called when production drop_xml_schema_collection is exited. +func (s *BaseTSqlParserListener) ExitDrop_xml_schema_collection(ctx *Drop_xml_schema_collectionContext) { +} + +// EnterDisable_trigger is called when production disable_trigger is entered. +func (s *BaseTSqlParserListener) EnterDisable_trigger(ctx *Disable_triggerContext) {} + +// ExitDisable_trigger is called when production disable_trigger is exited. +func (s *BaseTSqlParserListener) ExitDisable_trigger(ctx *Disable_triggerContext) {} + +// EnterEnable_trigger is called when production enable_trigger is entered. +func (s *BaseTSqlParserListener) EnterEnable_trigger(ctx *Enable_triggerContext) {} + +// ExitEnable_trigger is called when production enable_trigger is exited. +func (s *BaseTSqlParserListener) ExitEnable_trigger(ctx *Enable_triggerContext) {} + +// EnterLock_table is called when production lock_table is entered. +func (s *BaseTSqlParserListener) EnterLock_table(ctx *Lock_tableContext) {} + +// ExitLock_table is called when production lock_table is exited. +func (s *BaseTSqlParserListener) ExitLock_table(ctx *Lock_tableContext) {} + +// EnterTruncate_table is called when production truncate_table is entered. +func (s *BaseTSqlParserListener) EnterTruncate_table(ctx *Truncate_tableContext) {} + +// ExitTruncate_table is called when production truncate_table is exited. +func (s *BaseTSqlParserListener) ExitTruncate_table(ctx *Truncate_tableContext) {} + +// EnterCreate_column_master_key is called when production create_column_master_key is entered. +func (s *BaseTSqlParserListener) EnterCreate_column_master_key(ctx *Create_column_master_keyContext) { +} + +// ExitCreate_column_master_key is called when production create_column_master_key is exited. +func (s *BaseTSqlParserListener) ExitCreate_column_master_key(ctx *Create_column_master_keyContext) {} + +// EnterAlter_credential is called when production alter_credential is entered. +func (s *BaseTSqlParserListener) EnterAlter_credential(ctx *Alter_credentialContext) {} + +// ExitAlter_credential is called when production alter_credential is exited. +func (s *BaseTSqlParserListener) ExitAlter_credential(ctx *Alter_credentialContext) {} + +// EnterCreate_credential is called when production create_credential is entered. +func (s *BaseTSqlParserListener) EnterCreate_credential(ctx *Create_credentialContext) {} + +// ExitCreate_credential is called when production create_credential is exited. +func (s *BaseTSqlParserListener) ExitCreate_credential(ctx *Create_credentialContext) {} + +// EnterAlter_cryptographic_provider is called when production alter_cryptographic_provider is entered. +func (s *BaseTSqlParserListener) EnterAlter_cryptographic_provider(ctx *Alter_cryptographic_providerContext) { +} + +// ExitAlter_cryptographic_provider is called when production alter_cryptographic_provider is exited. +func (s *BaseTSqlParserListener) ExitAlter_cryptographic_provider(ctx *Alter_cryptographic_providerContext) { +} + +// EnterCreate_cryptographic_provider is called when production create_cryptographic_provider is entered. +func (s *BaseTSqlParserListener) EnterCreate_cryptographic_provider(ctx *Create_cryptographic_providerContext) { +} + +// ExitCreate_cryptographic_provider is called when production create_cryptographic_provider is exited. +func (s *BaseTSqlParserListener) ExitCreate_cryptographic_provider(ctx *Create_cryptographic_providerContext) { +} + +// EnterCreate_endpoint is called when production create_endpoint is entered. +func (s *BaseTSqlParserListener) EnterCreate_endpoint(ctx *Create_endpointContext) {} + +// ExitCreate_endpoint is called when production create_endpoint is exited. +func (s *BaseTSqlParserListener) ExitCreate_endpoint(ctx *Create_endpointContext) {} + +// EnterEndpoint_encryption_alogorithm_clause is called when production endpoint_encryption_alogorithm_clause is entered. +func (s *BaseTSqlParserListener) EnterEndpoint_encryption_alogorithm_clause(ctx *Endpoint_encryption_alogorithm_clauseContext) { +} + +// ExitEndpoint_encryption_alogorithm_clause is called when production endpoint_encryption_alogorithm_clause is exited. +func (s *BaseTSqlParserListener) ExitEndpoint_encryption_alogorithm_clause(ctx *Endpoint_encryption_alogorithm_clauseContext) { +} + +// EnterEndpoint_authentication_clause is called when production endpoint_authentication_clause is entered. +func (s *BaseTSqlParserListener) EnterEndpoint_authentication_clause(ctx *Endpoint_authentication_clauseContext) { +} + +// ExitEndpoint_authentication_clause is called when production endpoint_authentication_clause is exited. +func (s *BaseTSqlParserListener) ExitEndpoint_authentication_clause(ctx *Endpoint_authentication_clauseContext) { +} + +// EnterEndpoint_listener_clause is called when production endpoint_listener_clause is entered. +func (s *BaseTSqlParserListener) EnterEndpoint_listener_clause(ctx *Endpoint_listener_clauseContext) { +} + +// ExitEndpoint_listener_clause is called when production endpoint_listener_clause is exited. +func (s *BaseTSqlParserListener) ExitEndpoint_listener_clause(ctx *Endpoint_listener_clauseContext) {} + +// EnterCreate_event_notification is called when production create_event_notification is entered. +func (s *BaseTSqlParserListener) EnterCreate_event_notification(ctx *Create_event_notificationContext) { +} + +// ExitCreate_event_notification is called when production create_event_notification is exited. +func (s *BaseTSqlParserListener) ExitCreate_event_notification(ctx *Create_event_notificationContext) { +} + +// EnterCreate_or_alter_event_session is called when production create_or_alter_event_session is entered. +func (s *BaseTSqlParserListener) EnterCreate_or_alter_event_session(ctx *Create_or_alter_event_sessionContext) { +} + +// ExitCreate_or_alter_event_session is called when production create_or_alter_event_session is exited. +func (s *BaseTSqlParserListener) ExitCreate_or_alter_event_session(ctx *Create_or_alter_event_sessionContext) { +} + +// EnterEvent_session_predicate_expression is called when production event_session_predicate_expression is entered. +func (s *BaseTSqlParserListener) EnterEvent_session_predicate_expression(ctx *Event_session_predicate_expressionContext) { +} + +// ExitEvent_session_predicate_expression is called when production event_session_predicate_expression is exited. +func (s *BaseTSqlParserListener) ExitEvent_session_predicate_expression(ctx *Event_session_predicate_expressionContext) { +} + +// EnterEvent_session_predicate_factor is called when production event_session_predicate_factor is entered. +func (s *BaseTSqlParserListener) EnterEvent_session_predicate_factor(ctx *Event_session_predicate_factorContext) { +} + +// ExitEvent_session_predicate_factor is called when production event_session_predicate_factor is exited. +func (s *BaseTSqlParserListener) ExitEvent_session_predicate_factor(ctx *Event_session_predicate_factorContext) { +} + +// EnterEvent_session_predicate_leaf is called when production event_session_predicate_leaf is entered. +func (s *BaseTSqlParserListener) EnterEvent_session_predicate_leaf(ctx *Event_session_predicate_leafContext) { +} + +// ExitEvent_session_predicate_leaf is called when production event_session_predicate_leaf is exited. +func (s *BaseTSqlParserListener) ExitEvent_session_predicate_leaf(ctx *Event_session_predicate_leafContext) { +} + +// EnterAlter_external_data_source is called when production alter_external_data_source is entered. +func (s *BaseTSqlParserListener) EnterAlter_external_data_source(ctx *Alter_external_data_sourceContext) { +} + +// ExitAlter_external_data_source is called when production alter_external_data_source is exited. +func (s *BaseTSqlParserListener) ExitAlter_external_data_source(ctx *Alter_external_data_sourceContext) { +} + +// EnterAlter_external_library is called when production alter_external_library is entered. +func (s *BaseTSqlParserListener) EnterAlter_external_library(ctx *Alter_external_libraryContext) {} + +// ExitAlter_external_library is called when production alter_external_library is exited. +func (s *BaseTSqlParserListener) ExitAlter_external_library(ctx *Alter_external_libraryContext) {} + +// EnterCreate_external_library is called when production create_external_library is entered. +func (s *BaseTSqlParserListener) EnterCreate_external_library(ctx *Create_external_libraryContext) {} + +// ExitCreate_external_library is called when production create_external_library is exited. +func (s *BaseTSqlParserListener) ExitCreate_external_library(ctx *Create_external_libraryContext) {} + +// EnterAlter_external_resource_pool is called when production alter_external_resource_pool is entered. +func (s *BaseTSqlParserListener) EnterAlter_external_resource_pool(ctx *Alter_external_resource_poolContext) { +} + +// ExitAlter_external_resource_pool is called when production alter_external_resource_pool is exited. +func (s *BaseTSqlParserListener) ExitAlter_external_resource_pool(ctx *Alter_external_resource_poolContext) { +} + +// EnterCreate_external_resource_pool is called when production create_external_resource_pool is entered. +func (s *BaseTSqlParserListener) EnterCreate_external_resource_pool(ctx *Create_external_resource_poolContext) { +} + +// ExitCreate_external_resource_pool is called when production create_external_resource_pool is exited. +func (s *BaseTSqlParserListener) ExitCreate_external_resource_pool(ctx *Create_external_resource_poolContext) { +} + +// EnterAlter_fulltext_catalog is called when production alter_fulltext_catalog is entered. +func (s *BaseTSqlParserListener) EnterAlter_fulltext_catalog(ctx *Alter_fulltext_catalogContext) {} + +// ExitAlter_fulltext_catalog is called when production alter_fulltext_catalog is exited. +func (s *BaseTSqlParserListener) ExitAlter_fulltext_catalog(ctx *Alter_fulltext_catalogContext) {} + +// EnterCreate_fulltext_catalog is called when production create_fulltext_catalog is entered. +func (s *BaseTSqlParserListener) EnterCreate_fulltext_catalog(ctx *Create_fulltext_catalogContext) {} + +// ExitCreate_fulltext_catalog is called when production create_fulltext_catalog is exited. +func (s *BaseTSqlParserListener) ExitCreate_fulltext_catalog(ctx *Create_fulltext_catalogContext) {} + +// EnterAlter_fulltext_stoplist is called when production alter_fulltext_stoplist is entered. +func (s *BaseTSqlParserListener) EnterAlter_fulltext_stoplist(ctx *Alter_fulltext_stoplistContext) {} + +// ExitAlter_fulltext_stoplist is called when production alter_fulltext_stoplist is exited. +func (s *BaseTSqlParserListener) ExitAlter_fulltext_stoplist(ctx *Alter_fulltext_stoplistContext) {} + +// EnterCreate_fulltext_stoplist is called when production create_fulltext_stoplist is entered. +func (s *BaseTSqlParserListener) EnterCreate_fulltext_stoplist(ctx *Create_fulltext_stoplistContext) { +} + +// ExitCreate_fulltext_stoplist is called when production create_fulltext_stoplist is exited. +func (s *BaseTSqlParserListener) ExitCreate_fulltext_stoplist(ctx *Create_fulltext_stoplistContext) {} + +// EnterAlter_login_sql_server is called when production alter_login_sql_server is entered. +func (s *BaseTSqlParserListener) EnterAlter_login_sql_server(ctx *Alter_login_sql_serverContext) {} + +// ExitAlter_login_sql_server is called when production alter_login_sql_server is exited. +func (s *BaseTSqlParserListener) ExitAlter_login_sql_server(ctx *Alter_login_sql_serverContext) {} + +// EnterCreate_login_sql_server is called when production create_login_sql_server is entered. +func (s *BaseTSqlParserListener) EnterCreate_login_sql_server(ctx *Create_login_sql_serverContext) {} + +// ExitCreate_login_sql_server is called when production create_login_sql_server is exited. +func (s *BaseTSqlParserListener) ExitCreate_login_sql_server(ctx *Create_login_sql_serverContext) {} + +// EnterAlter_login_azure_sql is called when production alter_login_azure_sql is entered. +func (s *BaseTSqlParserListener) EnterAlter_login_azure_sql(ctx *Alter_login_azure_sqlContext) {} + +// ExitAlter_login_azure_sql is called when production alter_login_azure_sql is exited. +func (s *BaseTSqlParserListener) ExitAlter_login_azure_sql(ctx *Alter_login_azure_sqlContext) {} + +// EnterCreate_login_azure_sql is called when production create_login_azure_sql is entered. +func (s *BaseTSqlParserListener) EnterCreate_login_azure_sql(ctx *Create_login_azure_sqlContext) {} + +// ExitCreate_login_azure_sql is called when production create_login_azure_sql is exited. +func (s *BaseTSqlParserListener) ExitCreate_login_azure_sql(ctx *Create_login_azure_sqlContext) {} + +// EnterAlter_login_azure_sql_dw_and_pdw is called when production alter_login_azure_sql_dw_and_pdw is entered. +func (s *BaseTSqlParserListener) EnterAlter_login_azure_sql_dw_and_pdw(ctx *Alter_login_azure_sql_dw_and_pdwContext) { +} + +// ExitAlter_login_azure_sql_dw_and_pdw is called when production alter_login_azure_sql_dw_and_pdw is exited. +func (s *BaseTSqlParserListener) ExitAlter_login_azure_sql_dw_and_pdw(ctx *Alter_login_azure_sql_dw_and_pdwContext) { +} + +// EnterCreate_login_pdw is called when production create_login_pdw is entered. +func (s *BaseTSqlParserListener) EnterCreate_login_pdw(ctx *Create_login_pdwContext) {} + +// ExitCreate_login_pdw is called when production create_login_pdw is exited. +func (s *BaseTSqlParserListener) ExitCreate_login_pdw(ctx *Create_login_pdwContext) {} + +// EnterAlter_master_key_sql_server is called when production alter_master_key_sql_server is entered. +func (s *BaseTSqlParserListener) EnterAlter_master_key_sql_server(ctx *Alter_master_key_sql_serverContext) { +} + +// ExitAlter_master_key_sql_server is called when production alter_master_key_sql_server is exited. +func (s *BaseTSqlParserListener) ExitAlter_master_key_sql_server(ctx *Alter_master_key_sql_serverContext) { +} + +// EnterCreate_master_key_sql_server is called when production create_master_key_sql_server is entered. +func (s *BaseTSqlParserListener) EnterCreate_master_key_sql_server(ctx *Create_master_key_sql_serverContext) { +} + +// ExitCreate_master_key_sql_server is called when production create_master_key_sql_server is exited. +func (s *BaseTSqlParserListener) ExitCreate_master_key_sql_server(ctx *Create_master_key_sql_serverContext) { +} + +// EnterAlter_master_key_azure_sql is called when production alter_master_key_azure_sql is entered. +func (s *BaseTSqlParserListener) EnterAlter_master_key_azure_sql(ctx *Alter_master_key_azure_sqlContext) { +} + +// ExitAlter_master_key_azure_sql is called when production alter_master_key_azure_sql is exited. +func (s *BaseTSqlParserListener) ExitAlter_master_key_azure_sql(ctx *Alter_master_key_azure_sqlContext) { +} + +// EnterCreate_master_key_azure_sql is called when production create_master_key_azure_sql is entered. +func (s *BaseTSqlParserListener) EnterCreate_master_key_azure_sql(ctx *Create_master_key_azure_sqlContext) { +} + +// ExitCreate_master_key_azure_sql is called when production create_master_key_azure_sql is exited. +func (s *BaseTSqlParserListener) ExitCreate_master_key_azure_sql(ctx *Create_master_key_azure_sqlContext) { +} + +// EnterAlter_message_type is called when production alter_message_type is entered. +func (s *BaseTSqlParserListener) EnterAlter_message_type(ctx *Alter_message_typeContext) {} + +// ExitAlter_message_type is called when production alter_message_type is exited. +func (s *BaseTSqlParserListener) ExitAlter_message_type(ctx *Alter_message_typeContext) {} + +// EnterAlter_partition_function is called when production alter_partition_function is entered. +func (s *BaseTSqlParserListener) EnterAlter_partition_function(ctx *Alter_partition_functionContext) { +} + +// ExitAlter_partition_function is called when production alter_partition_function is exited. +func (s *BaseTSqlParserListener) ExitAlter_partition_function(ctx *Alter_partition_functionContext) {} + +// EnterAlter_partition_scheme is called when production alter_partition_scheme is entered. +func (s *BaseTSqlParserListener) EnterAlter_partition_scheme(ctx *Alter_partition_schemeContext) {} + +// ExitAlter_partition_scheme is called when production alter_partition_scheme is exited. +func (s *BaseTSqlParserListener) ExitAlter_partition_scheme(ctx *Alter_partition_schemeContext) {} + +// EnterAlter_remote_service_binding is called when production alter_remote_service_binding is entered. +func (s *BaseTSqlParserListener) EnterAlter_remote_service_binding(ctx *Alter_remote_service_bindingContext) { +} + +// ExitAlter_remote_service_binding is called when production alter_remote_service_binding is exited. +func (s *BaseTSqlParserListener) ExitAlter_remote_service_binding(ctx *Alter_remote_service_bindingContext) { +} + +// EnterCreate_remote_service_binding is called when production create_remote_service_binding is entered. +func (s *BaseTSqlParserListener) EnterCreate_remote_service_binding(ctx *Create_remote_service_bindingContext) { +} + +// ExitCreate_remote_service_binding is called when production create_remote_service_binding is exited. +func (s *BaseTSqlParserListener) ExitCreate_remote_service_binding(ctx *Create_remote_service_bindingContext) { +} + +// EnterCreate_resource_pool is called when production create_resource_pool is entered. +func (s *BaseTSqlParserListener) EnterCreate_resource_pool(ctx *Create_resource_poolContext) {} + +// ExitCreate_resource_pool is called when production create_resource_pool is exited. +func (s *BaseTSqlParserListener) ExitCreate_resource_pool(ctx *Create_resource_poolContext) {} + +// EnterAlter_resource_governor is called when production alter_resource_governor is entered. +func (s *BaseTSqlParserListener) EnterAlter_resource_governor(ctx *Alter_resource_governorContext) {} + +// ExitAlter_resource_governor is called when production alter_resource_governor is exited. +func (s *BaseTSqlParserListener) ExitAlter_resource_governor(ctx *Alter_resource_governorContext) {} + +// EnterAlter_database_audit_specification is called when production alter_database_audit_specification is entered. +func (s *BaseTSqlParserListener) EnterAlter_database_audit_specification(ctx *Alter_database_audit_specificationContext) { +} + +// ExitAlter_database_audit_specification is called when production alter_database_audit_specification is exited. +func (s *BaseTSqlParserListener) ExitAlter_database_audit_specification(ctx *Alter_database_audit_specificationContext) { +} + +// EnterAudit_action_spec_group is called when production audit_action_spec_group is entered. +func (s *BaseTSqlParserListener) EnterAudit_action_spec_group(ctx *Audit_action_spec_groupContext) {} + +// ExitAudit_action_spec_group is called when production audit_action_spec_group is exited. +func (s *BaseTSqlParserListener) ExitAudit_action_spec_group(ctx *Audit_action_spec_groupContext) {} + +// EnterAudit_action_specification is called when production audit_action_specification is entered. +func (s *BaseTSqlParserListener) EnterAudit_action_specification(ctx *Audit_action_specificationContext) { +} + +// ExitAudit_action_specification is called when production audit_action_specification is exited. +func (s *BaseTSqlParserListener) ExitAudit_action_specification(ctx *Audit_action_specificationContext) { +} + +// EnterAction_specification is called when production action_specification is entered. +func (s *BaseTSqlParserListener) EnterAction_specification(ctx *Action_specificationContext) {} + +// ExitAction_specification is called when production action_specification is exited. +func (s *BaseTSqlParserListener) ExitAction_specification(ctx *Action_specificationContext) {} + +// EnterAudit_class_name is called when production audit_class_name is entered. +func (s *BaseTSqlParserListener) EnterAudit_class_name(ctx *Audit_class_nameContext) {} + +// ExitAudit_class_name is called when production audit_class_name is exited. +func (s *BaseTSqlParserListener) ExitAudit_class_name(ctx *Audit_class_nameContext) {} + +// EnterAudit_securable is called when production audit_securable is entered. +func (s *BaseTSqlParserListener) EnterAudit_securable(ctx *Audit_securableContext) {} + +// ExitAudit_securable is called when production audit_securable is exited. +func (s *BaseTSqlParserListener) ExitAudit_securable(ctx *Audit_securableContext) {} + +// EnterAlter_db_role is called when production alter_db_role is entered. +func (s *BaseTSqlParserListener) EnterAlter_db_role(ctx *Alter_db_roleContext) {} + +// ExitAlter_db_role is called when production alter_db_role is exited. +func (s *BaseTSqlParserListener) ExitAlter_db_role(ctx *Alter_db_roleContext) {} + +// EnterCreate_database_audit_specification is called when production create_database_audit_specification is entered. +func (s *BaseTSqlParserListener) EnterCreate_database_audit_specification(ctx *Create_database_audit_specificationContext) { +} + +// ExitCreate_database_audit_specification is called when production create_database_audit_specification is exited. +func (s *BaseTSqlParserListener) ExitCreate_database_audit_specification(ctx *Create_database_audit_specificationContext) { +} + +// EnterCreate_db_role is called when production create_db_role is entered. +func (s *BaseTSqlParserListener) EnterCreate_db_role(ctx *Create_db_roleContext) {} + +// ExitCreate_db_role is called when production create_db_role is exited. +func (s *BaseTSqlParserListener) ExitCreate_db_role(ctx *Create_db_roleContext) {} + +// EnterCreate_route is called when production create_route is entered. +func (s *BaseTSqlParserListener) EnterCreate_route(ctx *Create_routeContext) {} + +// ExitCreate_route is called when production create_route is exited. +func (s *BaseTSqlParserListener) ExitCreate_route(ctx *Create_routeContext) {} + +// EnterCreate_rule is called when production create_rule is entered. +func (s *BaseTSqlParserListener) EnterCreate_rule(ctx *Create_ruleContext) {} + +// ExitCreate_rule is called when production create_rule is exited. +func (s *BaseTSqlParserListener) ExitCreate_rule(ctx *Create_ruleContext) {} + +// EnterAlter_schema_sql is called when production alter_schema_sql is entered. +func (s *BaseTSqlParserListener) EnterAlter_schema_sql(ctx *Alter_schema_sqlContext) {} + +// ExitAlter_schema_sql is called when production alter_schema_sql is exited. +func (s *BaseTSqlParserListener) ExitAlter_schema_sql(ctx *Alter_schema_sqlContext) {} + +// EnterCreate_schema is called when production create_schema is entered. +func (s *BaseTSqlParserListener) EnterCreate_schema(ctx *Create_schemaContext) {} + +// ExitCreate_schema is called when production create_schema is exited. +func (s *BaseTSqlParserListener) ExitCreate_schema(ctx *Create_schemaContext) {} + +// EnterCreate_schema_azure_sql_dw_and_pdw is called when production create_schema_azure_sql_dw_and_pdw is entered. +func (s *BaseTSqlParserListener) EnterCreate_schema_azure_sql_dw_and_pdw(ctx *Create_schema_azure_sql_dw_and_pdwContext) { +} + +// ExitCreate_schema_azure_sql_dw_and_pdw is called when production create_schema_azure_sql_dw_and_pdw is exited. +func (s *BaseTSqlParserListener) ExitCreate_schema_azure_sql_dw_and_pdw(ctx *Create_schema_azure_sql_dw_and_pdwContext) { +} + +// EnterAlter_schema_azure_sql_dw_and_pdw is called when production alter_schema_azure_sql_dw_and_pdw is entered. +func (s *BaseTSqlParserListener) EnterAlter_schema_azure_sql_dw_and_pdw(ctx *Alter_schema_azure_sql_dw_and_pdwContext) { +} + +// ExitAlter_schema_azure_sql_dw_and_pdw is called when production alter_schema_azure_sql_dw_and_pdw is exited. +func (s *BaseTSqlParserListener) ExitAlter_schema_azure_sql_dw_and_pdw(ctx *Alter_schema_azure_sql_dw_and_pdwContext) { +} + +// EnterCreate_search_property_list is called when production create_search_property_list is entered. +func (s *BaseTSqlParserListener) EnterCreate_search_property_list(ctx *Create_search_property_listContext) { +} + +// ExitCreate_search_property_list is called when production create_search_property_list is exited. +func (s *BaseTSqlParserListener) ExitCreate_search_property_list(ctx *Create_search_property_listContext) { +} + +// EnterCreate_security_policy is called when production create_security_policy is entered. +func (s *BaseTSqlParserListener) EnterCreate_security_policy(ctx *Create_security_policyContext) {} + +// ExitCreate_security_policy is called when production create_security_policy is exited. +func (s *BaseTSqlParserListener) ExitCreate_security_policy(ctx *Create_security_policyContext) {} + +// EnterAlter_sequence is called when production alter_sequence is entered. +func (s *BaseTSqlParserListener) EnterAlter_sequence(ctx *Alter_sequenceContext) {} + +// ExitAlter_sequence is called when production alter_sequence is exited. +func (s *BaseTSqlParserListener) ExitAlter_sequence(ctx *Alter_sequenceContext) {} + +// EnterCreate_sequence is called when production create_sequence is entered. +func (s *BaseTSqlParserListener) EnterCreate_sequence(ctx *Create_sequenceContext) {} + +// ExitCreate_sequence is called when production create_sequence is exited. +func (s *BaseTSqlParserListener) ExitCreate_sequence(ctx *Create_sequenceContext) {} + +// EnterAlter_server_audit is called when production alter_server_audit is entered. +func (s *BaseTSqlParserListener) EnterAlter_server_audit(ctx *Alter_server_auditContext) {} + +// ExitAlter_server_audit is called when production alter_server_audit is exited. +func (s *BaseTSqlParserListener) ExitAlter_server_audit(ctx *Alter_server_auditContext) {} + +// EnterCreate_server_audit is called when production create_server_audit is entered. +func (s *BaseTSqlParserListener) EnterCreate_server_audit(ctx *Create_server_auditContext) {} + +// ExitCreate_server_audit is called when production create_server_audit is exited. +func (s *BaseTSqlParserListener) ExitCreate_server_audit(ctx *Create_server_auditContext) {} + +// EnterAlter_server_audit_specification is called when production alter_server_audit_specification is entered. +func (s *BaseTSqlParserListener) EnterAlter_server_audit_specification(ctx *Alter_server_audit_specificationContext) { +} + +// ExitAlter_server_audit_specification is called when production alter_server_audit_specification is exited. +func (s *BaseTSqlParserListener) ExitAlter_server_audit_specification(ctx *Alter_server_audit_specificationContext) { +} + +// EnterCreate_server_audit_specification is called when production create_server_audit_specification is entered. +func (s *BaseTSqlParserListener) EnterCreate_server_audit_specification(ctx *Create_server_audit_specificationContext) { +} + +// ExitCreate_server_audit_specification is called when production create_server_audit_specification is exited. +func (s *BaseTSqlParserListener) ExitCreate_server_audit_specification(ctx *Create_server_audit_specificationContext) { +} + +// EnterAlter_server_configuration is called when production alter_server_configuration is entered. +func (s *BaseTSqlParserListener) EnterAlter_server_configuration(ctx *Alter_server_configurationContext) { +} + +// ExitAlter_server_configuration is called when production alter_server_configuration is exited. +func (s *BaseTSqlParserListener) ExitAlter_server_configuration(ctx *Alter_server_configurationContext) { +} + +// EnterAlter_server_role is called when production alter_server_role is entered. +func (s *BaseTSqlParserListener) EnterAlter_server_role(ctx *Alter_server_roleContext) {} + +// ExitAlter_server_role is called when production alter_server_role is exited. +func (s *BaseTSqlParserListener) ExitAlter_server_role(ctx *Alter_server_roleContext) {} + +// EnterCreate_server_role is called when production create_server_role is entered. +func (s *BaseTSqlParserListener) EnterCreate_server_role(ctx *Create_server_roleContext) {} + +// ExitCreate_server_role is called when production create_server_role is exited. +func (s *BaseTSqlParserListener) ExitCreate_server_role(ctx *Create_server_roleContext) {} + +// EnterAlter_server_role_pdw is called when production alter_server_role_pdw is entered. +func (s *BaseTSqlParserListener) EnterAlter_server_role_pdw(ctx *Alter_server_role_pdwContext) {} + +// ExitAlter_server_role_pdw is called when production alter_server_role_pdw is exited. +func (s *BaseTSqlParserListener) ExitAlter_server_role_pdw(ctx *Alter_server_role_pdwContext) {} + +// EnterAlter_service is called when production alter_service is entered. +func (s *BaseTSqlParserListener) EnterAlter_service(ctx *Alter_serviceContext) {} + +// ExitAlter_service is called when production alter_service is exited. +func (s *BaseTSqlParserListener) ExitAlter_service(ctx *Alter_serviceContext) {} + +// EnterOpt_arg_clause is called when production opt_arg_clause is entered. +func (s *BaseTSqlParserListener) EnterOpt_arg_clause(ctx *Opt_arg_clauseContext) {} + +// ExitOpt_arg_clause is called when production opt_arg_clause is exited. +func (s *BaseTSqlParserListener) ExitOpt_arg_clause(ctx *Opt_arg_clauseContext) {} + +// EnterCreate_service is called when production create_service is entered. +func (s *BaseTSqlParserListener) EnterCreate_service(ctx *Create_serviceContext) {} + +// ExitCreate_service is called when production create_service is exited. +func (s *BaseTSqlParserListener) ExitCreate_service(ctx *Create_serviceContext) {} + +// EnterAlter_service_master_key is called when production alter_service_master_key is entered. +func (s *BaseTSqlParserListener) EnterAlter_service_master_key(ctx *Alter_service_master_keyContext) { +} + +// ExitAlter_service_master_key is called when production alter_service_master_key is exited. +func (s *BaseTSqlParserListener) ExitAlter_service_master_key(ctx *Alter_service_master_keyContext) {} + +// EnterAlter_symmetric_key is called when production alter_symmetric_key is entered. +func (s *BaseTSqlParserListener) EnterAlter_symmetric_key(ctx *Alter_symmetric_keyContext) {} + +// ExitAlter_symmetric_key is called when production alter_symmetric_key is exited. +func (s *BaseTSqlParserListener) ExitAlter_symmetric_key(ctx *Alter_symmetric_keyContext) {} + +// EnterCreate_synonym is called when production create_synonym is entered. +func (s *BaseTSqlParserListener) EnterCreate_synonym(ctx *Create_synonymContext) {} + +// ExitCreate_synonym is called when production create_synonym is exited. +func (s *BaseTSqlParserListener) ExitCreate_synonym(ctx *Create_synonymContext) {} + +// EnterAlter_user is called when production alter_user is entered. +func (s *BaseTSqlParserListener) EnterAlter_user(ctx *Alter_userContext) {} + +// ExitAlter_user is called when production alter_user is exited. +func (s *BaseTSqlParserListener) ExitAlter_user(ctx *Alter_userContext) {} + +// EnterCreate_user is called when production create_user is entered. +func (s *BaseTSqlParserListener) EnterCreate_user(ctx *Create_userContext) {} + +// ExitCreate_user is called when production create_user is exited. +func (s *BaseTSqlParserListener) ExitCreate_user(ctx *Create_userContext) {} + +// EnterCreate_user_azure_sql_dw is called when production create_user_azure_sql_dw is entered. +func (s *BaseTSqlParserListener) EnterCreate_user_azure_sql_dw(ctx *Create_user_azure_sql_dwContext) { +} + +// ExitCreate_user_azure_sql_dw is called when production create_user_azure_sql_dw is exited. +func (s *BaseTSqlParserListener) ExitCreate_user_azure_sql_dw(ctx *Create_user_azure_sql_dwContext) {} + +// EnterAlter_user_azure_sql is called when production alter_user_azure_sql is entered. +func (s *BaseTSqlParserListener) EnterAlter_user_azure_sql(ctx *Alter_user_azure_sqlContext) {} + +// ExitAlter_user_azure_sql is called when production alter_user_azure_sql is exited. +func (s *BaseTSqlParserListener) ExitAlter_user_azure_sql(ctx *Alter_user_azure_sqlContext) {} + +// EnterAlter_workload_group is called when production alter_workload_group is entered. +func (s *BaseTSqlParserListener) EnterAlter_workload_group(ctx *Alter_workload_groupContext) {} + +// ExitAlter_workload_group is called when production alter_workload_group is exited. +func (s *BaseTSqlParserListener) ExitAlter_workload_group(ctx *Alter_workload_groupContext) {} + +// EnterCreate_workload_group is called when production create_workload_group is entered. +func (s *BaseTSqlParserListener) EnterCreate_workload_group(ctx *Create_workload_groupContext) {} + +// ExitCreate_workload_group is called when production create_workload_group is exited. +func (s *BaseTSqlParserListener) ExitCreate_workload_group(ctx *Create_workload_groupContext) {} + +// EnterCreate_xml_schema_collection is called when production create_xml_schema_collection is entered. +func (s *BaseTSqlParserListener) EnterCreate_xml_schema_collection(ctx *Create_xml_schema_collectionContext) { +} + +// ExitCreate_xml_schema_collection is called when production create_xml_schema_collection is exited. +func (s *BaseTSqlParserListener) ExitCreate_xml_schema_collection(ctx *Create_xml_schema_collectionContext) { +} + +// EnterCreate_partition_function is called when production create_partition_function is entered. +func (s *BaseTSqlParserListener) EnterCreate_partition_function(ctx *Create_partition_functionContext) { +} + +// ExitCreate_partition_function is called when production create_partition_function is exited. +func (s *BaseTSqlParserListener) ExitCreate_partition_function(ctx *Create_partition_functionContext) { +} + +// EnterCreate_partition_scheme is called when production create_partition_scheme is entered. +func (s *BaseTSqlParserListener) EnterCreate_partition_scheme(ctx *Create_partition_schemeContext) {} + +// ExitCreate_partition_scheme is called when production create_partition_scheme is exited. +func (s *BaseTSqlParserListener) ExitCreate_partition_scheme(ctx *Create_partition_schemeContext) {} + +// EnterCreate_queue is called when production create_queue is entered. +func (s *BaseTSqlParserListener) EnterCreate_queue(ctx *Create_queueContext) {} + +// ExitCreate_queue is called when production create_queue is exited. +func (s *BaseTSqlParserListener) ExitCreate_queue(ctx *Create_queueContext) {} + +// EnterQueue_settings is called when production queue_settings is entered. +func (s *BaseTSqlParserListener) EnterQueue_settings(ctx *Queue_settingsContext) {} + +// ExitQueue_settings is called when production queue_settings is exited. +func (s *BaseTSqlParserListener) ExitQueue_settings(ctx *Queue_settingsContext) {} + +// EnterAlter_queue is called when production alter_queue is entered. +func (s *BaseTSqlParserListener) EnterAlter_queue(ctx *Alter_queueContext) {} + +// ExitAlter_queue is called when production alter_queue is exited. +func (s *BaseTSqlParserListener) ExitAlter_queue(ctx *Alter_queueContext) {} + +// EnterQueue_action is called when production queue_action is entered. +func (s *BaseTSqlParserListener) EnterQueue_action(ctx *Queue_actionContext) {} + +// ExitQueue_action is called when production queue_action is exited. +func (s *BaseTSqlParserListener) ExitQueue_action(ctx *Queue_actionContext) {} + +// EnterQueue_rebuild_options is called when production queue_rebuild_options is entered. +func (s *BaseTSqlParserListener) EnterQueue_rebuild_options(ctx *Queue_rebuild_optionsContext) {} + +// ExitQueue_rebuild_options is called when production queue_rebuild_options is exited. +func (s *BaseTSqlParserListener) ExitQueue_rebuild_options(ctx *Queue_rebuild_optionsContext) {} + +// EnterCreate_contract is called when production create_contract is entered. +func (s *BaseTSqlParserListener) EnterCreate_contract(ctx *Create_contractContext) {} + +// ExitCreate_contract is called when production create_contract is exited. +func (s *BaseTSqlParserListener) ExitCreate_contract(ctx *Create_contractContext) {} + +// EnterConversation_statement is called when production conversation_statement is entered. +func (s *BaseTSqlParserListener) EnterConversation_statement(ctx *Conversation_statementContext) {} + +// ExitConversation_statement is called when production conversation_statement is exited. +func (s *BaseTSqlParserListener) ExitConversation_statement(ctx *Conversation_statementContext) {} + +// EnterMessage_statement is called when production message_statement is entered. +func (s *BaseTSqlParserListener) EnterMessage_statement(ctx *Message_statementContext) {} + +// ExitMessage_statement is called when production message_statement is exited. +func (s *BaseTSqlParserListener) ExitMessage_statement(ctx *Message_statementContext) {} + +// EnterMerge_statement is called when production merge_statement is entered. +func (s *BaseTSqlParserListener) EnterMerge_statement(ctx *Merge_statementContext) {} + +// ExitMerge_statement is called when production merge_statement is exited. +func (s *BaseTSqlParserListener) ExitMerge_statement(ctx *Merge_statementContext) {} + +// EnterWhen_matches is called when production when_matches is entered. +func (s *BaseTSqlParserListener) EnterWhen_matches(ctx *When_matchesContext) {} + +// ExitWhen_matches is called when production when_matches is exited. +func (s *BaseTSqlParserListener) ExitWhen_matches(ctx *When_matchesContext) {} + +// EnterMerge_matched is called when production merge_matched is entered. +func (s *BaseTSqlParserListener) EnterMerge_matched(ctx *Merge_matchedContext) {} + +// ExitMerge_matched is called when production merge_matched is exited. +func (s *BaseTSqlParserListener) ExitMerge_matched(ctx *Merge_matchedContext) {} + +// EnterMerge_not_matched is called when production merge_not_matched is entered. +func (s *BaseTSqlParserListener) EnterMerge_not_matched(ctx *Merge_not_matchedContext) {} + +// ExitMerge_not_matched is called when production merge_not_matched is exited. +func (s *BaseTSqlParserListener) ExitMerge_not_matched(ctx *Merge_not_matchedContext) {} + +// EnterDelete_statement is called when production delete_statement is entered. +func (s *BaseTSqlParserListener) EnterDelete_statement(ctx *Delete_statementContext) {} + +// ExitDelete_statement is called when production delete_statement is exited. +func (s *BaseTSqlParserListener) ExitDelete_statement(ctx *Delete_statementContext) {} + +// EnterDelete_statement_from is called when production delete_statement_from is entered. +func (s *BaseTSqlParserListener) EnterDelete_statement_from(ctx *Delete_statement_fromContext) {} + +// ExitDelete_statement_from is called when production delete_statement_from is exited. +func (s *BaseTSqlParserListener) ExitDelete_statement_from(ctx *Delete_statement_fromContext) {} + +// EnterInsert_statement is called when production insert_statement is entered. +func (s *BaseTSqlParserListener) EnterInsert_statement(ctx *Insert_statementContext) {} + +// ExitInsert_statement is called when production insert_statement is exited. +func (s *BaseTSqlParserListener) ExitInsert_statement(ctx *Insert_statementContext) {} + +// EnterInsert_statement_value is called when production insert_statement_value is entered. +func (s *BaseTSqlParserListener) EnterInsert_statement_value(ctx *Insert_statement_valueContext) {} + +// ExitInsert_statement_value is called when production insert_statement_value is exited. +func (s *BaseTSqlParserListener) ExitInsert_statement_value(ctx *Insert_statement_valueContext) {} + +// EnterReceive_statement is called when production receive_statement is entered. +func (s *BaseTSqlParserListener) EnterReceive_statement(ctx *Receive_statementContext) {} + +// ExitReceive_statement is called when production receive_statement is exited. +func (s *BaseTSqlParserListener) ExitReceive_statement(ctx *Receive_statementContext) {} + +// EnterSelect_statement_standalone is called when production select_statement_standalone is entered. +func (s *BaseTSqlParserListener) EnterSelect_statement_standalone(ctx *Select_statement_standaloneContext) { +} + +// ExitSelect_statement_standalone is called when production select_statement_standalone is exited. +func (s *BaseTSqlParserListener) ExitSelect_statement_standalone(ctx *Select_statement_standaloneContext) { +} + +// EnterSelect_statement is called when production select_statement is entered. +func (s *BaseTSqlParserListener) EnterSelect_statement(ctx *Select_statementContext) {} + +// ExitSelect_statement is called when production select_statement is exited. +func (s *BaseTSqlParserListener) ExitSelect_statement(ctx *Select_statementContext) {} + +// EnterTime is called when production time is entered. +func (s *BaseTSqlParserListener) EnterTime(ctx *TimeContext) {} + +// ExitTime is called when production time is exited. +func (s *BaseTSqlParserListener) ExitTime(ctx *TimeContext) {} + +// EnterUpdate_statement is called when production update_statement is entered. +func (s *BaseTSqlParserListener) EnterUpdate_statement(ctx *Update_statementContext) {} + +// ExitUpdate_statement is called when production update_statement is exited. +func (s *BaseTSqlParserListener) ExitUpdate_statement(ctx *Update_statementContext) {} + +// EnterOutput_clause is called when production output_clause is entered. +func (s *BaseTSqlParserListener) EnterOutput_clause(ctx *Output_clauseContext) {} + +// ExitOutput_clause is called when production output_clause is exited. +func (s *BaseTSqlParserListener) ExitOutput_clause(ctx *Output_clauseContext) {} + +// EnterOutput_dml_list_elem is called when production output_dml_list_elem is entered. +func (s *BaseTSqlParserListener) EnterOutput_dml_list_elem(ctx *Output_dml_list_elemContext) {} + +// ExitOutput_dml_list_elem is called when production output_dml_list_elem is exited. +func (s *BaseTSqlParserListener) ExitOutput_dml_list_elem(ctx *Output_dml_list_elemContext) {} + +// EnterCreate_database is called when production create_database is entered. +func (s *BaseTSqlParserListener) EnterCreate_database(ctx *Create_databaseContext) {} + +// ExitCreate_database is called when production create_database is exited. +func (s *BaseTSqlParserListener) ExitCreate_database(ctx *Create_databaseContext) {} + +// EnterCreate_index is called when production create_index is entered. +func (s *BaseTSqlParserListener) EnterCreate_index(ctx *Create_indexContext) {} + +// ExitCreate_index is called when production create_index is exited. +func (s *BaseTSqlParserListener) ExitCreate_index(ctx *Create_indexContext) {} + +// EnterCreate_spatial_index is called when production create_spatial_index is entered. +func (s *BaseTSqlParserListener) EnterCreate_spatial_index(ctx *Create_spatial_indexContext) {} + +// ExitCreate_spatial_index is called when production create_spatial_index is exited. +func (s *BaseTSqlParserListener) ExitCreate_spatial_index(ctx *Create_spatial_indexContext) {} + +// EnterSpatial_tessellation_scheme is called when production spatial_tessellation_scheme is entered. +func (s *BaseTSqlParserListener) EnterSpatial_tessellation_scheme(ctx *Spatial_tessellation_schemeContext) { +} + +// ExitSpatial_tessellation_scheme is called when production spatial_tessellation_scheme is exited. +func (s *BaseTSqlParserListener) ExitSpatial_tessellation_scheme(ctx *Spatial_tessellation_schemeContext) { +} + +// EnterSpatial_index_options is called when production spatial_index_options is entered. +func (s *BaseTSqlParserListener) EnterSpatial_index_options(ctx *Spatial_index_optionsContext) {} + +// ExitSpatial_index_options is called when production spatial_index_options is exited. +func (s *BaseTSqlParserListener) ExitSpatial_index_options(ctx *Spatial_index_optionsContext) {} + +// EnterSpatial_index_option is called when production spatial_index_option is entered. +func (s *BaseTSqlParserListener) EnterSpatial_index_option(ctx *Spatial_index_optionContext) {} + +// ExitSpatial_index_option is called when production spatial_index_option is exited. +func (s *BaseTSqlParserListener) ExitSpatial_index_option(ctx *Spatial_index_optionContext) {} + +// EnterSigned_decimal is called when production signed_decimal is entered. +func (s *BaseTSqlParserListener) EnterSigned_decimal(ctx *Signed_decimalContext) {} + +// ExitSigned_decimal is called when production signed_decimal is exited. +func (s *BaseTSqlParserListener) ExitSigned_decimal(ctx *Signed_decimalContext) {} + +// EnterSpatial_grid_level is called when production spatial_grid_level is entered. +func (s *BaseTSqlParserListener) EnterSpatial_grid_level(ctx *Spatial_grid_levelContext) {} + +// ExitSpatial_grid_level is called when production spatial_grid_level is exited. +func (s *BaseTSqlParserListener) ExitSpatial_grid_level(ctx *Spatial_grid_levelContext) {} + +// EnterSpatial_grid_density is called when production spatial_grid_density is entered. +func (s *BaseTSqlParserListener) EnterSpatial_grid_density(ctx *Spatial_grid_densityContext) {} + +// ExitSpatial_grid_density is called when production spatial_grid_density is exited. +func (s *BaseTSqlParserListener) ExitSpatial_grid_density(ctx *Spatial_grid_densityContext) {} + +// EnterCreate_index_options is called when production create_index_options is entered. +func (s *BaseTSqlParserListener) EnterCreate_index_options(ctx *Create_index_optionsContext) {} + +// ExitCreate_index_options is called when production create_index_options is exited. +func (s *BaseTSqlParserListener) ExitCreate_index_options(ctx *Create_index_optionsContext) {} + +// EnterRelational_index_option is called when production relational_index_option is entered. +func (s *BaseTSqlParserListener) EnterRelational_index_option(ctx *Relational_index_optionContext) {} + +// ExitRelational_index_option is called when production relational_index_option is exited. +func (s *BaseTSqlParserListener) ExitRelational_index_option(ctx *Relational_index_optionContext) {} + +// EnterAlter_index is called when production alter_index is entered. +func (s *BaseTSqlParserListener) EnterAlter_index(ctx *Alter_indexContext) {} + +// ExitAlter_index is called when production alter_index is exited. +func (s *BaseTSqlParserListener) ExitAlter_index(ctx *Alter_indexContext) {} + +// EnterResumable_index_options is called when production resumable_index_options is entered. +func (s *BaseTSqlParserListener) EnterResumable_index_options(ctx *Resumable_index_optionsContext) {} + +// ExitResumable_index_options is called when production resumable_index_options is exited. +func (s *BaseTSqlParserListener) ExitResumable_index_options(ctx *Resumable_index_optionsContext) {} + +// EnterResumable_index_option is called when production resumable_index_option is entered. +func (s *BaseTSqlParserListener) EnterResumable_index_option(ctx *Resumable_index_optionContext) {} + +// ExitResumable_index_option is called when production resumable_index_option is exited. +func (s *BaseTSqlParserListener) ExitResumable_index_option(ctx *Resumable_index_optionContext) {} + +// EnterReorganize_partition is called when production reorganize_partition is entered. +func (s *BaseTSqlParserListener) EnterReorganize_partition(ctx *Reorganize_partitionContext) {} + +// ExitReorganize_partition is called when production reorganize_partition is exited. +func (s *BaseTSqlParserListener) ExitReorganize_partition(ctx *Reorganize_partitionContext) {} + +// EnterReorganize_options is called when production reorganize_options is entered. +func (s *BaseTSqlParserListener) EnterReorganize_options(ctx *Reorganize_optionsContext) {} + +// ExitReorganize_options is called when production reorganize_options is exited. +func (s *BaseTSqlParserListener) ExitReorganize_options(ctx *Reorganize_optionsContext) {} + +// EnterReorganize_option is called when production reorganize_option is entered. +func (s *BaseTSqlParserListener) EnterReorganize_option(ctx *Reorganize_optionContext) {} + +// ExitReorganize_option is called when production reorganize_option is exited. +func (s *BaseTSqlParserListener) ExitReorganize_option(ctx *Reorganize_optionContext) {} + +// EnterSet_index_options is called when production set_index_options is entered. +func (s *BaseTSqlParserListener) EnterSet_index_options(ctx *Set_index_optionsContext) {} + +// ExitSet_index_options is called when production set_index_options is exited. +func (s *BaseTSqlParserListener) ExitSet_index_options(ctx *Set_index_optionsContext) {} + +// EnterSet_index_option is called when production set_index_option is entered. +func (s *BaseTSqlParserListener) EnterSet_index_option(ctx *Set_index_optionContext) {} + +// ExitSet_index_option is called when production set_index_option is exited. +func (s *BaseTSqlParserListener) ExitSet_index_option(ctx *Set_index_optionContext) {} + +// EnterRebuild_partition is called when production rebuild_partition is entered. +func (s *BaseTSqlParserListener) EnterRebuild_partition(ctx *Rebuild_partitionContext) {} + +// ExitRebuild_partition is called when production rebuild_partition is exited. +func (s *BaseTSqlParserListener) ExitRebuild_partition(ctx *Rebuild_partitionContext) {} + +// EnterRebuild_index_options is called when production rebuild_index_options is entered. +func (s *BaseTSqlParserListener) EnterRebuild_index_options(ctx *Rebuild_index_optionsContext) {} + +// ExitRebuild_index_options is called when production rebuild_index_options is exited. +func (s *BaseTSqlParserListener) ExitRebuild_index_options(ctx *Rebuild_index_optionsContext) {} + +// EnterRebuild_index_option is called when production rebuild_index_option is entered. +func (s *BaseTSqlParserListener) EnterRebuild_index_option(ctx *Rebuild_index_optionContext) {} + +// ExitRebuild_index_option is called when production rebuild_index_option is exited. +func (s *BaseTSqlParserListener) ExitRebuild_index_option(ctx *Rebuild_index_optionContext) {} + +// EnterSingle_partition_rebuild_index_options is called when production single_partition_rebuild_index_options is entered. +func (s *BaseTSqlParserListener) EnterSingle_partition_rebuild_index_options(ctx *Single_partition_rebuild_index_optionsContext) { +} + +// ExitSingle_partition_rebuild_index_options is called when production single_partition_rebuild_index_options is exited. +func (s *BaseTSqlParserListener) ExitSingle_partition_rebuild_index_options(ctx *Single_partition_rebuild_index_optionsContext) { +} + +// EnterSingle_partition_rebuild_index_option is called when production single_partition_rebuild_index_option is entered. +func (s *BaseTSqlParserListener) EnterSingle_partition_rebuild_index_option(ctx *Single_partition_rebuild_index_optionContext) { +} + +// ExitSingle_partition_rebuild_index_option is called when production single_partition_rebuild_index_option is exited. +func (s *BaseTSqlParserListener) ExitSingle_partition_rebuild_index_option(ctx *Single_partition_rebuild_index_optionContext) { +} + +// EnterOn_partitions is called when production on_partitions is entered. +func (s *BaseTSqlParserListener) EnterOn_partitions(ctx *On_partitionsContext) {} + +// ExitOn_partitions is called when production on_partitions is exited. +func (s *BaseTSqlParserListener) ExitOn_partitions(ctx *On_partitionsContext) {} + +// EnterCreate_columnstore_index is called when production create_columnstore_index is entered. +func (s *BaseTSqlParserListener) EnterCreate_columnstore_index(ctx *Create_columnstore_indexContext) { +} + +// ExitCreate_columnstore_index is called when production create_columnstore_index is exited. +func (s *BaseTSqlParserListener) ExitCreate_columnstore_index(ctx *Create_columnstore_indexContext) {} + +// EnterCreate_columnstore_index_options is called when production create_columnstore_index_options is entered. +func (s *BaseTSqlParserListener) EnterCreate_columnstore_index_options(ctx *Create_columnstore_index_optionsContext) { +} + +// ExitCreate_columnstore_index_options is called when production create_columnstore_index_options is exited. +func (s *BaseTSqlParserListener) ExitCreate_columnstore_index_options(ctx *Create_columnstore_index_optionsContext) { +} + +// EnterColumnstore_index_option is called when production columnstore_index_option is entered. +func (s *BaseTSqlParserListener) EnterColumnstore_index_option(ctx *Columnstore_index_optionContext) { +} + +// ExitColumnstore_index_option is called when production columnstore_index_option is exited. +func (s *BaseTSqlParserListener) ExitColumnstore_index_option(ctx *Columnstore_index_optionContext) {} + +// EnterCreate_nonclustered_columnstore_index is called when production create_nonclustered_columnstore_index is entered. +func (s *BaseTSqlParserListener) EnterCreate_nonclustered_columnstore_index(ctx *Create_nonclustered_columnstore_indexContext) { +} + +// ExitCreate_nonclustered_columnstore_index is called when production create_nonclustered_columnstore_index is exited. +func (s *BaseTSqlParserListener) ExitCreate_nonclustered_columnstore_index(ctx *Create_nonclustered_columnstore_indexContext) { +} + +// EnterCreate_xml_index is called when production create_xml_index is entered. +func (s *BaseTSqlParserListener) EnterCreate_xml_index(ctx *Create_xml_indexContext) {} + +// ExitCreate_xml_index is called when production create_xml_index is exited. +func (s *BaseTSqlParserListener) ExitCreate_xml_index(ctx *Create_xml_indexContext) {} + +// EnterXml_index_options is called when production xml_index_options is entered. +func (s *BaseTSqlParserListener) EnterXml_index_options(ctx *Xml_index_optionsContext) {} + +// ExitXml_index_options is called when production xml_index_options is exited. +func (s *BaseTSqlParserListener) ExitXml_index_options(ctx *Xml_index_optionsContext) {} + +// EnterXml_index_option is called when production xml_index_option is entered. +func (s *BaseTSqlParserListener) EnterXml_index_option(ctx *Xml_index_optionContext) {} + +// ExitXml_index_option is called when production xml_index_option is exited. +func (s *BaseTSqlParserListener) ExitXml_index_option(ctx *Xml_index_optionContext) {} + +// EnterCreate_or_alter_procedure is called when production create_or_alter_procedure is entered. +func (s *BaseTSqlParserListener) EnterCreate_or_alter_procedure(ctx *Create_or_alter_procedureContext) { +} + +// ExitCreate_or_alter_procedure is called when production create_or_alter_procedure is exited. +func (s *BaseTSqlParserListener) ExitCreate_or_alter_procedure(ctx *Create_or_alter_procedureContext) { +} + +// EnterAs_external_name is called when production as_external_name is entered. +func (s *BaseTSqlParserListener) EnterAs_external_name(ctx *As_external_nameContext) {} + +// ExitAs_external_name is called when production as_external_name is exited. +func (s *BaseTSqlParserListener) ExitAs_external_name(ctx *As_external_nameContext) {} + +// EnterCreate_or_alter_trigger is called when production create_or_alter_trigger is entered. +func (s *BaseTSqlParserListener) EnterCreate_or_alter_trigger(ctx *Create_or_alter_triggerContext) {} + +// ExitCreate_or_alter_trigger is called when production create_or_alter_trigger is exited. +func (s *BaseTSqlParserListener) ExitCreate_or_alter_trigger(ctx *Create_or_alter_triggerContext) {} + +// EnterCreate_or_alter_dml_trigger is called when production create_or_alter_dml_trigger is entered. +func (s *BaseTSqlParserListener) EnterCreate_or_alter_dml_trigger(ctx *Create_or_alter_dml_triggerContext) { +} + +// ExitCreate_or_alter_dml_trigger is called when production create_or_alter_dml_trigger is exited. +func (s *BaseTSqlParserListener) ExitCreate_or_alter_dml_trigger(ctx *Create_or_alter_dml_triggerContext) { +} + +// EnterDml_trigger_option is called when production dml_trigger_option is entered. +func (s *BaseTSqlParserListener) EnterDml_trigger_option(ctx *Dml_trigger_optionContext) {} + +// ExitDml_trigger_option is called when production dml_trigger_option is exited. +func (s *BaseTSqlParserListener) ExitDml_trigger_option(ctx *Dml_trigger_optionContext) {} + +// EnterDml_trigger_operation is called when production dml_trigger_operation is entered. +func (s *BaseTSqlParserListener) EnterDml_trigger_operation(ctx *Dml_trigger_operationContext) {} + +// ExitDml_trigger_operation is called when production dml_trigger_operation is exited. +func (s *BaseTSqlParserListener) ExitDml_trigger_operation(ctx *Dml_trigger_operationContext) {} + +// EnterCreate_or_alter_ddl_trigger is called when production create_or_alter_ddl_trigger is entered. +func (s *BaseTSqlParserListener) EnterCreate_or_alter_ddl_trigger(ctx *Create_or_alter_ddl_triggerContext) { +} + +// ExitCreate_or_alter_ddl_trigger is called when production create_or_alter_ddl_trigger is exited. +func (s *BaseTSqlParserListener) ExitCreate_or_alter_ddl_trigger(ctx *Create_or_alter_ddl_triggerContext) { +} + +// EnterDdl_trigger_operation is called when production ddl_trigger_operation is entered. +func (s *BaseTSqlParserListener) EnterDdl_trigger_operation(ctx *Ddl_trigger_operationContext) {} + +// ExitDdl_trigger_operation is called when production ddl_trigger_operation is exited. +func (s *BaseTSqlParserListener) ExitDdl_trigger_operation(ctx *Ddl_trigger_operationContext) {} + +// EnterCreate_or_alter_function is called when production create_or_alter_function is entered. +func (s *BaseTSqlParserListener) EnterCreate_or_alter_function(ctx *Create_or_alter_functionContext) { +} + +// ExitCreate_or_alter_function is called when production create_or_alter_function is exited. +func (s *BaseTSqlParserListener) ExitCreate_or_alter_function(ctx *Create_or_alter_functionContext) {} + +// EnterFunc_body_returns_select is called when production func_body_returns_select is entered. +func (s *BaseTSqlParserListener) EnterFunc_body_returns_select(ctx *Func_body_returns_selectContext) { +} + +// ExitFunc_body_returns_select is called when production func_body_returns_select is exited. +func (s *BaseTSqlParserListener) ExitFunc_body_returns_select(ctx *Func_body_returns_selectContext) {} + +// EnterFunc_body_returns_table is called when production func_body_returns_table is entered. +func (s *BaseTSqlParserListener) EnterFunc_body_returns_table(ctx *Func_body_returns_tableContext) {} + +// ExitFunc_body_returns_table is called when production func_body_returns_table is exited. +func (s *BaseTSqlParserListener) ExitFunc_body_returns_table(ctx *Func_body_returns_tableContext) {} + +// EnterFunc_body_returns_scalar is called when production func_body_returns_scalar is entered. +func (s *BaseTSqlParserListener) EnterFunc_body_returns_scalar(ctx *Func_body_returns_scalarContext) { +} + +// ExitFunc_body_returns_scalar is called when production func_body_returns_scalar is exited. +func (s *BaseTSqlParserListener) ExitFunc_body_returns_scalar(ctx *Func_body_returns_scalarContext) {} + +// EnterProcedure_param_default_value is called when production procedure_param_default_value is entered. +func (s *BaseTSqlParserListener) EnterProcedure_param_default_value(ctx *Procedure_param_default_valueContext) { +} + +// ExitProcedure_param_default_value is called when production procedure_param_default_value is exited. +func (s *BaseTSqlParserListener) ExitProcedure_param_default_value(ctx *Procedure_param_default_valueContext) { +} + +// EnterProcedure_param is called when production procedure_param is entered. +func (s *BaseTSqlParserListener) EnterProcedure_param(ctx *Procedure_paramContext) {} + +// ExitProcedure_param is called when production procedure_param is exited. +func (s *BaseTSqlParserListener) ExitProcedure_param(ctx *Procedure_paramContext) {} + +// EnterProcedure_option is called when production procedure_option is entered. +func (s *BaseTSqlParserListener) EnterProcedure_option(ctx *Procedure_optionContext) {} + +// ExitProcedure_option is called when production procedure_option is exited. +func (s *BaseTSqlParserListener) ExitProcedure_option(ctx *Procedure_optionContext) {} + +// EnterFunction_option is called when production function_option is entered. +func (s *BaseTSqlParserListener) EnterFunction_option(ctx *Function_optionContext) {} + +// ExitFunction_option is called when production function_option is exited. +func (s *BaseTSqlParserListener) ExitFunction_option(ctx *Function_optionContext) {} + +// EnterCreate_statistics is called when production create_statistics is entered. +func (s *BaseTSqlParserListener) EnterCreate_statistics(ctx *Create_statisticsContext) {} + +// ExitCreate_statistics is called when production create_statistics is exited. +func (s *BaseTSqlParserListener) ExitCreate_statistics(ctx *Create_statisticsContext) {} + +// EnterUpdate_statistics is called when production update_statistics is entered. +func (s *BaseTSqlParserListener) EnterUpdate_statistics(ctx *Update_statisticsContext) {} + +// ExitUpdate_statistics is called when production update_statistics is exited. +func (s *BaseTSqlParserListener) ExitUpdate_statistics(ctx *Update_statisticsContext) {} + +// EnterUpdate_statistics_options is called when production update_statistics_options is entered. +func (s *BaseTSqlParserListener) EnterUpdate_statistics_options(ctx *Update_statistics_optionsContext) { +} + +// ExitUpdate_statistics_options is called when production update_statistics_options is exited. +func (s *BaseTSqlParserListener) ExitUpdate_statistics_options(ctx *Update_statistics_optionsContext) { +} + +// EnterUpdate_statistics_option is called when production update_statistics_option is entered. +func (s *BaseTSqlParserListener) EnterUpdate_statistics_option(ctx *Update_statistics_optionContext) { +} + +// ExitUpdate_statistics_option is called when production update_statistics_option is exited. +func (s *BaseTSqlParserListener) ExitUpdate_statistics_option(ctx *Update_statistics_optionContext) {} + +// EnterCreate_table is called when production create_table is entered. +func (s *BaseTSqlParserListener) EnterCreate_table(ctx *Create_tableContext) {} + +// ExitCreate_table is called when production create_table is exited. +func (s *BaseTSqlParserListener) ExitCreate_table(ctx *Create_tableContext) {} + +// EnterTable_indices is called when production table_indices is entered. +func (s *BaseTSqlParserListener) EnterTable_indices(ctx *Table_indicesContext) {} + +// ExitTable_indices is called when production table_indices is exited. +func (s *BaseTSqlParserListener) ExitTable_indices(ctx *Table_indicesContext) {} + +// EnterTable_options is called when production table_options is entered. +func (s *BaseTSqlParserListener) EnterTable_options(ctx *Table_optionsContext) {} + +// ExitTable_options is called when production table_options is exited. +func (s *BaseTSqlParserListener) ExitTable_options(ctx *Table_optionsContext) {} + +// EnterTable_option is called when production table_option is entered. +func (s *BaseTSqlParserListener) EnterTable_option(ctx *Table_optionContext) {} + +// ExitTable_option is called when production table_option is exited. +func (s *BaseTSqlParserListener) ExitTable_option(ctx *Table_optionContext) {} + +// EnterCreate_table_index_options is called when production create_table_index_options is entered. +func (s *BaseTSqlParserListener) EnterCreate_table_index_options(ctx *Create_table_index_optionsContext) { +} + +// ExitCreate_table_index_options is called when production create_table_index_options is exited. +func (s *BaseTSqlParserListener) ExitCreate_table_index_options(ctx *Create_table_index_optionsContext) { +} + +// EnterCreate_table_index_option is called when production create_table_index_option is entered. +func (s *BaseTSqlParserListener) EnterCreate_table_index_option(ctx *Create_table_index_optionContext) { +} + +// ExitCreate_table_index_option is called when production create_table_index_option is exited. +func (s *BaseTSqlParserListener) ExitCreate_table_index_option(ctx *Create_table_index_optionContext) { +} + +// EnterCreate_view is called when production create_view is entered. +func (s *BaseTSqlParserListener) EnterCreate_view(ctx *Create_viewContext) {} + +// ExitCreate_view is called when production create_view is exited. +func (s *BaseTSqlParserListener) ExitCreate_view(ctx *Create_viewContext) {} + +// EnterView_attribute is called when production view_attribute is entered. +func (s *BaseTSqlParserListener) EnterView_attribute(ctx *View_attributeContext) {} + +// ExitView_attribute is called when production view_attribute is exited. +func (s *BaseTSqlParserListener) ExitView_attribute(ctx *View_attributeContext) {} + +// EnterAlter_table is called when production alter_table is entered. +func (s *BaseTSqlParserListener) EnterAlter_table(ctx *Alter_tableContext) {} + +// ExitAlter_table is called when production alter_table is exited. +func (s *BaseTSqlParserListener) ExitAlter_table(ctx *Alter_tableContext) {} + +// EnterSwitch_partition is called when production switch_partition is entered. +func (s *BaseTSqlParserListener) EnterSwitch_partition(ctx *Switch_partitionContext) {} + +// ExitSwitch_partition is called when production switch_partition is exited. +func (s *BaseTSqlParserListener) ExitSwitch_partition(ctx *Switch_partitionContext) {} + +// EnterLow_priority_lock_wait is called when production low_priority_lock_wait is entered. +func (s *BaseTSqlParserListener) EnterLow_priority_lock_wait(ctx *Low_priority_lock_waitContext) {} + +// ExitLow_priority_lock_wait is called when production low_priority_lock_wait is exited. +func (s *BaseTSqlParserListener) ExitLow_priority_lock_wait(ctx *Low_priority_lock_waitContext) {} + +// EnterAlter_database is called when production alter_database is entered. +func (s *BaseTSqlParserListener) EnterAlter_database(ctx *Alter_databaseContext) {} + +// ExitAlter_database is called when production alter_database is exited. +func (s *BaseTSqlParserListener) ExitAlter_database(ctx *Alter_databaseContext) {} + +// EnterAdd_or_modify_files is called when production add_or_modify_files is entered. +func (s *BaseTSqlParserListener) EnterAdd_or_modify_files(ctx *Add_or_modify_filesContext) {} + +// ExitAdd_or_modify_files is called when production add_or_modify_files is exited. +func (s *BaseTSqlParserListener) ExitAdd_or_modify_files(ctx *Add_or_modify_filesContext) {} + +// EnterFilespec is called when production filespec is entered. +func (s *BaseTSqlParserListener) EnterFilespec(ctx *FilespecContext) {} + +// ExitFilespec is called when production filespec is exited. +func (s *BaseTSqlParserListener) ExitFilespec(ctx *FilespecContext) {} + +// EnterAdd_or_modify_filegroups is called when production add_or_modify_filegroups is entered. +func (s *BaseTSqlParserListener) EnterAdd_or_modify_filegroups(ctx *Add_or_modify_filegroupsContext) { +} + +// ExitAdd_or_modify_filegroups is called when production add_or_modify_filegroups is exited. +func (s *BaseTSqlParserListener) ExitAdd_or_modify_filegroups(ctx *Add_or_modify_filegroupsContext) {} + +// EnterFilegroup_updatability_option is called when production filegroup_updatability_option is entered. +func (s *BaseTSqlParserListener) EnterFilegroup_updatability_option(ctx *Filegroup_updatability_optionContext) { +} + +// ExitFilegroup_updatability_option is called when production filegroup_updatability_option is exited. +func (s *BaseTSqlParserListener) ExitFilegroup_updatability_option(ctx *Filegroup_updatability_optionContext) { +} + +// EnterDatabase_optionspec is called when production database_optionspec is entered. +func (s *BaseTSqlParserListener) EnterDatabase_optionspec(ctx *Database_optionspecContext) {} + +// ExitDatabase_optionspec is called when production database_optionspec is exited. +func (s *BaseTSqlParserListener) ExitDatabase_optionspec(ctx *Database_optionspecContext) {} + +// EnterAuto_option is called when production auto_option is entered. +func (s *BaseTSqlParserListener) EnterAuto_option(ctx *Auto_optionContext) {} + +// ExitAuto_option is called when production auto_option is exited. +func (s *BaseTSqlParserListener) ExitAuto_option(ctx *Auto_optionContext) {} + +// EnterChange_tracking_option is called when production change_tracking_option is entered. +func (s *BaseTSqlParserListener) EnterChange_tracking_option(ctx *Change_tracking_optionContext) {} + +// ExitChange_tracking_option is called when production change_tracking_option is exited. +func (s *BaseTSqlParserListener) ExitChange_tracking_option(ctx *Change_tracking_optionContext) {} + +// EnterChange_tracking_option_list is called when production change_tracking_option_list is entered. +func (s *BaseTSqlParserListener) EnterChange_tracking_option_list(ctx *Change_tracking_option_listContext) { +} + +// ExitChange_tracking_option_list is called when production change_tracking_option_list is exited. +func (s *BaseTSqlParserListener) ExitChange_tracking_option_list(ctx *Change_tracking_option_listContext) { +} + +// EnterContainment_option is called when production containment_option is entered. +func (s *BaseTSqlParserListener) EnterContainment_option(ctx *Containment_optionContext) {} + +// ExitContainment_option is called when production containment_option is exited. +func (s *BaseTSqlParserListener) ExitContainment_option(ctx *Containment_optionContext) {} + +// EnterCursor_option is called when production cursor_option is entered. +func (s *BaseTSqlParserListener) EnterCursor_option(ctx *Cursor_optionContext) {} + +// ExitCursor_option is called when production cursor_option is exited. +func (s *BaseTSqlParserListener) ExitCursor_option(ctx *Cursor_optionContext) {} + +// EnterAlter_endpoint is called when production alter_endpoint is entered. +func (s *BaseTSqlParserListener) EnterAlter_endpoint(ctx *Alter_endpointContext) {} + +// ExitAlter_endpoint is called when production alter_endpoint is exited. +func (s *BaseTSqlParserListener) ExitAlter_endpoint(ctx *Alter_endpointContext) {} + +// EnterDatabase_mirroring_option is called when production database_mirroring_option is entered. +func (s *BaseTSqlParserListener) EnterDatabase_mirroring_option(ctx *Database_mirroring_optionContext) { +} + +// ExitDatabase_mirroring_option is called when production database_mirroring_option is exited. +func (s *BaseTSqlParserListener) ExitDatabase_mirroring_option(ctx *Database_mirroring_optionContext) { +} + +// EnterMirroring_set_option is called when production mirroring_set_option is entered. +func (s *BaseTSqlParserListener) EnterMirroring_set_option(ctx *Mirroring_set_optionContext) {} + +// ExitMirroring_set_option is called when production mirroring_set_option is exited. +func (s *BaseTSqlParserListener) ExitMirroring_set_option(ctx *Mirroring_set_optionContext) {} + +// EnterMirroring_partner is called when production mirroring_partner is entered. +func (s *BaseTSqlParserListener) EnterMirroring_partner(ctx *Mirroring_partnerContext) {} + +// ExitMirroring_partner is called when production mirroring_partner is exited. +func (s *BaseTSqlParserListener) ExitMirroring_partner(ctx *Mirroring_partnerContext) {} + +// EnterMirroring_witness is called when production mirroring_witness is entered. +func (s *BaseTSqlParserListener) EnterMirroring_witness(ctx *Mirroring_witnessContext) {} + +// ExitMirroring_witness is called when production mirroring_witness is exited. +func (s *BaseTSqlParserListener) ExitMirroring_witness(ctx *Mirroring_witnessContext) {} + +// EnterWitness_partner_equal is called when production witness_partner_equal is entered. +func (s *BaseTSqlParserListener) EnterWitness_partner_equal(ctx *Witness_partner_equalContext) {} + +// ExitWitness_partner_equal is called when production witness_partner_equal is exited. +func (s *BaseTSqlParserListener) ExitWitness_partner_equal(ctx *Witness_partner_equalContext) {} + +// EnterPartner_option is called when production partner_option is entered. +func (s *BaseTSqlParserListener) EnterPartner_option(ctx *Partner_optionContext) {} + +// ExitPartner_option is called when production partner_option is exited. +func (s *BaseTSqlParserListener) ExitPartner_option(ctx *Partner_optionContext) {} + +// EnterWitness_option is called when production witness_option is entered. +func (s *BaseTSqlParserListener) EnterWitness_option(ctx *Witness_optionContext) {} + +// ExitWitness_option is called when production witness_option is exited. +func (s *BaseTSqlParserListener) ExitWitness_option(ctx *Witness_optionContext) {} + +// EnterWitness_server is called when production witness_server is entered. +func (s *BaseTSqlParserListener) EnterWitness_server(ctx *Witness_serverContext) {} + +// ExitWitness_server is called when production witness_server is exited. +func (s *BaseTSqlParserListener) ExitWitness_server(ctx *Witness_serverContext) {} + +// EnterPartner_server is called when production partner_server is entered. +func (s *BaseTSqlParserListener) EnterPartner_server(ctx *Partner_serverContext) {} + +// ExitPartner_server is called when production partner_server is exited. +func (s *BaseTSqlParserListener) ExitPartner_server(ctx *Partner_serverContext) {} + +// EnterMirroring_host_port_seperator is called when production mirroring_host_port_seperator is entered. +func (s *BaseTSqlParserListener) EnterMirroring_host_port_seperator(ctx *Mirroring_host_port_seperatorContext) { +} + +// ExitMirroring_host_port_seperator is called when production mirroring_host_port_seperator is exited. +func (s *BaseTSqlParserListener) ExitMirroring_host_port_seperator(ctx *Mirroring_host_port_seperatorContext) { +} + +// EnterPartner_server_tcp_prefix is called when production partner_server_tcp_prefix is entered. +func (s *BaseTSqlParserListener) EnterPartner_server_tcp_prefix(ctx *Partner_server_tcp_prefixContext) { +} + +// ExitPartner_server_tcp_prefix is called when production partner_server_tcp_prefix is exited. +func (s *BaseTSqlParserListener) ExitPartner_server_tcp_prefix(ctx *Partner_server_tcp_prefixContext) { +} + +// EnterPort_number is called when production port_number is entered. +func (s *BaseTSqlParserListener) EnterPort_number(ctx *Port_numberContext) {} + +// ExitPort_number is called when production port_number is exited. +func (s *BaseTSqlParserListener) ExitPort_number(ctx *Port_numberContext) {} + +// EnterHost is called when production host is entered. +func (s *BaseTSqlParserListener) EnterHost(ctx *HostContext) {} + +// ExitHost is called when production host is exited. +func (s *BaseTSqlParserListener) ExitHost(ctx *HostContext) {} + +// EnterDate_correlation_optimization_option is called when production date_correlation_optimization_option is entered. +func (s *BaseTSqlParserListener) EnterDate_correlation_optimization_option(ctx *Date_correlation_optimization_optionContext) { +} + +// ExitDate_correlation_optimization_option is called when production date_correlation_optimization_option is exited. +func (s *BaseTSqlParserListener) ExitDate_correlation_optimization_option(ctx *Date_correlation_optimization_optionContext) { +} + +// EnterDb_encryption_option is called when production db_encryption_option is entered. +func (s *BaseTSqlParserListener) EnterDb_encryption_option(ctx *Db_encryption_optionContext) {} + +// ExitDb_encryption_option is called when production db_encryption_option is exited. +func (s *BaseTSqlParserListener) ExitDb_encryption_option(ctx *Db_encryption_optionContext) {} + +// EnterDb_state_option is called when production db_state_option is entered. +func (s *BaseTSqlParserListener) EnterDb_state_option(ctx *Db_state_optionContext) {} + +// ExitDb_state_option is called when production db_state_option is exited. +func (s *BaseTSqlParserListener) ExitDb_state_option(ctx *Db_state_optionContext) {} + +// EnterDb_update_option is called when production db_update_option is entered. +func (s *BaseTSqlParserListener) EnterDb_update_option(ctx *Db_update_optionContext) {} + +// ExitDb_update_option is called when production db_update_option is exited. +func (s *BaseTSqlParserListener) ExitDb_update_option(ctx *Db_update_optionContext) {} + +// EnterDb_user_access_option is called when production db_user_access_option is entered. +func (s *BaseTSqlParserListener) EnterDb_user_access_option(ctx *Db_user_access_optionContext) {} + +// ExitDb_user_access_option is called when production db_user_access_option is exited. +func (s *BaseTSqlParserListener) ExitDb_user_access_option(ctx *Db_user_access_optionContext) {} + +// EnterDelayed_durability_option is called when production delayed_durability_option is entered. +func (s *BaseTSqlParserListener) EnterDelayed_durability_option(ctx *Delayed_durability_optionContext) { +} + +// ExitDelayed_durability_option is called when production delayed_durability_option is exited. +func (s *BaseTSqlParserListener) ExitDelayed_durability_option(ctx *Delayed_durability_optionContext) { +} + +// EnterExternal_access_option is called when production external_access_option is entered. +func (s *BaseTSqlParserListener) EnterExternal_access_option(ctx *External_access_optionContext) {} + +// ExitExternal_access_option is called when production external_access_option is exited. +func (s *BaseTSqlParserListener) ExitExternal_access_option(ctx *External_access_optionContext) {} + +// EnterHadr_options is called when production hadr_options is entered. +func (s *BaseTSqlParserListener) EnterHadr_options(ctx *Hadr_optionsContext) {} + +// ExitHadr_options is called when production hadr_options is exited. +func (s *BaseTSqlParserListener) ExitHadr_options(ctx *Hadr_optionsContext) {} + +// EnterMixed_page_allocation_option is called when production mixed_page_allocation_option is entered. +func (s *BaseTSqlParserListener) EnterMixed_page_allocation_option(ctx *Mixed_page_allocation_optionContext) { +} + +// ExitMixed_page_allocation_option is called when production mixed_page_allocation_option is exited. +func (s *BaseTSqlParserListener) ExitMixed_page_allocation_option(ctx *Mixed_page_allocation_optionContext) { +} + +// EnterParameterization_option is called when production parameterization_option is entered. +func (s *BaseTSqlParserListener) EnterParameterization_option(ctx *Parameterization_optionContext) {} + +// ExitParameterization_option is called when production parameterization_option is exited. +func (s *BaseTSqlParserListener) ExitParameterization_option(ctx *Parameterization_optionContext) {} + +// EnterRecovery_option is called when production recovery_option is entered. +func (s *BaseTSqlParserListener) EnterRecovery_option(ctx *Recovery_optionContext) {} + +// ExitRecovery_option is called when production recovery_option is exited. +func (s *BaseTSqlParserListener) ExitRecovery_option(ctx *Recovery_optionContext) {} + +// EnterService_broker_option is called when production service_broker_option is entered. +func (s *BaseTSqlParserListener) EnterService_broker_option(ctx *Service_broker_optionContext) {} + +// ExitService_broker_option is called when production service_broker_option is exited. +func (s *BaseTSqlParserListener) ExitService_broker_option(ctx *Service_broker_optionContext) {} + +// EnterSnapshot_option is called when production snapshot_option is entered. +func (s *BaseTSqlParserListener) EnterSnapshot_option(ctx *Snapshot_optionContext) {} + +// ExitSnapshot_option is called when production snapshot_option is exited. +func (s *BaseTSqlParserListener) ExitSnapshot_option(ctx *Snapshot_optionContext) {} + +// EnterSql_option is called when production sql_option is entered. +func (s *BaseTSqlParserListener) EnterSql_option(ctx *Sql_optionContext) {} + +// ExitSql_option is called when production sql_option is exited. +func (s *BaseTSqlParserListener) ExitSql_option(ctx *Sql_optionContext) {} + +// EnterTarget_recovery_time_option is called when production target_recovery_time_option is entered. +func (s *BaseTSqlParserListener) EnterTarget_recovery_time_option(ctx *Target_recovery_time_optionContext) { +} + +// ExitTarget_recovery_time_option is called when production target_recovery_time_option is exited. +func (s *BaseTSqlParserListener) ExitTarget_recovery_time_option(ctx *Target_recovery_time_optionContext) { +} + +// EnterTermination is called when production termination is entered. +func (s *BaseTSqlParserListener) EnterTermination(ctx *TerminationContext) {} + +// ExitTermination is called when production termination is exited. +func (s *BaseTSqlParserListener) ExitTermination(ctx *TerminationContext) {} + +// EnterDrop_index is called when production drop_index is entered. +func (s *BaseTSqlParserListener) EnterDrop_index(ctx *Drop_indexContext) {} + +// ExitDrop_index is called when production drop_index is exited. +func (s *BaseTSqlParserListener) ExitDrop_index(ctx *Drop_indexContext) {} + +// EnterDrop_relational_or_xml_or_spatial_index is called when production drop_relational_or_xml_or_spatial_index is entered. +func (s *BaseTSqlParserListener) EnterDrop_relational_or_xml_or_spatial_index(ctx *Drop_relational_or_xml_or_spatial_indexContext) { +} + +// ExitDrop_relational_or_xml_or_spatial_index is called when production drop_relational_or_xml_or_spatial_index is exited. +func (s *BaseTSqlParserListener) ExitDrop_relational_or_xml_or_spatial_index(ctx *Drop_relational_or_xml_or_spatial_indexContext) { +} + +// EnterDrop_backward_compatible_index is called when production drop_backward_compatible_index is entered. +func (s *BaseTSqlParserListener) EnterDrop_backward_compatible_index(ctx *Drop_backward_compatible_indexContext) { +} + +// ExitDrop_backward_compatible_index is called when production drop_backward_compatible_index is exited. +func (s *BaseTSqlParserListener) ExitDrop_backward_compatible_index(ctx *Drop_backward_compatible_indexContext) { +} + +// EnterDrop_procedure is called when production drop_procedure is entered. +func (s *BaseTSqlParserListener) EnterDrop_procedure(ctx *Drop_procedureContext) {} + +// ExitDrop_procedure is called when production drop_procedure is exited. +func (s *BaseTSqlParserListener) ExitDrop_procedure(ctx *Drop_procedureContext) {} + +// EnterDrop_trigger is called when production drop_trigger is entered. +func (s *BaseTSqlParserListener) EnterDrop_trigger(ctx *Drop_triggerContext) {} + +// ExitDrop_trigger is called when production drop_trigger is exited. +func (s *BaseTSqlParserListener) ExitDrop_trigger(ctx *Drop_triggerContext) {} + +// EnterDrop_dml_trigger is called when production drop_dml_trigger is entered. +func (s *BaseTSqlParserListener) EnterDrop_dml_trigger(ctx *Drop_dml_triggerContext) {} + +// ExitDrop_dml_trigger is called when production drop_dml_trigger is exited. +func (s *BaseTSqlParserListener) ExitDrop_dml_trigger(ctx *Drop_dml_triggerContext) {} + +// EnterDrop_ddl_trigger is called when production drop_ddl_trigger is entered. +func (s *BaseTSqlParserListener) EnterDrop_ddl_trigger(ctx *Drop_ddl_triggerContext) {} + +// ExitDrop_ddl_trigger is called when production drop_ddl_trigger is exited. +func (s *BaseTSqlParserListener) ExitDrop_ddl_trigger(ctx *Drop_ddl_triggerContext) {} + +// EnterDrop_function is called when production drop_function is entered. +func (s *BaseTSqlParserListener) EnterDrop_function(ctx *Drop_functionContext) {} + +// ExitDrop_function is called when production drop_function is exited. +func (s *BaseTSqlParserListener) ExitDrop_function(ctx *Drop_functionContext) {} + +// EnterDrop_statistics is called when production drop_statistics is entered. +func (s *BaseTSqlParserListener) EnterDrop_statistics(ctx *Drop_statisticsContext) {} + +// ExitDrop_statistics is called when production drop_statistics is exited. +func (s *BaseTSqlParserListener) ExitDrop_statistics(ctx *Drop_statisticsContext) {} + +// EnterDrop_table is called when production drop_table is entered. +func (s *BaseTSqlParserListener) EnterDrop_table(ctx *Drop_tableContext) {} + +// ExitDrop_table is called when production drop_table is exited. +func (s *BaseTSqlParserListener) ExitDrop_table(ctx *Drop_tableContext) {} + +// EnterDrop_view is called when production drop_view is entered. +func (s *BaseTSqlParserListener) EnterDrop_view(ctx *Drop_viewContext) {} + +// ExitDrop_view is called when production drop_view is exited. +func (s *BaseTSqlParserListener) ExitDrop_view(ctx *Drop_viewContext) {} + +// EnterCreate_type is called when production create_type is entered. +func (s *BaseTSqlParserListener) EnterCreate_type(ctx *Create_typeContext) {} + +// ExitCreate_type is called when production create_type is exited. +func (s *BaseTSqlParserListener) ExitCreate_type(ctx *Create_typeContext) {} + +// EnterDrop_type is called when production drop_type is entered. +func (s *BaseTSqlParserListener) EnterDrop_type(ctx *Drop_typeContext) {} + +// ExitDrop_type is called when production drop_type is exited. +func (s *BaseTSqlParserListener) ExitDrop_type(ctx *Drop_typeContext) {} + +// EnterRowset_function_limited is called when production rowset_function_limited is entered. +func (s *BaseTSqlParserListener) EnterRowset_function_limited(ctx *Rowset_function_limitedContext) {} + +// ExitRowset_function_limited is called when production rowset_function_limited is exited. +func (s *BaseTSqlParserListener) ExitRowset_function_limited(ctx *Rowset_function_limitedContext) {} + +// EnterOpenquery is called when production openquery is entered. +func (s *BaseTSqlParserListener) EnterOpenquery(ctx *OpenqueryContext) {} + +// ExitOpenquery is called when production openquery is exited. +func (s *BaseTSqlParserListener) ExitOpenquery(ctx *OpenqueryContext) {} + +// EnterOpendatasource is called when production opendatasource is entered. +func (s *BaseTSqlParserListener) EnterOpendatasource(ctx *OpendatasourceContext) {} + +// ExitOpendatasource is called when production opendatasource is exited. +func (s *BaseTSqlParserListener) ExitOpendatasource(ctx *OpendatasourceContext) {} + +// EnterDeclare_statement is called when production declare_statement is entered. +func (s *BaseTSqlParserListener) EnterDeclare_statement(ctx *Declare_statementContext) {} + +// ExitDeclare_statement is called when production declare_statement is exited. +func (s *BaseTSqlParserListener) ExitDeclare_statement(ctx *Declare_statementContext) {} + +// EnterXml_declaration is called when production xml_declaration is entered. +func (s *BaseTSqlParserListener) EnterXml_declaration(ctx *Xml_declarationContext) {} + +// ExitXml_declaration is called when production xml_declaration is exited. +func (s *BaseTSqlParserListener) ExitXml_declaration(ctx *Xml_declarationContext) {} + +// EnterCursor_statement is called when production cursor_statement is entered. +func (s *BaseTSqlParserListener) EnterCursor_statement(ctx *Cursor_statementContext) {} + +// ExitCursor_statement is called when production cursor_statement is exited. +func (s *BaseTSqlParserListener) ExitCursor_statement(ctx *Cursor_statementContext) {} + +// EnterBackup_database is called when production backup_database is entered. +func (s *BaseTSqlParserListener) EnterBackup_database(ctx *Backup_databaseContext) {} + +// ExitBackup_database is called when production backup_database is exited. +func (s *BaseTSqlParserListener) ExitBackup_database(ctx *Backup_databaseContext) {} + +// EnterBackup_log is called when production backup_log is entered. +func (s *BaseTSqlParserListener) EnterBackup_log(ctx *Backup_logContext) {} + +// ExitBackup_log is called when production backup_log is exited. +func (s *BaseTSqlParserListener) ExitBackup_log(ctx *Backup_logContext) {} + +// EnterBackup_certificate is called when production backup_certificate is entered. +func (s *BaseTSqlParserListener) EnterBackup_certificate(ctx *Backup_certificateContext) {} + +// ExitBackup_certificate is called when production backup_certificate is exited. +func (s *BaseTSqlParserListener) ExitBackup_certificate(ctx *Backup_certificateContext) {} + +// EnterBackup_master_key is called when production backup_master_key is entered. +func (s *BaseTSqlParserListener) EnterBackup_master_key(ctx *Backup_master_keyContext) {} + +// ExitBackup_master_key is called when production backup_master_key is exited. +func (s *BaseTSqlParserListener) ExitBackup_master_key(ctx *Backup_master_keyContext) {} + +// EnterBackup_service_master_key is called when production backup_service_master_key is entered. +func (s *BaseTSqlParserListener) EnterBackup_service_master_key(ctx *Backup_service_master_keyContext) { +} + +// ExitBackup_service_master_key is called when production backup_service_master_key is exited. +func (s *BaseTSqlParserListener) ExitBackup_service_master_key(ctx *Backup_service_master_keyContext) { +} + +// EnterKill_statement is called when production kill_statement is entered. +func (s *BaseTSqlParserListener) EnterKill_statement(ctx *Kill_statementContext) {} + +// ExitKill_statement is called when production kill_statement is exited. +func (s *BaseTSqlParserListener) ExitKill_statement(ctx *Kill_statementContext) {} + +// EnterKill_process is called when production kill_process is entered. +func (s *BaseTSqlParserListener) EnterKill_process(ctx *Kill_processContext) {} + +// ExitKill_process is called when production kill_process is exited. +func (s *BaseTSqlParserListener) ExitKill_process(ctx *Kill_processContext) {} + +// EnterKill_query_notification is called when production kill_query_notification is entered. +func (s *BaseTSqlParserListener) EnterKill_query_notification(ctx *Kill_query_notificationContext) {} + +// ExitKill_query_notification is called when production kill_query_notification is exited. +func (s *BaseTSqlParserListener) ExitKill_query_notification(ctx *Kill_query_notificationContext) {} + +// EnterKill_stats_job is called when production kill_stats_job is entered. +func (s *BaseTSqlParserListener) EnterKill_stats_job(ctx *Kill_stats_jobContext) {} + +// ExitKill_stats_job is called when production kill_stats_job is exited. +func (s *BaseTSqlParserListener) ExitKill_stats_job(ctx *Kill_stats_jobContext) {} + +// EnterExecute_statement is called when production execute_statement is entered. +func (s *BaseTSqlParserListener) EnterExecute_statement(ctx *Execute_statementContext) {} + +// ExitExecute_statement is called when production execute_statement is exited. +func (s *BaseTSqlParserListener) ExitExecute_statement(ctx *Execute_statementContext) {} + +// EnterExecute_body_batch is called when production execute_body_batch is entered. +func (s *BaseTSqlParserListener) EnterExecute_body_batch(ctx *Execute_body_batchContext) {} + +// ExitExecute_body_batch is called when production execute_body_batch is exited. +func (s *BaseTSqlParserListener) ExitExecute_body_batch(ctx *Execute_body_batchContext) {} + +// EnterExecute_body is called when production execute_body is entered. +func (s *BaseTSqlParserListener) EnterExecute_body(ctx *Execute_bodyContext) {} + +// ExitExecute_body is called when production execute_body is exited. +func (s *BaseTSqlParserListener) ExitExecute_body(ctx *Execute_bodyContext) {} + +// EnterExecute_statement_arg is called when production execute_statement_arg is entered. +func (s *BaseTSqlParserListener) EnterExecute_statement_arg(ctx *Execute_statement_argContext) {} + +// ExitExecute_statement_arg is called when production execute_statement_arg is exited. +func (s *BaseTSqlParserListener) ExitExecute_statement_arg(ctx *Execute_statement_argContext) {} + +// EnterExecute_statement_arg_named is called when production execute_statement_arg_named is entered. +func (s *BaseTSqlParserListener) EnterExecute_statement_arg_named(ctx *Execute_statement_arg_namedContext) { +} + +// ExitExecute_statement_arg_named is called when production execute_statement_arg_named is exited. +func (s *BaseTSqlParserListener) ExitExecute_statement_arg_named(ctx *Execute_statement_arg_namedContext) { +} + +// EnterExecute_statement_arg_unnamed is called when production execute_statement_arg_unnamed is entered. +func (s *BaseTSqlParserListener) EnterExecute_statement_arg_unnamed(ctx *Execute_statement_arg_unnamedContext) { +} + +// ExitExecute_statement_arg_unnamed is called when production execute_statement_arg_unnamed is exited. +func (s *BaseTSqlParserListener) ExitExecute_statement_arg_unnamed(ctx *Execute_statement_arg_unnamedContext) { +} + +// EnterExecute_parameter is called when production execute_parameter is entered. +func (s *BaseTSqlParserListener) EnterExecute_parameter(ctx *Execute_parameterContext) {} + +// ExitExecute_parameter is called when production execute_parameter is exited. +func (s *BaseTSqlParserListener) ExitExecute_parameter(ctx *Execute_parameterContext) {} + +// EnterExecute_var_string is called when production execute_var_string is entered. +func (s *BaseTSqlParserListener) EnterExecute_var_string(ctx *Execute_var_stringContext) {} + +// ExitExecute_var_string is called when production execute_var_string is exited. +func (s *BaseTSqlParserListener) ExitExecute_var_string(ctx *Execute_var_stringContext) {} + +// EnterSecurity_statement is called when production security_statement is entered. +func (s *BaseTSqlParserListener) EnterSecurity_statement(ctx *Security_statementContext) {} + +// ExitSecurity_statement is called when production security_statement is exited. +func (s *BaseTSqlParserListener) ExitSecurity_statement(ctx *Security_statementContext) {} + +// EnterPrincipal_id is called when production principal_id is entered. +func (s *BaseTSqlParserListener) EnterPrincipal_id(ctx *Principal_idContext) {} + +// ExitPrincipal_id is called when production principal_id is exited. +func (s *BaseTSqlParserListener) ExitPrincipal_id(ctx *Principal_idContext) {} + +// EnterCreate_certificate is called when production create_certificate is entered. +func (s *BaseTSqlParserListener) EnterCreate_certificate(ctx *Create_certificateContext) {} + +// ExitCreate_certificate is called when production create_certificate is exited. +func (s *BaseTSqlParserListener) ExitCreate_certificate(ctx *Create_certificateContext) {} + +// EnterExisting_keys is called when production existing_keys is entered. +func (s *BaseTSqlParserListener) EnterExisting_keys(ctx *Existing_keysContext) {} + +// ExitExisting_keys is called when production existing_keys is exited. +func (s *BaseTSqlParserListener) ExitExisting_keys(ctx *Existing_keysContext) {} + +// EnterPrivate_key_options is called when production private_key_options is entered. +func (s *BaseTSqlParserListener) EnterPrivate_key_options(ctx *Private_key_optionsContext) {} + +// ExitPrivate_key_options is called when production private_key_options is exited. +func (s *BaseTSqlParserListener) ExitPrivate_key_options(ctx *Private_key_optionsContext) {} + +// EnterGenerate_new_keys is called when production generate_new_keys is entered. +func (s *BaseTSqlParserListener) EnterGenerate_new_keys(ctx *Generate_new_keysContext) {} + +// ExitGenerate_new_keys is called when production generate_new_keys is exited. +func (s *BaseTSqlParserListener) ExitGenerate_new_keys(ctx *Generate_new_keysContext) {} + +// EnterDate_options is called when production date_options is entered. +func (s *BaseTSqlParserListener) EnterDate_options(ctx *Date_optionsContext) {} + +// ExitDate_options is called when production date_options is exited. +func (s *BaseTSqlParserListener) ExitDate_options(ctx *Date_optionsContext) {} + +// EnterOpen_key is called when production open_key is entered. +func (s *BaseTSqlParserListener) EnterOpen_key(ctx *Open_keyContext) {} + +// ExitOpen_key is called when production open_key is exited. +func (s *BaseTSqlParserListener) ExitOpen_key(ctx *Open_keyContext) {} + +// EnterClose_key is called when production close_key is entered. +func (s *BaseTSqlParserListener) EnterClose_key(ctx *Close_keyContext) {} + +// ExitClose_key is called when production close_key is exited. +func (s *BaseTSqlParserListener) ExitClose_key(ctx *Close_keyContext) {} + +// EnterCreate_key is called when production create_key is entered. +func (s *BaseTSqlParserListener) EnterCreate_key(ctx *Create_keyContext) {} + +// ExitCreate_key is called when production create_key is exited. +func (s *BaseTSqlParserListener) ExitCreate_key(ctx *Create_keyContext) {} + +// EnterKey_options is called when production key_options is entered. +func (s *BaseTSqlParserListener) EnterKey_options(ctx *Key_optionsContext) {} + +// ExitKey_options is called when production key_options is exited. +func (s *BaseTSqlParserListener) ExitKey_options(ctx *Key_optionsContext) {} + +// EnterAlgorithm is called when production algorithm is entered. +func (s *BaseTSqlParserListener) EnterAlgorithm(ctx *AlgorithmContext) {} + +// ExitAlgorithm is called when production algorithm is exited. +func (s *BaseTSqlParserListener) ExitAlgorithm(ctx *AlgorithmContext) {} + +// EnterEncryption_mechanism is called when production encryption_mechanism is entered. +func (s *BaseTSqlParserListener) EnterEncryption_mechanism(ctx *Encryption_mechanismContext) {} + +// ExitEncryption_mechanism is called when production encryption_mechanism is exited. +func (s *BaseTSqlParserListener) ExitEncryption_mechanism(ctx *Encryption_mechanismContext) {} + +// EnterDecryption_mechanism is called when production decryption_mechanism is entered. +func (s *BaseTSqlParserListener) EnterDecryption_mechanism(ctx *Decryption_mechanismContext) {} + +// ExitDecryption_mechanism is called when production decryption_mechanism is exited. +func (s *BaseTSqlParserListener) ExitDecryption_mechanism(ctx *Decryption_mechanismContext) {} + +// EnterGrant_permission is called when production grant_permission is entered. +func (s *BaseTSqlParserListener) EnterGrant_permission(ctx *Grant_permissionContext) {} + +// ExitGrant_permission is called when production grant_permission is exited. +func (s *BaseTSqlParserListener) ExitGrant_permission(ctx *Grant_permissionContext) {} + +// EnterSet_statement is called when production set_statement is entered. +func (s *BaseTSqlParserListener) EnterSet_statement(ctx *Set_statementContext) {} + +// ExitSet_statement is called when production set_statement is exited. +func (s *BaseTSqlParserListener) ExitSet_statement(ctx *Set_statementContext) {} + +// EnterTransaction_statement is called when production transaction_statement is entered. +func (s *BaseTSqlParserListener) EnterTransaction_statement(ctx *Transaction_statementContext) {} + +// ExitTransaction_statement is called when production transaction_statement is exited. +func (s *BaseTSqlParserListener) ExitTransaction_statement(ctx *Transaction_statementContext) {} + +// EnterGo_statement is called when production go_statement is entered. +func (s *BaseTSqlParserListener) EnterGo_statement(ctx *Go_statementContext) {} + +// ExitGo_statement is called when production go_statement is exited. +func (s *BaseTSqlParserListener) ExitGo_statement(ctx *Go_statementContext) {} + +// EnterUse_statement is called when production use_statement is entered. +func (s *BaseTSqlParserListener) EnterUse_statement(ctx *Use_statementContext) {} + +// ExitUse_statement is called when production use_statement is exited. +func (s *BaseTSqlParserListener) ExitUse_statement(ctx *Use_statementContext) {} + +// EnterSetuser_statement is called when production setuser_statement is entered. +func (s *BaseTSqlParserListener) EnterSetuser_statement(ctx *Setuser_statementContext) {} + +// ExitSetuser_statement is called when production setuser_statement is exited. +func (s *BaseTSqlParserListener) ExitSetuser_statement(ctx *Setuser_statementContext) {} + +// EnterReconfigure_statement is called when production reconfigure_statement is entered. +func (s *BaseTSqlParserListener) EnterReconfigure_statement(ctx *Reconfigure_statementContext) {} + +// ExitReconfigure_statement is called when production reconfigure_statement is exited. +func (s *BaseTSqlParserListener) ExitReconfigure_statement(ctx *Reconfigure_statementContext) {} + +// EnterShutdown_statement is called when production shutdown_statement is entered. +func (s *BaseTSqlParserListener) EnterShutdown_statement(ctx *Shutdown_statementContext) {} + +// ExitShutdown_statement is called when production shutdown_statement is exited. +func (s *BaseTSqlParserListener) ExitShutdown_statement(ctx *Shutdown_statementContext) {} + +// EnterCheckpoint_statement is called when production checkpoint_statement is entered. +func (s *BaseTSqlParserListener) EnterCheckpoint_statement(ctx *Checkpoint_statementContext) {} + +// ExitCheckpoint_statement is called when production checkpoint_statement is exited. +func (s *BaseTSqlParserListener) ExitCheckpoint_statement(ctx *Checkpoint_statementContext) {} + +// EnterDbcc_checkalloc_option is called when production dbcc_checkalloc_option is entered. +func (s *BaseTSqlParserListener) EnterDbcc_checkalloc_option(ctx *Dbcc_checkalloc_optionContext) {} + +// ExitDbcc_checkalloc_option is called when production dbcc_checkalloc_option is exited. +func (s *BaseTSqlParserListener) ExitDbcc_checkalloc_option(ctx *Dbcc_checkalloc_optionContext) {} + +// EnterDbcc_checkalloc is called when production dbcc_checkalloc is entered. +func (s *BaseTSqlParserListener) EnterDbcc_checkalloc(ctx *Dbcc_checkallocContext) {} + +// ExitDbcc_checkalloc is called when production dbcc_checkalloc is exited. +func (s *BaseTSqlParserListener) ExitDbcc_checkalloc(ctx *Dbcc_checkallocContext) {} + +// EnterDbcc_checkcatalog is called when production dbcc_checkcatalog is entered. +func (s *BaseTSqlParserListener) EnterDbcc_checkcatalog(ctx *Dbcc_checkcatalogContext) {} + +// ExitDbcc_checkcatalog is called when production dbcc_checkcatalog is exited. +func (s *BaseTSqlParserListener) ExitDbcc_checkcatalog(ctx *Dbcc_checkcatalogContext) {} + +// EnterDbcc_checkconstraints_option is called when production dbcc_checkconstraints_option is entered. +func (s *BaseTSqlParserListener) EnterDbcc_checkconstraints_option(ctx *Dbcc_checkconstraints_optionContext) { +} + +// ExitDbcc_checkconstraints_option is called when production dbcc_checkconstraints_option is exited. +func (s *BaseTSqlParserListener) ExitDbcc_checkconstraints_option(ctx *Dbcc_checkconstraints_optionContext) { +} + +// EnterDbcc_checkconstraints is called when production dbcc_checkconstraints is entered. +func (s *BaseTSqlParserListener) EnterDbcc_checkconstraints(ctx *Dbcc_checkconstraintsContext) {} + +// ExitDbcc_checkconstraints is called when production dbcc_checkconstraints is exited. +func (s *BaseTSqlParserListener) ExitDbcc_checkconstraints(ctx *Dbcc_checkconstraintsContext) {} + +// EnterDbcc_checkdb_table_option is called when production dbcc_checkdb_table_option is entered. +func (s *BaseTSqlParserListener) EnterDbcc_checkdb_table_option(ctx *Dbcc_checkdb_table_optionContext) { +} + +// ExitDbcc_checkdb_table_option is called when production dbcc_checkdb_table_option is exited. +func (s *BaseTSqlParserListener) ExitDbcc_checkdb_table_option(ctx *Dbcc_checkdb_table_optionContext) { +} + +// EnterDbcc_checkdb is called when production dbcc_checkdb is entered. +func (s *BaseTSqlParserListener) EnterDbcc_checkdb(ctx *Dbcc_checkdbContext) {} + +// ExitDbcc_checkdb is called when production dbcc_checkdb is exited. +func (s *BaseTSqlParserListener) ExitDbcc_checkdb(ctx *Dbcc_checkdbContext) {} + +// EnterDbcc_checkfilegroup_option is called when production dbcc_checkfilegroup_option is entered. +func (s *BaseTSqlParserListener) EnterDbcc_checkfilegroup_option(ctx *Dbcc_checkfilegroup_optionContext) { +} + +// ExitDbcc_checkfilegroup_option is called when production dbcc_checkfilegroup_option is exited. +func (s *BaseTSqlParserListener) ExitDbcc_checkfilegroup_option(ctx *Dbcc_checkfilegroup_optionContext) { +} + +// EnterDbcc_checkfilegroup is called when production dbcc_checkfilegroup is entered. +func (s *BaseTSqlParserListener) EnterDbcc_checkfilegroup(ctx *Dbcc_checkfilegroupContext) {} + +// ExitDbcc_checkfilegroup is called when production dbcc_checkfilegroup is exited. +func (s *BaseTSqlParserListener) ExitDbcc_checkfilegroup(ctx *Dbcc_checkfilegroupContext) {} + +// EnterDbcc_checktable is called when production dbcc_checktable is entered. +func (s *BaseTSqlParserListener) EnterDbcc_checktable(ctx *Dbcc_checktableContext) {} + +// ExitDbcc_checktable is called when production dbcc_checktable is exited. +func (s *BaseTSqlParserListener) ExitDbcc_checktable(ctx *Dbcc_checktableContext) {} + +// EnterDbcc_cleantable is called when production dbcc_cleantable is entered. +func (s *BaseTSqlParserListener) EnterDbcc_cleantable(ctx *Dbcc_cleantableContext) {} + +// ExitDbcc_cleantable is called when production dbcc_cleantable is exited. +func (s *BaseTSqlParserListener) ExitDbcc_cleantable(ctx *Dbcc_cleantableContext) {} + +// EnterDbcc_clonedatabase_option is called when production dbcc_clonedatabase_option is entered. +func (s *BaseTSqlParserListener) EnterDbcc_clonedatabase_option(ctx *Dbcc_clonedatabase_optionContext) { +} + +// ExitDbcc_clonedatabase_option is called when production dbcc_clonedatabase_option is exited. +func (s *BaseTSqlParserListener) ExitDbcc_clonedatabase_option(ctx *Dbcc_clonedatabase_optionContext) { +} + +// EnterDbcc_clonedatabase is called when production dbcc_clonedatabase is entered. +func (s *BaseTSqlParserListener) EnterDbcc_clonedatabase(ctx *Dbcc_clonedatabaseContext) {} + +// ExitDbcc_clonedatabase is called when production dbcc_clonedatabase is exited. +func (s *BaseTSqlParserListener) ExitDbcc_clonedatabase(ctx *Dbcc_clonedatabaseContext) {} + +// EnterDbcc_pdw_showspaceused is called when production dbcc_pdw_showspaceused is entered. +func (s *BaseTSqlParserListener) EnterDbcc_pdw_showspaceused(ctx *Dbcc_pdw_showspaceusedContext) {} + +// ExitDbcc_pdw_showspaceused is called when production dbcc_pdw_showspaceused is exited. +func (s *BaseTSqlParserListener) ExitDbcc_pdw_showspaceused(ctx *Dbcc_pdw_showspaceusedContext) {} + +// EnterDbcc_proccache is called when production dbcc_proccache is entered. +func (s *BaseTSqlParserListener) EnterDbcc_proccache(ctx *Dbcc_proccacheContext) {} + +// ExitDbcc_proccache is called when production dbcc_proccache is exited. +func (s *BaseTSqlParserListener) ExitDbcc_proccache(ctx *Dbcc_proccacheContext) {} + +// EnterDbcc_showcontig_option is called when production dbcc_showcontig_option is entered. +func (s *BaseTSqlParserListener) EnterDbcc_showcontig_option(ctx *Dbcc_showcontig_optionContext) {} + +// ExitDbcc_showcontig_option is called when production dbcc_showcontig_option is exited. +func (s *BaseTSqlParserListener) ExitDbcc_showcontig_option(ctx *Dbcc_showcontig_optionContext) {} + +// EnterDbcc_showcontig is called when production dbcc_showcontig is entered. +func (s *BaseTSqlParserListener) EnterDbcc_showcontig(ctx *Dbcc_showcontigContext) {} + +// ExitDbcc_showcontig is called when production dbcc_showcontig is exited. +func (s *BaseTSqlParserListener) ExitDbcc_showcontig(ctx *Dbcc_showcontigContext) {} + +// EnterDbcc_shrinklog is called when production dbcc_shrinklog is entered. +func (s *BaseTSqlParserListener) EnterDbcc_shrinklog(ctx *Dbcc_shrinklogContext) {} + +// ExitDbcc_shrinklog is called when production dbcc_shrinklog is exited. +func (s *BaseTSqlParserListener) ExitDbcc_shrinklog(ctx *Dbcc_shrinklogContext) {} + +// EnterDbcc_dbreindex is called when production dbcc_dbreindex is entered. +func (s *BaseTSqlParserListener) EnterDbcc_dbreindex(ctx *Dbcc_dbreindexContext) {} + +// ExitDbcc_dbreindex is called when production dbcc_dbreindex is exited. +func (s *BaseTSqlParserListener) ExitDbcc_dbreindex(ctx *Dbcc_dbreindexContext) {} + +// EnterDbcc_dll_free is called when production dbcc_dll_free is entered. +func (s *BaseTSqlParserListener) EnterDbcc_dll_free(ctx *Dbcc_dll_freeContext) {} + +// ExitDbcc_dll_free is called when production dbcc_dll_free is exited. +func (s *BaseTSqlParserListener) ExitDbcc_dll_free(ctx *Dbcc_dll_freeContext) {} + +// EnterDbcc_dropcleanbuffers is called when production dbcc_dropcleanbuffers is entered. +func (s *BaseTSqlParserListener) EnterDbcc_dropcleanbuffers(ctx *Dbcc_dropcleanbuffersContext) {} + +// ExitDbcc_dropcleanbuffers is called when production dbcc_dropcleanbuffers is exited. +func (s *BaseTSqlParserListener) ExitDbcc_dropcleanbuffers(ctx *Dbcc_dropcleanbuffersContext) {} + +// EnterDbcc_clause is called when production dbcc_clause is entered. +func (s *BaseTSqlParserListener) EnterDbcc_clause(ctx *Dbcc_clauseContext) {} + +// ExitDbcc_clause is called when production dbcc_clause is exited. +func (s *BaseTSqlParserListener) ExitDbcc_clause(ctx *Dbcc_clauseContext) {} + +// EnterExecute_clause is called when production execute_clause is entered. +func (s *BaseTSqlParserListener) EnterExecute_clause(ctx *Execute_clauseContext) {} + +// ExitExecute_clause is called when production execute_clause is exited. +func (s *BaseTSqlParserListener) ExitExecute_clause(ctx *Execute_clauseContext) {} + +// EnterDeclare_local is called when production declare_local is entered. +func (s *BaseTSqlParserListener) EnterDeclare_local(ctx *Declare_localContext) {} + +// ExitDeclare_local is called when production declare_local is exited. +func (s *BaseTSqlParserListener) ExitDeclare_local(ctx *Declare_localContext) {} + +// EnterTable_type_definition is called when production table_type_definition is entered. +func (s *BaseTSqlParserListener) EnterTable_type_definition(ctx *Table_type_definitionContext) {} + +// ExitTable_type_definition is called when production table_type_definition is exited. +func (s *BaseTSqlParserListener) ExitTable_type_definition(ctx *Table_type_definitionContext) {} + +// EnterTable_type_indices is called when production table_type_indices is entered. +func (s *BaseTSqlParserListener) EnterTable_type_indices(ctx *Table_type_indicesContext) {} + +// ExitTable_type_indices is called when production table_type_indices is exited. +func (s *BaseTSqlParserListener) ExitTable_type_indices(ctx *Table_type_indicesContext) {} + +// EnterXml_type_definition is called when production xml_type_definition is entered. +func (s *BaseTSqlParserListener) EnterXml_type_definition(ctx *Xml_type_definitionContext) {} + +// ExitXml_type_definition is called when production xml_type_definition is exited. +func (s *BaseTSqlParserListener) ExitXml_type_definition(ctx *Xml_type_definitionContext) {} + +// EnterXml_schema_collection is called when production xml_schema_collection is entered. +func (s *BaseTSqlParserListener) EnterXml_schema_collection(ctx *Xml_schema_collectionContext) {} + +// ExitXml_schema_collection is called when production xml_schema_collection is exited. +func (s *BaseTSqlParserListener) ExitXml_schema_collection(ctx *Xml_schema_collectionContext) {} + +// EnterColumn_def_table_constraints is called when production column_def_table_constraints is entered. +func (s *BaseTSqlParserListener) EnterColumn_def_table_constraints(ctx *Column_def_table_constraintsContext) { +} + +// ExitColumn_def_table_constraints is called when production column_def_table_constraints is exited. +func (s *BaseTSqlParserListener) ExitColumn_def_table_constraints(ctx *Column_def_table_constraintsContext) { +} + +// EnterColumn_def_table_constraint is called when production column_def_table_constraint is entered. +func (s *BaseTSqlParserListener) EnterColumn_def_table_constraint(ctx *Column_def_table_constraintContext) { +} + +// ExitColumn_def_table_constraint is called when production column_def_table_constraint is exited. +func (s *BaseTSqlParserListener) ExitColumn_def_table_constraint(ctx *Column_def_table_constraintContext) { +} + +// EnterColumn_definition is called when production column_definition is entered. +func (s *BaseTSqlParserListener) EnterColumn_definition(ctx *Column_definitionContext) {} + +// ExitColumn_definition is called when production column_definition is exited. +func (s *BaseTSqlParserListener) ExitColumn_definition(ctx *Column_definitionContext) {} + +// EnterColumn_definition_element is called when production column_definition_element is entered. +func (s *BaseTSqlParserListener) EnterColumn_definition_element(ctx *Column_definition_elementContext) { +} + +// ExitColumn_definition_element is called when production column_definition_element is exited. +func (s *BaseTSqlParserListener) ExitColumn_definition_element(ctx *Column_definition_elementContext) { +} + +// EnterColumn_modifier is called when production column_modifier is entered. +func (s *BaseTSqlParserListener) EnterColumn_modifier(ctx *Column_modifierContext) {} + +// ExitColumn_modifier is called when production column_modifier is exited. +func (s *BaseTSqlParserListener) ExitColumn_modifier(ctx *Column_modifierContext) {} + +// EnterMaterialized_column_definition is called when production materialized_column_definition is entered. +func (s *BaseTSqlParserListener) EnterMaterialized_column_definition(ctx *Materialized_column_definitionContext) { +} + +// ExitMaterialized_column_definition is called when production materialized_column_definition is exited. +func (s *BaseTSqlParserListener) ExitMaterialized_column_definition(ctx *Materialized_column_definitionContext) { +} + +// EnterColumn_constraint is called when production column_constraint is entered. +func (s *BaseTSqlParserListener) EnterColumn_constraint(ctx *Column_constraintContext) {} + +// ExitColumn_constraint is called when production column_constraint is exited. +func (s *BaseTSqlParserListener) ExitColumn_constraint(ctx *Column_constraintContext) {} + +// EnterColumn_index is called when production column_index is entered. +func (s *BaseTSqlParserListener) EnterColumn_index(ctx *Column_indexContext) {} + +// ExitColumn_index is called when production column_index is exited. +func (s *BaseTSqlParserListener) ExitColumn_index(ctx *Column_indexContext) {} + +// EnterOn_partition_or_filegroup is called when production on_partition_or_filegroup is entered. +func (s *BaseTSqlParserListener) EnterOn_partition_or_filegroup(ctx *On_partition_or_filegroupContext) { +} + +// ExitOn_partition_or_filegroup is called when production on_partition_or_filegroup is exited. +func (s *BaseTSqlParserListener) ExitOn_partition_or_filegroup(ctx *On_partition_or_filegroupContext) { +} + +// EnterTable_constraint is called when production table_constraint is entered. +func (s *BaseTSqlParserListener) EnterTable_constraint(ctx *Table_constraintContext) {} + +// ExitTable_constraint is called when production table_constraint is exited. +func (s *BaseTSqlParserListener) ExitTable_constraint(ctx *Table_constraintContext) {} + +// EnterConnection_node is called when production connection_node is entered. +func (s *BaseTSqlParserListener) EnterConnection_node(ctx *Connection_nodeContext) {} + +// ExitConnection_node is called when production connection_node is exited. +func (s *BaseTSqlParserListener) ExitConnection_node(ctx *Connection_nodeContext) {} + +// EnterPrimary_key_options is called when production primary_key_options is entered. +func (s *BaseTSqlParserListener) EnterPrimary_key_options(ctx *Primary_key_optionsContext) {} + +// ExitPrimary_key_options is called when production primary_key_options is exited. +func (s *BaseTSqlParserListener) ExitPrimary_key_options(ctx *Primary_key_optionsContext) {} + +// EnterForeign_key_options is called when production foreign_key_options is entered. +func (s *BaseTSqlParserListener) EnterForeign_key_options(ctx *Foreign_key_optionsContext) {} + +// ExitForeign_key_options is called when production foreign_key_options is exited. +func (s *BaseTSqlParserListener) ExitForeign_key_options(ctx *Foreign_key_optionsContext) {} + +// EnterCheck_constraint is called when production check_constraint is entered. +func (s *BaseTSqlParserListener) EnterCheck_constraint(ctx *Check_constraintContext) {} + +// ExitCheck_constraint is called when production check_constraint is exited. +func (s *BaseTSqlParserListener) ExitCheck_constraint(ctx *Check_constraintContext) {} + +// EnterOn_delete is called when production on_delete is entered. +func (s *BaseTSqlParserListener) EnterOn_delete(ctx *On_deleteContext) {} + +// ExitOn_delete is called when production on_delete is exited. +func (s *BaseTSqlParserListener) ExitOn_delete(ctx *On_deleteContext) {} + +// EnterOn_update is called when production on_update is entered. +func (s *BaseTSqlParserListener) EnterOn_update(ctx *On_updateContext) {} + +// ExitOn_update is called when production on_update is exited. +func (s *BaseTSqlParserListener) ExitOn_update(ctx *On_updateContext) {} + +// EnterAlter_table_index_options is called when production alter_table_index_options is entered. +func (s *BaseTSqlParserListener) EnterAlter_table_index_options(ctx *Alter_table_index_optionsContext) { +} + +// ExitAlter_table_index_options is called when production alter_table_index_options is exited. +func (s *BaseTSqlParserListener) ExitAlter_table_index_options(ctx *Alter_table_index_optionsContext) { +} + +// EnterAlter_table_index_option is called when production alter_table_index_option is entered. +func (s *BaseTSqlParserListener) EnterAlter_table_index_option(ctx *Alter_table_index_optionContext) { +} + +// ExitAlter_table_index_option is called when production alter_table_index_option is exited. +func (s *BaseTSqlParserListener) ExitAlter_table_index_option(ctx *Alter_table_index_optionContext) {} + +// EnterDeclare_cursor is called when production declare_cursor is entered. +func (s *BaseTSqlParserListener) EnterDeclare_cursor(ctx *Declare_cursorContext) {} + +// ExitDeclare_cursor is called when production declare_cursor is exited. +func (s *BaseTSqlParserListener) ExitDeclare_cursor(ctx *Declare_cursorContext) {} + +// EnterDeclare_set_cursor_common is called when production declare_set_cursor_common is entered. +func (s *BaseTSqlParserListener) EnterDeclare_set_cursor_common(ctx *Declare_set_cursor_commonContext) { +} + +// ExitDeclare_set_cursor_common is called when production declare_set_cursor_common is exited. +func (s *BaseTSqlParserListener) ExitDeclare_set_cursor_common(ctx *Declare_set_cursor_commonContext) { +} + +// EnterDeclare_set_cursor_common_partial is called when production declare_set_cursor_common_partial is entered. +func (s *BaseTSqlParserListener) EnterDeclare_set_cursor_common_partial(ctx *Declare_set_cursor_common_partialContext) { +} + +// ExitDeclare_set_cursor_common_partial is called when production declare_set_cursor_common_partial is exited. +func (s *BaseTSqlParserListener) ExitDeclare_set_cursor_common_partial(ctx *Declare_set_cursor_common_partialContext) { +} + +// EnterFetch_cursor is called when production fetch_cursor is entered. +func (s *BaseTSqlParserListener) EnterFetch_cursor(ctx *Fetch_cursorContext) {} + +// ExitFetch_cursor is called when production fetch_cursor is exited. +func (s *BaseTSqlParserListener) ExitFetch_cursor(ctx *Fetch_cursorContext) {} + +// EnterSet_special is called when production set_special is entered. +func (s *BaseTSqlParserListener) EnterSet_special(ctx *Set_specialContext) {} + +// ExitSet_special is called when production set_special is exited. +func (s *BaseTSqlParserListener) ExitSet_special(ctx *Set_specialContext) {} + +// EnterSpecial_list is called when production special_list is entered. +func (s *BaseTSqlParserListener) EnterSpecial_list(ctx *Special_listContext) {} + +// ExitSpecial_list is called when production special_list is exited. +func (s *BaseTSqlParserListener) ExitSpecial_list(ctx *Special_listContext) {} + +// EnterConstant_LOCAL_ID is called when production constant_LOCAL_ID is entered. +func (s *BaseTSqlParserListener) EnterConstant_LOCAL_ID(ctx *Constant_LOCAL_IDContext) {} + +// ExitConstant_LOCAL_ID is called when production constant_LOCAL_ID is exited. +func (s *BaseTSqlParserListener) ExitConstant_LOCAL_ID(ctx *Constant_LOCAL_IDContext) {} + +// EnterExpression is called when production expression is entered. +func (s *BaseTSqlParserListener) EnterExpression(ctx *ExpressionContext) {} + +// ExitExpression is called when production expression is exited. +func (s *BaseTSqlParserListener) ExitExpression(ctx *ExpressionContext) {} + +// EnterParameter is called when production parameter is entered. +func (s *BaseTSqlParserListener) EnterParameter(ctx *ParameterContext) {} + +// ExitParameter is called when production parameter is exited. +func (s *BaseTSqlParserListener) ExitParameter(ctx *ParameterContext) {} + +// EnterTime_zone is called when production time_zone is entered. +func (s *BaseTSqlParserListener) EnterTime_zone(ctx *Time_zoneContext) {} + +// ExitTime_zone is called when production time_zone is exited. +func (s *BaseTSqlParserListener) ExitTime_zone(ctx *Time_zoneContext) {} + +// EnterPrimitive_expression is called when production primitive_expression is entered. +func (s *BaseTSqlParserListener) EnterPrimitive_expression(ctx *Primitive_expressionContext) {} + +// ExitPrimitive_expression is called when production primitive_expression is exited. +func (s *BaseTSqlParserListener) ExitPrimitive_expression(ctx *Primitive_expressionContext) {} + +// EnterCase_expression is called when production case_expression is entered. +func (s *BaseTSqlParserListener) EnterCase_expression(ctx *Case_expressionContext) {} + +// ExitCase_expression is called when production case_expression is exited. +func (s *BaseTSqlParserListener) ExitCase_expression(ctx *Case_expressionContext) {} + +// EnterUnary_operator_expression is called when production unary_operator_expression is entered. +func (s *BaseTSqlParserListener) EnterUnary_operator_expression(ctx *Unary_operator_expressionContext) { +} + +// ExitUnary_operator_expression is called when production unary_operator_expression is exited. +func (s *BaseTSqlParserListener) ExitUnary_operator_expression(ctx *Unary_operator_expressionContext) { +} + +// EnterBracket_expression is called when production bracket_expression is entered. +func (s *BaseTSqlParserListener) EnterBracket_expression(ctx *Bracket_expressionContext) {} + +// ExitBracket_expression is called when production bracket_expression is exited. +func (s *BaseTSqlParserListener) ExitBracket_expression(ctx *Bracket_expressionContext) {} + +// EnterSubquery is called when production subquery is entered. +func (s *BaseTSqlParserListener) EnterSubquery(ctx *SubqueryContext) {} + +// ExitSubquery is called when production subquery is exited. +func (s *BaseTSqlParserListener) ExitSubquery(ctx *SubqueryContext) {} + +// EnterWith_expression is called when production with_expression is entered. +func (s *BaseTSqlParserListener) EnterWith_expression(ctx *With_expressionContext) {} + +// ExitWith_expression is called when production with_expression is exited. +func (s *BaseTSqlParserListener) ExitWith_expression(ctx *With_expressionContext) {} + +// EnterCommon_table_expression is called when production common_table_expression is entered. +func (s *BaseTSqlParserListener) EnterCommon_table_expression(ctx *Common_table_expressionContext) {} + +// ExitCommon_table_expression is called when production common_table_expression is exited. +func (s *BaseTSqlParserListener) ExitCommon_table_expression(ctx *Common_table_expressionContext) {} + +// EnterUpdate_elem is called when production update_elem is entered. +func (s *BaseTSqlParserListener) EnterUpdate_elem(ctx *Update_elemContext) {} + +// ExitUpdate_elem is called when production update_elem is exited. +func (s *BaseTSqlParserListener) ExitUpdate_elem(ctx *Update_elemContext) {} + +// EnterUpdate_elem_merge is called when production update_elem_merge is entered. +func (s *BaseTSqlParserListener) EnterUpdate_elem_merge(ctx *Update_elem_mergeContext) {} + +// ExitUpdate_elem_merge is called when production update_elem_merge is exited. +func (s *BaseTSqlParserListener) ExitUpdate_elem_merge(ctx *Update_elem_mergeContext) {} + +// EnterSearch_condition is called when production search_condition is entered. +func (s *BaseTSqlParserListener) EnterSearch_condition(ctx *Search_conditionContext) {} + +// ExitSearch_condition is called when production search_condition is exited. +func (s *BaseTSqlParserListener) ExitSearch_condition(ctx *Search_conditionContext) {} + +// EnterPredicate is called when production predicate is entered. +func (s *BaseTSqlParserListener) EnterPredicate(ctx *PredicateContext) {} + +// ExitPredicate is called when production predicate is exited. +func (s *BaseTSqlParserListener) ExitPredicate(ctx *PredicateContext) {} + +// EnterQuery_expression is called when production query_expression is entered. +func (s *BaseTSqlParserListener) EnterQuery_expression(ctx *Query_expressionContext) {} + +// ExitQuery_expression is called when production query_expression is exited. +func (s *BaseTSqlParserListener) ExitQuery_expression(ctx *Query_expressionContext) {} + +// EnterSql_union is called when production sql_union is entered. +func (s *BaseTSqlParserListener) EnterSql_union(ctx *Sql_unionContext) {} + +// ExitSql_union is called when production sql_union is exited. +func (s *BaseTSqlParserListener) ExitSql_union(ctx *Sql_unionContext) {} + +// EnterQuery_specification is called when production query_specification is entered. +func (s *BaseTSqlParserListener) EnterQuery_specification(ctx *Query_specificationContext) {} + +// ExitQuery_specification is called when production query_specification is exited. +func (s *BaseTSqlParserListener) ExitQuery_specification(ctx *Query_specificationContext) {} + +// EnterGroup_by_clause is called when production group_by_clause is entered. +func (s *BaseTSqlParserListener) EnterGroup_by_clause(ctx *Group_by_clauseContext) {} + +// ExitGroup_by_clause is called when production group_by_clause is exited. +func (s *BaseTSqlParserListener) ExitGroup_by_clause(ctx *Group_by_clauseContext) {} + +// EnterHaving_clause is called when production having_clause is entered. +func (s *BaseTSqlParserListener) EnterHaving_clause(ctx *Having_clauseContext) {} + +// ExitHaving_clause is called when production having_clause is exited. +func (s *BaseTSqlParserListener) ExitHaving_clause(ctx *Having_clauseContext) {} + +// EnterFrom_table_sources is called when production from_table_sources is entered. +func (s *BaseTSqlParserListener) EnterFrom_table_sources(ctx *From_table_sourcesContext) {} + +// ExitFrom_table_sources is called when production from_table_sources is exited. +func (s *BaseTSqlParserListener) ExitFrom_table_sources(ctx *From_table_sourcesContext) {} + +// EnterTop_clause is called when production top_clause is entered. +func (s *BaseTSqlParserListener) EnterTop_clause(ctx *Top_clauseContext) {} + +// ExitTop_clause is called when production top_clause is exited. +func (s *BaseTSqlParserListener) ExitTop_clause(ctx *Top_clauseContext) {} + +// EnterTop_percent is called when production top_percent is entered. +func (s *BaseTSqlParserListener) EnterTop_percent(ctx *Top_percentContext) {} + +// ExitTop_percent is called when production top_percent is exited. +func (s *BaseTSqlParserListener) ExitTop_percent(ctx *Top_percentContext) {} + +// EnterTop_count is called when production top_count is entered. +func (s *BaseTSqlParserListener) EnterTop_count(ctx *Top_countContext) {} + +// ExitTop_count is called when production top_count is exited. +func (s *BaseTSqlParserListener) ExitTop_count(ctx *Top_countContext) {} + +// EnterOrder_by_clause is called when production order_by_clause is entered. +func (s *BaseTSqlParserListener) EnterOrder_by_clause(ctx *Order_by_clauseContext) {} + +// ExitOrder_by_clause is called when production order_by_clause is exited. +func (s *BaseTSqlParserListener) ExitOrder_by_clause(ctx *Order_by_clauseContext) {} + +// EnterSelect_order_by_clause is called when production select_order_by_clause is entered. +func (s *BaseTSqlParserListener) EnterSelect_order_by_clause(ctx *Select_order_by_clauseContext) {} + +// ExitSelect_order_by_clause is called when production select_order_by_clause is exited. +func (s *BaseTSqlParserListener) ExitSelect_order_by_clause(ctx *Select_order_by_clauseContext) {} + +// EnterFor_clause is called when production for_clause is entered. +func (s *BaseTSqlParserListener) EnterFor_clause(ctx *For_clauseContext) {} + +// ExitFor_clause is called when production for_clause is exited. +func (s *BaseTSqlParserListener) ExitFor_clause(ctx *For_clauseContext) {} + +// EnterXml_common_directives is called when production xml_common_directives is entered. +func (s *BaseTSqlParserListener) EnterXml_common_directives(ctx *Xml_common_directivesContext) {} + +// ExitXml_common_directives is called when production xml_common_directives is exited. +func (s *BaseTSqlParserListener) ExitXml_common_directives(ctx *Xml_common_directivesContext) {} + +// EnterOrder_by_expression is called when production order_by_expression is entered. +func (s *BaseTSqlParserListener) EnterOrder_by_expression(ctx *Order_by_expressionContext) {} + +// ExitOrder_by_expression is called when production order_by_expression is exited. +func (s *BaseTSqlParserListener) ExitOrder_by_expression(ctx *Order_by_expressionContext) {} + +// EnterGrouping_sets_item is called when production grouping_sets_item is entered. +func (s *BaseTSqlParserListener) EnterGrouping_sets_item(ctx *Grouping_sets_itemContext) {} + +// ExitGrouping_sets_item is called when production grouping_sets_item is exited. +func (s *BaseTSqlParserListener) ExitGrouping_sets_item(ctx *Grouping_sets_itemContext) {} + +// EnterGroup_by_item is called when production group_by_item is entered. +func (s *BaseTSqlParserListener) EnterGroup_by_item(ctx *Group_by_itemContext) {} + +// ExitGroup_by_item is called when production group_by_item is exited. +func (s *BaseTSqlParserListener) ExitGroup_by_item(ctx *Group_by_itemContext) {} + +// EnterOption_clause is called when production option_clause is entered. +func (s *BaseTSqlParserListener) EnterOption_clause(ctx *Option_clauseContext) {} + +// ExitOption_clause is called when production option_clause is exited. +func (s *BaseTSqlParserListener) ExitOption_clause(ctx *Option_clauseContext) {} + +// EnterOption is called when production option is entered. +func (s *BaseTSqlParserListener) EnterOption(ctx *OptionContext) {} + +// ExitOption is called when production option is exited. +func (s *BaseTSqlParserListener) ExitOption(ctx *OptionContext) {} + +// EnterOptimize_for_arg is called when production optimize_for_arg is entered. +func (s *BaseTSqlParserListener) EnterOptimize_for_arg(ctx *Optimize_for_argContext) {} + +// ExitOptimize_for_arg is called when production optimize_for_arg is exited. +func (s *BaseTSqlParserListener) ExitOptimize_for_arg(ctx *Optimize_for_argContext) {} + +// EnterSelect_list is called when production select_list is entered. +func (s *BaseTSqlParserListener) EnterSelect_list(ctx *Select_listContext) {} + +// ExitSelect_list is called when production select_list is exited. +func (s *BaseTSqlParserListener) ExitSelect_list(ctx *Select_listContext) {} + +// EnterUdt_method_arguments is called when production udt_method_arguments is entered. +func (s *BaseTSqlParserListener) EnterUdt_method_arguments(ctx *Udt_method_argumentsContext) {} + +// ExitUdt_method_arguments is called when production udt_method_arguments is exited. +func (s *BaseTSqlParserListener) ExitUdt_method_arguments(ctx *Udt_method_argumentsContext) {} + +// EnterAsterisk is called when production asterisk is entered. +func (s *BaseTSqlParserListener) EnterAsterisk(ctx *AsteriskContext) {} + +// ExitAsterisk is called when production asterisk is exited. +func (s *BaseTSqlParserListener) ExitAsterisk(ctx *AsteriskContext) {} + +// EnterUdt_elem is called when production udt_elem is entered. +func (s *BaseTSqlParserListener) EnterUdt_elem(ctx *Udt_elemContext) {} + +// ExitUdt_elem is called when production udt_elem is exited. +func (s *BaseTSqlParserListener) ExitUdt_elem(ctx *Udt_elemContext) {} + +// EnterExpression_elem is called when production expression_elem is entered. +func (s *BaseTSqlParserListener) EnterExpression_elem(ctx *Expression_elemContext) {} + +// ExitExpression_elem is called when production expression_elem is exited. +func (s *BaseTSqlParserListener) ExitExpression_elem(ctx *Expression_elemContext) {} + +// EnterSelect_list_elem is called when production select_list_elem is entered. +func (s *BaseTSqlParserListener) EnterSelect_list_elem(ctx *Select_list_elemContext) {} + +// ExitSelect_list_elem is called when production select_list_elem is exited. +func (s *BaseTSqlParserListener) ExitSelect_list_elem(ctx *Select_list_elemContext) {} + +// EnterTable_sources is called when production table_sources is entered. +func (s *BaseTSqlParserListener) EnterTable_sources(ctx *Table_sourcesContext) {} + +// ExitTable_sources is called when production table_sources is exited. +func (s *BaseTSqlParserListener) ExitTable_sources(ctx *Table_sourcesContext) {} + +// EnterTable_source is called when production table_source is entered. +func (s *BaseTSqlParserListener) EnterTable_source(ctx *Table_sourceContext) {} + +// ExitTable_source is called when production table_source is exited. +func (s *BaseTSqlParserListener) ExitTable_source(ctx *Table_sourceContext) {} + +// EnterTable_source_item is called when production table_source_item is entered. +func (s *BaseTSqlParserListener) EnterTable_source_item(ctx *Table_source_itemContext) {} + +// ExitTable_source_item is called when production table_source_item is exited. +func (s *BaseTSqlParserListener) ExitTable_source_item(ctx *Table_source_itemContext) {} + +// EnterOpen_xml is called when production open_xml is entered. +func (s *BaseTSqlParserListener) EnterOpen_xml(ctx *Open_xmlContext) {} + +// ExitOpen_xml is called when production open_xml is exited. +func (s *BaseTSqlParserListener) ExitOpen_xml(ctx *Open_xmlContext) {} + +// EnterOpen_json is called when production open_json is entered. +func (s *BaseTSqlParserListener) EnterOpen_json(ctx *Open_jsonContext) {} + +// ExitOpen_json is called when production open_json is exited. +func (s *BaseTSqlParserListener) ExitOpen_json(ctx *Open_jsonContext) {} + +// EnterJson_declaration is called when production json_declaration is entered. +func (s *BaseTSqlParserListener) EnterJson_declaration(ctx *Json_declarationContext) {} + +// ExitJson_declaration is called when production json_declaration is exited. +func (s *BaseTSqlParserListener) ExitJson_declaration(ctx *Json_declarationContext) {} + +// EnterJson_column_declaration is called when production json_column_declaration is entered. +func (s *BaseTSqlParserListener) EnterJson_column_declaration(ctx *Json_column_declarationContext) {} + +// ExitJson_column_declaration is called when production json_column_declaration is exited. +func (s *BaseTSqlParserListener) ExitJson_column_declaration(ctx *Json_column_declarationContext) {} + +// EnterSchema_declaration is called when production schema_declaration is entered. +func (s *BaseTSqlParserListener) EnterSchema_declaration(ctx *Schema_declarationContext) {} + +// ExitSchema_declaration is called when production schema_declaration is exited. +func (s *BaseTSqlParserListener) ExitSchema_declaration(ctx *Schema_declarationContext) {} + +// EnterColumn_declaration is called when production column_declaration is entered. +func (s *BaseTSqlParserListener) EnterColumn_declaration(ctx *Column_declarationContext) {} + +// ExitColumn_declaration is called when production column_declaration is exited. +func (s *BaseTSqlParserListener) ExitColumn_declaration(ctx *Column_declarationContext) {} + +// EnterChange_table is called when production change_table is entered. +func (s *BaseTSqlParserListener) EnterChange_table(ctx *Change_tableContext) {} + +// ExitChange_table is called when production change_table is exited. +func (s *BaseTSqlParserListener) ExitChange_table(ctx *Change_tableContext) {} + +// EnterChange_table_changes is called when production change_table_changes is entered. +func (s *BaseTSqlParserListener) EnterChange_table_changes(ctx *Change_table_changesContext) {} + +// ExitChange_table_changes is called when production change_table_changes is exited. +func (s *BaseTSqlParserListener) ExitChange_table_changes(ctx *Change_table_changesContext) {} + +// EnterChange_table_version is called when production change_table_version is entered. +func (s *BaseTSqlParserListener) EnterChange_table_version(ctx *Change_table_versionContext) {} + +// ExitChange_table_version is called when production change_table_version is exited. +func (s *BaseTSqlParserListener) ExitChange_table_version(ctx *Change_table_versionContext) {} + +// EnterJoin_part is called when production join_part is entered. +func (s *BaseTSqlParserListener) EnterJoin_part(ctx *Join_partContext) {} + +// ExitJoin_part is called when production join_part is exited. +func (s *BaseTSqlParserListener) ExitJoin_part(ctx *Join_partContext) {} + +// EnterJoin_on is called when production join_on is entered. +func (s *BaseTSqlParserListener) EnterJoin_on(ctx *Join_onContext) {} + +// ExitJoin_on is called when production join_on is exited. +func (s *BaseTSqlParserListener) ExitJoin_on(ctx *Join_onContext) {} + +// EnterCross_join is called when production cross_join is entered. +func (s *BaseTSqlParserListener) EnterCross_join(ctx *Cross_joinContext) {} + +// ExitCross_join is called when production cross_join is exited. +func (s *BaseTSqlParserListener) ExitCross_join(ctx *Cross_joinContext) {} + +// EnterApply_ is called when production apply_ is entered. +func (s *BaseTSqlParserListener) EnterApply_(ctx *Apply_Context) {} + +// ExitApply_ is called when production apply_ is exited. +func (s *BaseTSqlParserListener) ExitApply_(ctx *Apply_Context) {} + +// EnterPivot is called when production pivot is entered. +func (s *BaseTSqlParserListener) EnterPivot(ctx *PivotContext) {} + +// ExitPivot is called when production pivot is exited. +func (s *BaseTSqlParserListener) ExitPivot(ctx *PivotContext) {} + +// EnterUnpivot is called when production unpivot is entered. +func (s *BaseTSqlParserListener) EnterUnpivot(ctx *UnpivotContext) {} + +// ExitUnpivot is called when production unpivot is exited. +func (s *BaseTSqlParserListener) ExitUnpivot(ctx *UnpivotContext) {} + +// EnterPivot_clause is called when production pivot_clause is entered. +func (s *BaseTSqlParserListener) EnterPivot_clause(ctx *Pivot_clauseContext) {} + +// ExitPivot_clause is called when production pivot_clause is exited. +func (s *BaseTSqlParserListener) ExitPivot_clause(ctx *Pivot_clauseContext) {} + +// EnterUnpivot_clause is called when production unpivot_clause is entered. +func (s *BaseTSqlParserListener) EnterUnpivot_clause(ctx *Unpivot_clauseContext) {} + +// ExitUnpivot_clause is called when production unpivot_clause is exited. +func (s *BaseTSqlParserListener) ExitUnpivot_clause(ctx *Unpivot_clauseContext) {} + +// EnterFull_column_name_list is called when production full_column_name_list is entered. +func (s *BaseTSqlParserListener) EnterFull_column_name_list(ctx *Full_column_name_listContext) {} + +// ExitFull_column_name_list is called when production full_column_name_list is exited. +func (s *BaseTSqlParserListener) ExitFull_column_name_list(ctx *Full_column_name_listContext) {} + +// EnterRowset_function is called when production rowset_function is entered. +func (s *BaseTSqlParserListener) EnterRowset_function(ctx *Rowset_functionContext) {} + +// ExitRowset_function is called when production rowset_function is exited. +func (s *BaseTSqlParserListener) ExitRowset_function(ctx *Rowset_functionContext) {} + +// EnterBulk_option is called when production bulk_option is entered. +func (s *BaseTSqlParserListener) EnterBulk_option(ctx *Bulk_optionContext) {} + +// ExitBulk_option is called when production bulk_option is exited. +func (s *BaseTSqlParserListener) ExitBulk_option(ctx *Bulk_optionContext) {} + +// EnterDerived_table is called when production derived_table is entered. +func (s *BaseTSqlParserListener) EnterDerived_table(ctx *Derived_tableContext) {} + +// ExitDerived_table is called when production derived_table is exited. +func (s *BaseTSqlParserListener) ExitDerived_table(ctx *Derived_tableContext) {} + +// EnterRANKING_WINDOWED_FUNC is called when production RANKING_WINDOWED_FUNC is entered. +func (s *BaseTSqlParserListener) EnterRANKING_WINDOWED_FUNC(ctx *RANKING_WINDOWED_FUNCContext) {} + +// ExitRANKING_WINDOWED_FUNC is called when production RANKING_WINDOWED_FUNC is exited. +func (s *BaseTSqlParserListener) ExitRANKING_WINDOWED_FUNC(ctx *RANKING_WINDOWED_FUNCContext) {} + +// EnterAGGREGATE_WINDOWED_FUNC is called when production AGGREGATE_WINDOWED_FUNC is entered. +func (s *BaseTSqlParserListener) EnterAGGREGATE_WINDOWED_FUNC(ctx *AGGREGATE_WINDOWED_FUNCContext) {} + +// ExitAGGREGATE_WINDOWED_FUNC is called when production AGGREGATE_WINDOWED_FUNC is exited. +func (s *BaseTSqlParserListener) ExitAGGREGATE_WINDOWED_FUNC(ctx *AGGREGATE_WINDOWED_FUNCContext) {} + +// EnterANALYTIC_WINDOWED_FUNC is called when production ANALYTIC_WINDOWED_FUNC is entered. +func (s *BaseTSqlParserListener) EnterANALYTIC_WINDOWED_FUNC(ctx *ANALYTIC_WINDOWED_FUNCContext) {} + +// ExitANALYTIC_WINDOWED_FUNC is called when production ANALYTIC_WINDOWED_FUNC is exited. +func (s *BaseTSqlParserListener) ExitANALYTIC_WINDOWED_FUNC(ctx *ANALYTIC_WINDOWED_FUNCContext) {} + +// EnterBUILT_IN_FUNC is called when production BUILT_IN_FUNC is entered. +func (s *BaseTSqlParserListener) EnterBUILT_IN_FUNC(ctx *BUILT_IN_FUNCContext) {} + +// ExitBUILT_IN_FUNC is called when production BUILT_IN_FUNC is exited. +func (s *BaseTSqlParserListener) ExitBUILT_IN_FUNC(ctx *BUILT_IN_FUNCContext) {} + +// EnterSCALAR_FUNCTION is called when production SCALAR_FUNCTION is entered. +func (s *BaseTSqlParserListener) EnterSCALAR_FUNCTION(ctx *SCALAR_FUNCTIONContext) {} + +// ExitSCALAR_FUNCTION is called when production SCALAR_FUNCTION is exited. +func (s *BaseTSqlParserListener) ExitSCALAR_FUNCTION(ctx *SCALAR_FUNCTIONContext) {} + +// EnterFREE_TEXT is called when production FREE_TEXT is entered. +func (s *BaseTSqlParserListener) EnterFREE_TEXT(ctx *FREE_TEXTContext) {} + +// ExitFREE_TEXT is called when production FREE_TEXT is exited. +func (s *BaseTSqlParserListener) ExitFREE_TEXT(ctx *FREE_TEXTContext) {} + +// EnterPARTITION_FUNC is called when production PARTITION_FUNC is entered. +func (s *BaseTSqlParserListener) EnterPARTITION_FUNC(ctx *PARTITION_FUNCContext) {} + +// ExitPARTITION_FUNC is called when production PARTITION_FUNC is exited. +func (s *BaseTSqlParserListener) ExitPARTITION_FUNC(ctx *PARTITION_FUNCContext) {} + +// EnterHIERARCHYID_METHOD is called when production HIERARCHYID_METHOD is entered. +func (s *BaseTSqlParserListener) EnterHIERARCHYID_METHOD(ctx *HIERARCHYID_METHODContext) {} + +// ExitHIERARCHYID_METHOD is called when production HIERARCHYID_METHOD is exited. +func (s *BaseTSqlParserListener) ExitHIERARCHYID_METHOD(ctx *HIERARCHYID_METHODContext) {} + +// EnterPartition_function is called when production partition_function is entered. +func (s *BaseTSqlParserListener) EnterPartition_function(ctx *Partition_functionContext) {} + +// ExitPartition_function is called when production partition_function is exited. +func (s *BaseTSqlParserListener) ExitPartition_function(ctx *Partition_functionContext) {} + +// EnterFreetext_function is called when production freetext_function is entered. +func (s *BaseTSqlParserListener) EnterFreetext_function(ctx *Freetext_functionContext) {} + +// ExitFreetext_function is called when production freetext_function is exited. +func (s *BaseTSqlParserListener) ExitFreetext_function(ctx *Freetext_functionContext) {} + +// EnterFreetext_predicate is called when production freetext_predicate is entered. +func (s *BaseTSqlParserListener) EnterFreetext_predicate(ctx *Freetext_predicateContext) {} + +// ExitFreetext_predicate is called when production freetext_predicate is exited. +func (s *BaseTSqlParserListener) ExitFreetext_predicate(ctx *Freetext_predicateContext) {} + +// EnterJson_key_value is called when production json_key_value is entered. +func (s *BaseTSqlParserListener) EnterJson_key_value(ctx *Json_key_valueContext) {} + +// ExitJson_key_value is called when production json_key_value is exited. +func (s *BaseTSqlParserListener) ExitJson_key_value(ctx *Json_key_valueContext) {} + +// EnterJson_null_clause is called when production json_null_clause is entered. +func (s *BaseTSqlParserListener) EnterJson_null_clause(ctx *Json_null_clauseContext) {} + +// ExitJson_null_clause is called when production json_null_clause is exited. +func (s *BaseTSqlParserListener) ExitJson_null_clause(ctx *Json_null_clauseContext) {} + +// EnterAPP_NAME is called when production APP_NAME is entered. +func (s *BaseTSqlParserListener) EnterAPP_NAME(ctx *APP_NAMEContext) {} + +// ExitAPP_NAME is called when production APP_NAME is exited. +func (s *BaseTSqlParserListener) ExitAPP_NAME(ctx *APP_NAMEContext) {} + +// EnterAPPLOCK_MODE is called when production APPLOCK_MODE is entered. +func (s *BaseTSqlParserListener) EnterAPPLOCK_MODE(ctx *APPLOCK_MODEContext) {} + +// ExitAPPLOCK_MODE is called when production APPLOCK_MODE is exited. +func (s *BaseTSqlParserListener) ExitAPPLOCK_MODE(ctx *APPLOCK_MODEContext) {} + +// EnterAPPLOCK_TEST is called when production APPLOCK_TEST is entered. +func (s *BaseTSqlParserListener) EnterAPPLOCK_TEST(ctx *APPLOCK_TESTContext) {} + +// ExitAPPLOCK_TEST is called when production APPLOCK_TEST is exited. +func (s *BaseTSqlParserListener) ExitAPPLOCK_TEST(ctx *APPLOCK_TESTContext) {} + +// EnterASSEMBLYPROPERTY is called when production ASSEMBLYPROPERTY is entered. +func (s *BaseTSqlParserListener) EnterASSEMBLYPROPERTY(ctx *ASSEMBLYPROPERTYContext) {} + +// ExitASSEMBLYPROPERTY is called when production ASSEMBLYPROPERTY is exited. +func (s *BaseTSqlParserListener) ExitASSEMBLYPROPERTY(ctx *ASSEMBLYPROPERTYContext) {} + +// EnterCOL_LENGTH is called when production COL_LENGTH is entered. +func (s *BaseTSqlParserListener) EnterCOL_LENGTH(ctx *COL_LENGTHContext) {} + +// ExitCOL_LENGTH is called when production COL_LENGTH is exited. +func (s *BaseTSqlParserListener) ExitCOL_LENGTH(ctx *COL_LENGTHContext) {} + +// EnterCOL_NAME is called when production COL_NAME is entered. +func (s *BaseTSqlParserListener) EnterCOL_NAME(ctx *COL_NAMEContext) {} + +// ExitCOL_NAME is called when production COL_NAME is exited. +func (s *BaseTSqlParserListener) ExitCOL_NAME(ctx *COL_NAMEContext) {} + +// EnterCOLUMNPROPERTY is called when production COLUMNPROPERTY is entered. +func (s *BaseTSqlParserListener) EnterCOLUMNPROPERTY(ctx *COLUMNPROPERTYContext) {} + +// ExitCOLUMNPROPERTY is called when production COLUMNPROPERTY is exited. +func (s *BaseTSqlParserListener) ExitCOLUMNPROPERTY(ctx *COLUMNPROPERTYContext) {} + +// EnterDATABASEPROPERTYEX is called when production DATABASEPROPERTYEX is entered. +func (s *BaseTSqlParserListener) EnterDATABASEPROPERTYEX(ctx *DATABASEPROPERTYEXContext) {} + +// ExitDATABASEPROPERTYEX is called when production DATABASEPROPERTYEX is exited. +func (s *BaseTSqlParserListener) ExitDATABASEPROPERTYEX(ctx *DATABASEPROPERTYEXContext) {} + +// EnterDB_ID is called when production DB_ID is entered. +func (s *BaseTSqlParserListener) EnterDB_ID(ctx *DB_IDContext) {} + +// ExitDB_ID is called when production DB_ID is exited. +func (s *BaseTSqlParserListener) ExitDB_ID(ctx *DB_IDContext) {} + +// EnterDB_NAME is called when production DB_NAME is entered. +func (s *BaseTSqlParserListener) EnterDB_NAME(ctx *DB_NAMEContext) {} + +// ExitDB_NAME is called when production DB_NAME is exited. +func (s *BaseTSqlParserListener) ExitDB_NAME(ctx *DB_NAMEContext) {} + +// EnterFILE_ID is called when production FILE_ID is entered. +func (s *BaseTSqlParserListener) EnterFILE_ID(ctx *FILE_IDContext) {} + +// ExitFILE_ID is called when production FILE_ID is exited. +func (s *BaseTSqlParserListener) ExitFILE_ID(ctx *FILE_IDContext) {} + +// EnterFILE_IDEX is called when production FILE_IDEX is entered. +func (s *BaseTSqlParserListener) EnterFILE_IDEX(ctx *FILE_IDEXContext) {} + +// ExitFILE_IDEX is called when production FILE_IDEX is exited. +func (s *BaseTSqlParserListener) ExitFILE_IDEX(ctx *FILE_IDEXContext) {} + +// EnterFILE_NAME is called when production FILE_NAME is entered. +func (s *BaseTSqlParserListener) EnterFILE_NAME(ctx *FILE_NAMEContext) {} + +// ExitFILE_NAME is called when production FILE_NAME is exited. +func (s *BaseTSqlParserListener) ExitFILE_NAME(ctx *FILE_NAMEContext) {} + +// EnterFILEGROUP_ID is called when production FILEGROUP_ID is entered. +func (s *BaseTSqlParserListener) EnterFILEGROUP_ID(ctx *FILEGROUP_IDContext) {} + +// ExitFILEGROUP_ID is called when production FILEGROUP_ID is exited. +func (s *BaseTSqlParserListener) ExitFILEGROUP_ID(ctx *FILEGROUP_IDContext) {} + +// EnterFILEGROUP_NAME is called when production FILEGROUP_NAME is entered. +func (s *BaseTSqlParserListener) EnterFILEGROUP_NAME(ctx *FILEGROUP_NAMEContext) {} + +// ExitFILEGROUP_NAME is called when production FILEGROUP_NAME is exited. +func (s *BaseTSqlParserListener) ExitFILEGROUP_NAME(ctx *FILEGROUP_NAMEContext) {} + +// EnterFILEGROUPPROPERTY is called when production FILEGROUPPROPERTY is entered. +func (s *BaseTSqlParserListener) EnterFILEGROUPPROPERTY(ctx *FILEGROUPPROPERTYContext) {} + +// ExitFILEGROUPPROPERTY is called when production FILEGROUPPROPERTY is exited. +func (s *BaseTSqlParserListener) ExitFILEGROUPPROPERTY(ctx *FILEGROUPPROPERTYContext) {} + +// EnterFILEPROPERTY is called when production FILEPROPERTY is entered. +func (s *BaseTSqlParserListener) EnterFILEPROPERTY(ctx *FILEPROPERTYContext) {} + +// ExitFILEPROPERTY is called when production FILEPROPERTY is exited. +func (s *BaseTSqlParserListener) ExitFILEPROPERTY(ctx *FILEPROPERTYContext) {} + +// EnterFILEPROPERTYEX is called when production FILEPROPERTYEX is entered. +func (s *BaseTSqlParserListener) EnterFILEPROPERTYEX(ctx *FILEPROPERTYEXContext) {} + +// ExitFILEPROPERTYEX is called when production FILEPROPERTYEX is exited. +func (s *BaseTSqlParserListener) ExitFILEPROPERTYEX(ctx *FILEPROPERTYEXContext) {} + +// EnterFULLTEXTCATALOGPROPERTY is called when production FULLTEXTCATALOGPROPERTY is entered. +func (s *BaseTSqlParserListener) EnterFULLTEXTCATALOGPROPERTY(ctx *FULLTEXTCATALOGPROPERTYContext) {} + +// ExitFULLTEXTCATALOGPROPERTY is called when production FULLTEXTCATALOGPROPERTY is exited. +func (s *BaseTSqlParserListener) ExitFULLTEXTCATALOGPROPERTY(ctx *FULLTEXTCATALOGPROPERTYContext) {} + +// EnterFULLTEXTSERVICEPROPERTY is called when production FULLTEXTSERVICEPROPERTY is entered. +func (s *BaseTSqlParserListener) EnterFULLTEXTSERVICEPROPERTY(ctx *FULLTEXTSERVICEPROPERTYContext) {} + +// ExitFULLTEXTSERVICEPROPERTY is called when production FULLTEXTSERVICEPROPERTY is exited. +func (s *BaseTSqlParserListener) ExitFULLTEXTSERVICEPROPERTY(ctx *FULLTEXTSERVICEPROPERTYContext) {} + +// EnterINDEX_COL is called when production INDEX_COL is entered. +func (s *BaseTSqlParserListener) EnterINDEX_COL(ctx *INDEX_COLContext) {} + +// ExitINDEX_COL is called when production INDEX_COL is exited. +func (s *BaseTSqlParserListener) ExitINDEX_COL(ctx *INDEX_COLContext) {} + +// EnterINDEXKEY_PROPERTY is called when production INDEXKEY_PROPERTY is entered. +func (s *BaseTSqlParserListener) EnterINDEXKEY_PROPERTY(ctx *INDEXKEY_PROPERTYContext) {} + +// ExitINDEXKEY_PROPERTY is called when production INDEXKEY_PROPERTY is exited. +func (s *BaseTSqlParserListener) ExitINDEXKEY_PROPERTY(ctx *INDEXKEY_PROPERTYContext) {} + +// EnterINDEXPROPERTY is called when production INDEXPROPERTY is entered. +func (s *BaseTSqlParserListener) EnterINDEXPROPERTY(ctx *INDEXPROPERTYContext) {} + +// ExitINDEXPROPERTY is called when production INDEXPROPERTY is exited. +func (s *BaseTSqlParserListener) ExitINDEXPROPERTY(ctx *INDEXPROPERTYContext) {} + +// EnterNEXT_VALUE_FOR is called when production NEXT_VALUE_FOR is entered. +func (s *BaseTSqlParserListener) EnterNEXT_VALUE_FOR(ctx *NEXT_VALUE_FORContext) {} + +// ExitNEXT_VALUE_FOR is called when production NEXT_VALUE_FOR is exited. +func (s *BaseTSqlParserListener) ExitNEXT_VALUE_FOR(ctx *NEXT_VALUE_FORContext) {} + +// EnterOBJECT_DEFINITION is called when production OBJECT_DEFINITION is entered. +func (s *BaseTSqlParserListener) EnterOBJECT_DEFINITION(ctx *OBJECT_DEFINITIONContext) {} + +// ExitOBJECT_DEFINITION is called when production OBJECT_DEFINITION is exited. +func (s *BaseTSqlParserListener) ExitOBJECT_DEFINITION(ctx *OBJECT_DEFINITIONContext) {} + +// EnterOBJECT_ID is called when production OBJECT_ID is entered. +func (s *BaseTSqlParserListener) EnterOBJECT_ID(ctx *OBJECT_IDContext) {} + +// ExitOBJECT_ID is called when production OBJECT_ID is exited. +func (s *BaseTSqlParserListener) ExitOBJECT_ID(ctx *OBJECT_IDContext) {} + +// EnterOBJECT_NAME is called when production OBJECT_NAME is entered. +func (s *BaseTSqlParserListener) EnterOBJECT_NAME(ctx *OBJECT_NAMEContext) {} + +// ExitOBJECT_NAME is called when production OBJECT_NAME is exited. +func (s *BaseTSqlParserListener) ExitOBJECT_NAME(ctx *OBJECT_NAMEContext) {} + +// EnterOBJECT_SCHEMA_NAME is called when production OBJECT_SCHEMA_NAME is entered. +func (s *BaseTSqlParserListener) EnterOBJECT_SCHEMA_NAME(ctx *OBJECT_SCHEMA_NAMEContext) {} + +// ExitOBJECT_SCHEMA_NAME is called when production OBJECT_SCHEMA_NAME is exited. +func (s *BaseTSqlParserListener) ExitOBJECT_SCHEMA_NAME(ctx *OBJECT_SCHEMA_NAMEContext) {} + +// EnterOBJECTPROPERTY is called when production OBJECTPROPERTY is entered. +func (s *BaseTSqlParserListener) EnterOBJECTPROPERTY(ctx *OBJECTPROPERTYContext) {} + +// ExitOBJECTPROPERTY is called when production OBJECTPROPERTY is exited. +func (s *BaseTSqlParserListener) ExitOBJECTPROPERTY(ctx *OBJECTPROPERTYContext) {} + +// EnterOBJECTPROPERTYEX is called when production OBJECTPROPERTYEX is entered. +func (s *BaseTSqlParserListener) EnterOBJECTPROPERTYEX(ctx *OBJECTPROPERTYEXContext) {} + +// ExitOBJECTPROPERTYEX is called when production OBJECTPROPERTYEX is exited. +func (s *BaseTSqlParserListener) ExitOBJECTPROPERTYEX(ctx *OBJECTPROPERTYEXContext) {} + +// EnterORIGINAL_DB_NAME is called when production ORIGINAL_DB_NAME is entered. +func (s *BaseTSqlParserListener) EnterORIGINAL_DB_NAME(ctx *ORIGINAL_DB_NAMEContext) {} + +// ExitORIGINAL_DB_NAME is called when production ORIGINAL_DB_NAME is exited. +func (s *BaseTSqlParserListener) ExitORIGINAL_DB_NAME(ctx *ORIGINAL_DB_NAMEContext) {} + +// EnterPARSENAME is called when production PARSENAME is entered. +func (s *BaseTSqlParserListener) EnterPARSENAME(ctx *PARSENAMEContext) {} + +// ExitPARSENAME is called when production PARSENAME is exited. +func (s *BaseTSqlParserListener) ExitPARSENAME(ctx *PARSENAMEContext) {} + +// EnterSCHEMA_ID is called when production SCHEMA_ID is entered. +func (s *BaseTSqlParserListener) EnterSCHEMA_ID(ctx *SCHEMA_IDContext) {} + +// ExitSCHEMA_ID is called when production SCHEMA_ID is exited. +func (s *BaseTSqlParserListener) ExitSCHEMA_ID(ctx *SCHEMA_IDContext) {} + +// EnterSCHEMA_NAME is called when production SCHEMA_NAME is entered. +func (s *BaseTSqlParserListener) EnterSCHEMA_NAME(ctx *SCHEMA_NAMEContext) {} + +// ExitSCHEMA_NAME is called when production SCHEMA_NAME is exited. +func (s *BaseTSqlParserListener) ExitSCHEMA_NAME(ctx *SCHEMA_NAMEContext) {} + +// EnterSCOPE_IDENTITY is called when production SCOPE_IDENTITY is entered. +func (s *BaseTSqlParserListener) EnterSCOPE_IDENTITY(ctx *SCOPE_IDENTITYContext) {} + +// ExitSCOPE_IDENTITY is called when production SCOPE_IDENTITY is exited. +func (s *BaseTSqlParserListener) ExitSCOPE_IDENTITY(ctx *SCOPE_IDENTITYContext) {} + +// EnterSERVERPROPERTY is called when production SERVERPROPERTY is entered. +func (s *BaseTSqlParserListener) EnterSERVERPROPERTY(ctx *SERVERPROPERTYContext) {} + +// ExitSERVERPROPERTY is called when production SERVERPROPERTY is exited. +func (s *BaseTSqlParserListener) ExitSERVERPROPERTY(ctx *SERVERPROPERTYContext) {} + +// EnterSTATS_DATE is called when production STATS_DATE is entered. +func (s *BaseTSqlParserListener) EnterSTATS_DATE(ctx *STATS_DATEContext) {} + +// ExitSTATS_DATE is called when production STATS_DATE is exited. +func (s *BaseTSqlParserListener) ExitSTATS_DATE(ctx *STATS_DATEContext) {} + +// EnterTYPE_ID is called when production TYPE_ID is entered. +func (s *BaseTSqlParserListener) EnterTYPE_ID(ctx *TYPE_IDContext) {} + +// ExitTYPE_ID is called when production TYPE_ID is exited. +func (s *BaseTSqlParserListener) ExitTYPE_ID(ctx *TYPE_IDContext) {} + +// EnterTYPE_NAME is called when production TYPE_NAME is entered. +func (s *BaseTSqlParserListener) EnterTYPE_NAME(ctx *TYPE_NAMEContext) {} + +// ExitTYPE_NAME is called when production TYPE_NAME is exited. +func (s *BaseTSqlParserListener) ExitTYPE_NAME(ctx *TYPE_NAMEContext) {} + +// EnterTYPEPROPERTY is called when production TYPEPROPERTY is entered. +func (s *BaseTSqlParserListener) EnterTYPEPROPERTY(ctx *TYPEPROPERTYContext) {} + +// ExitTYPEPROPERTY is called when production TYPEPROPERTY is exited. +func (s *BaseTSqlParserListener) ExitTYPEPROPERTY(ctx *TYPEPROPERTYContext) {} + +// EnterASCII is called when production ASCII is entered. +func (s *BaseTSqlParserListener) EnterASCII(ctx *ASCIIContext) {} + +// ExitASCII is called when production ASCII is exited. +func (s *BaseTSqlParserListener) ExitASCII(ctx *ASCIIContext) {} + +// EnterCHAR is called when production CHAR is entered. +func (s *BaseTSqlParserListener) EnterCHAR(ctx *CHARContext) {} + +// ExitCHAR is called when production CHAR is exited. +func (s *BaseTSqlParserListener) ExitCHAR(ctx *CHARContext) {} + +// EnterCHARINDEX is called when production CHARINDEX is entered. +func (s *BaseTSqlParserListener) EnterCHARINDEX(ctx *CHARINDEXContext) {} + +// ExitCHARINDEX is called when production CHARINDEX is exited. +func (s *BaseTSqlParserListener) ExitCHARINDEX(ctx *CHARINDEXContext) {} + +// EnterCONCAT is called when production CONCAT is entered. +func (s *BaseTSqlParserListener) EnterCONCAT(ctx *CONCATContext) {} + +// ExitCONCAT is called when production CONCAT is exited. +func (s *BaseTSqlParserListener) ExitCONCAT(ctx *CONCATContext) {} + +// EnterCONCAT_WS is called when production CONCAT_WS is entered. +func (s *BaseTSqlParserListener) EnterCONCAT_WS(ctx *CONCAT_WSContext) {} + +// ExitCONCAT_WS is called when production CONCAT_WS is exited. +func (s *BaseTSqlParserListener) ExitCONCAT_WS(ctx *CONCAT_WSContext) {} + +// EnterDIFFERENCE is called when production DIFFERENCE is entered. +func (s *BaseTSqlParserListener) EnterDIFFERENCE(ctx *DIFFERENCEContext) {} + +// ExitDIFFERENCE is called when production DIFFERENCE is exited. +func (s *BaseTSqlParserListener) ExitDIFFERENCE(ctx *DIFFERENCEContext) {} + +// EnterFORMAT is called when production FORMAT is entered. +func (s *BaseTSqlParserListener) EnterFORMAT(ctx *FORMATContext) {} + +// ExitFORMAT is called when production FORMAT is exited. +func (s *BaseTSqlParserListener) ExitFORMAT(ctx *FORMATContext) {} + +// EnterLEFT is called when production LEFT is entered. +func (s *BaseTSqlParserListener) EnterLEFT(ctx *LEFTContext) {} + +// ExitLEFT is called when production LEFT is exited. +func (s *BaseTSqlParserListener) ExitLEFT(ctx *LEFTContext) {} + +// EnterLEN is called when production LEN is entered. +func (s *BaseTSqlParserListener) EnterLEN(ctx *LENContext) {} + +// ExitLEN is called when production LEN is exited. +func (s *BaseTSqlParserListener) ExitLEN(ctx *LENContext) {} + +// EnterLOWER is called when production LOWER is entered. +func (s *BaseTSqlParserListener) EnterLOWER(ctx *LOWERContext) {} + +// ExitLOWER is called when production LOWER is exited. +func (s *BaseTSqlParserListener) ExitLOWER(ctx *LOWERContext) {} + +// EnterLTRIM is called when production LTRIM is entered. +func (s *BaseTSqlParserListener) EnterLTRIM(ctx *LTRIMContext) {} + +// ExitLTRIM is called when production LTRIM is exited. +func (s *BaseTSqlParserListener) ExitLTRIM(ctx *LTRIMContext) {} + +// EnterNCHAR is called when production NCHAR is entered. +func (s *BaseTSqlParserListener) EnterNCHAR(ctx *NCHARContext) {} + +// ExitNCHAR is called when production NCHAR is exited. +func (s *BaseTSqlParserListener) ExitNCHAR(ctx *NCHARContext) {} + +// EnterPATINDEX is called when production PATINDEX is entered. +func (s *BaseTSqlParserListener) EnterPATINDEX(ctx *PATINDEXContext) {} + +// ExitPATINDEX is called when production PATINDEX is exited. +func (s *BaseTSqlParserListener) ExitPATINDEX(ctx *PATINDEXContext) {} + +// EnterQUOTENAME is called when production QUOTENAME is entered. +func (s *BaseTSqlParserListener) EnterQUOTENAME(ctx *QUOTENAMEContext) {} + +// ExitQUOTENAME is called when production QUOTENAME is exited. +func (s *BaseTSqlParserListener) ExitQUOTENAME(ctx *QUOTENAMEContext) {} + +// EnterREPLACE is called when production REPLACE is entered. +func (s *BaseTSqlParserListener) EnterREPLACE(ctx *REPLACEContext) {} + +// ExitREPLACE is called when production REPLACE is exited. +func (s *BaseTSqlParserListener) ExitREPLACE(ctx *REPLACEContext) {} + +// EnterREPLICATE is called when production REPLICATE is entered. +func (s *BaseTSqlParserListener) EnterREPLICATE(ctx *REPLICATEContext) {} + +// ExitREPLICATE is called when production REPLICATE is exited. +func (s *BaseTSqlParserListener) ExitREPLICATE(ctx *REPLICATEContext) {} + +// EnterREVERSE is called when production REVERSE is entered. +func (s *BaseTSqlParserListener) EnterREVERSE(ctx *REVERSEContext) {} + +// ExitREVERSE is called when production REVERSE is exited. +func (s *BaseTSqlParserListener) ExitREVERSE(ctx *REVERSEContext) {} + +// EnterRIGHT is called when production RIGHT is entered. +func (s *BaseTSqlParserListener) EnterRIGHT(ctx *RIGHTContext) {} + +// ExitRIGHT is called when production RIGHT is exited. +func (s *BaseTSqlParserListener) ExitRIGHT(ctx *RIGHTContext) {} + +// EnterRTRIM is called when production RTRIM is entered. +func (s *BaseTSqlParserListener) EnterRTRIM(ctx *RTRIMContext) {} + +// ExitRTRIM is called when production RTRIM is exited. +func (s *BaseTSqlParserListener) ExitRTRIM(ctx *RTRIMContext) {} + +// EnterSOUNDEX is called when production SOUNDEX is entered. +func (s *BaseTSqlParserListener) EnterSOUNDEX(ctx *SOUNDEXContext) {} + +// ExitSOUNDEX is called when production SOUNDEX is exited. +func (s *BaseTSqlParserListener) ExitSOUNDEX(ctx *SOUNDEXContext) {} + +// EnterSPACE is called when production SPACE is entered. +func (s *BaseTSqlParserListener) EnterSPACE(ctx *SPACEContext) {} + +// ExitSPACE is called when production SPACE is exited. +func (s *BaseTSqlParserListener) ExitSPACE(ctx *SPACEContext) {} + +// EnterSTR is called when production STR is entered. +func (s *BaseTSqlParserListener) EnterSTR(ctx *STRContext) {} + +// ExitSTR is called when production STR is exited. +func (s *BaseTSqlParserListener) ExitSTR(ctx *STRContext) {} + +// EnterSTRINGAGG is called when production STRINGAGG is entered. +func (s *BaseTSqlParserListener) EnterSTRINGAGG(ctx *STRINGAGGContext) {} + +// ExitSTRINGAGG is called when production STRINGAGG is exited. +func (s *BaseTSqlParserListener) ExitSTRINGAGG(ctx *STRINGAGGContext) {} + +// EnterSTRING_ESCAPE is called when production STRING_ESCAPE is entered. +func (s *BaseTSqlParserListener) EnterSTRING_ESCAPE(ctx *STRING_ESCAPEContext) {} + +// ExitSTRING_ESCAPE is called when production STRING_ESCAPE is exited. +func (s *BaseTSqlParserListener) ExitSTRING_ESCAPE(ctx *STRING_ESCAPEContext) {} + +// EnterSTUFF is called when production STUFF is entered. +func (s *BaseTSqlParserListener) EnterSTUFF(ctx *STUFFContext) {} + +// ExitSTUFF is called when production STUFF is exited. +func (s *BaseTSqlParserListener) ExitSTUFF(ctx *STUFFContext) {} + +// EnterSUBSTRING is called when production SUBSTRING is entered. +func (s *BaseTSqlParserListener) EnterSUBSTRING(ctx *SUBSTRINGContext) {} + +// ExitSUBSTRING is called when production SUBSTRING is exited. +func (s *BaseTSqlParserListener) ExitSUBSTRING(ctx *SUBSTRINGContext) {} + +// EnterTRANSLATE is called when production TRANSLATE is entered. +func (s *BaseTSqlParserListener) EnterTRANSLATE(ctx *TRANSLATEContext) {} + +// ExitTRANSLATE is called when production TRANSLATE is exited. +func (s *BaseTSqlParserListener) ExitTRANSLATE(ctx *TRANSLATEContext) {} + +// EnterTRIM is called when production TRIM is entered. +func (s *BaseTSqlParserListener) EnterTRIM(ctx *TRIMContext) {} + +// ExitTRIM is called when production TRIM is exited. +func (s *BaseTSqlParserListener) ExitTRIM(ctx *TRIMContext) {} + +// EnterUNICODE is called when production UNICODE is entered. +func (s *BaseTSqlParserListener) EnterUNICODE(ctx *UNICODEContext) {} + +// ExitUNICODE is called when production UNICODE is exited. +func (s *BaseTSqlParserListener) ExitUNICODE(ctx *UNICODEContext) {} + +// EnterUPPER is called when production UPPER is entered. +func (s *BaseTSqlParserListener) EnterUPPER(ctx *UPPERContext) {} + +// ExitUPPER is called when production UPPER is exited. +func (s *BaseTSqlParserListener) ExitUPPER(ctx *UPPERContext) {} + +// EnterBINARY_CHECKSUM is called when production BINARY_CHECKSUM is entered. +func (s *BaseTSqlParserListener) EnterBINARY_CHECKSUM(ctx *BINARY_CHECKSUMContext) {} + +// ExitBINARY_CHECKSUM is called when production BINARY_CHECKSUM is exited. +func (s *BaseTSqlParserListener) ExitBINARY_CHECKSUM(ctx *BINARY_CHECKSUMContext) {} + +// EnterCHECKSUM is called when production CHECKSUM is entered. +func (s *BaseTSqlParserListener) EnterCHECKSUM(ctx *CHECKSUMContext) {} + +// ExitCHECKSUM is called when production CHECKSUM is exited. +func (s *BaseTSqlParserListener) ExitCHECKSUM(ctx *CHECKSUMContext) {} + +// EnterCOMPRESS is called when production COMPRESS is entered. +func (s *BaseTSqlParserListener) EnterCOMPRESS(ctx *COMPRESSContext) {} + +// ExitCOMPRESS is called when production COMPRESS is exited. +func (s *BaseTSqlParserListener) ExitCOMPRESS(ctx *COMPRESSContext) {} + +// EnterCONNECTIONPROPERTY is called when production CONNECTIONPROPERTY is entered. +func (s *BaseTSqlParserListener) EnterCONNECTIONPROPERTY(ctx *CONNECTIONPROPERTYContext) {} + +// ExitCONNECTIONPROPERTY is called when production CONNECTIONPROPERTY is exited. +func (s *BaseTSqlParserListener) ExitCONNECTIONPROPERTY(ctx *CONNECTIONPROPERTYContext) {} + +// EnterCONTEXT_INFO is called when production CONTEXT_INFO is entered. +func (s *BaseTSqlParserListener) EnterCONTEXT_INFO(ctx *CONTEXT_INFOContext) {} + +// ExitCONTEXT_INFO is called when production CONTEXT_INFO is exited. +func (s *BaseTSqlParserListener) ExitCONTEXT_INFO(ctx *CONTEXT_INFOContext) {} + +// EnterCURRENT_REQUEST_ID is called when production CURRENT_REQUEST_ID is entered. +func (s *BaseTSqlParserListener) EnterCURRENT_REQUEST_ID(ctx *CURRENT_REQUEST_IDContext) {} + +// ExitCURRENT_REQUEST_ID is called when production CURRENT_REQUEST_ID is exited. +func (s *BaseTSqlParserListener) ExitCURRENT_REQUEST_ID(ctx *CURRENT_REQUEST_IDContext) {} + +// EnterCURRENT_TRANSACTION_ID is called when production CURRENT_TRANSACTION_ID is entered. +func (s *BaseTSqlParserListener) EnterCURRENT_TRANSACTION_ID(ctx *CURRENT_TRANSACTION_IDContext) {} + +// ExitCURRENT_TRANSACTION_ID is called when production CURRENT_TRANSACTION_ID is exited. +func (s *BaseTSqlParserListener) ExitCURRENT_TRANSACTION_ID(ctx *CURRENT_TRANSACTION_IDContext) {} + +// EnterDECOMPRESS is called when production DECOMPRESS is entered. +func (s *BaseTSqlParserListener) EnterDECOMPRESS(ctx *DECOMPRESSContext) {} + +// ExitDECOMPRESS is called when production DECOMPRESS is exited. +func (s *BaseTSqlParserListener) ExitDECOMPRESS(ctx *DECOMPRESSContext) {} + +// EnterERROR_LINE is called when production ERROR_LINE is entered. +func (s *BaseTSqlParserListener) EnterERROR_LINE(ctx *ERROR_LINEContext) {} + +// ExitERROR_LINE is called when production ERROR_LINE is exited. +func (s *BaseTSqlParserListener) ExitERROR_LINE(ctx *ERROR_LINEContext) {} + +// EnterERROR_MESSAGE is called when production ERROR_MESSAGE is entered. +func (s *BaseTSqlParserListener) EnterERROR_MESSAGE(ctx *ERROR_MESSAGEContext) {} + +// ExitERROR_MESSAGE is called when production ERROR_MESSAGE is exited. +func (s *BaseTSqlParserListener) ExitERROR_MESSAGE(ctx *ERROR_MESSAGEContext) {} + +// EnterERROR_NUMBER is called when production ERROR_NUMBER is entered. +func (s *BaseTSqlParserListener) EnterERROR_NUMBER(ctx *ERROR_NUMBERContext) {} + +// ExitERROR_NUMBER is called when production ERROR_NUMBER is exited. +func (s *BaseTSqlParserListener) ExitERROR_NUMBER(ctx *ERROR_NUMBERContext) {} + +// EnterERROR_PROCEDURE is called when production ERROR_PROCEDURE is entered. +func (s *BaseTSqlParserListener) EnterERROR_PROCEDURE(ctx *ERROR_PROCEDUREContext) {} + +// ExitERROR_PROCEDURE is called when production ERROR_PROCEDURE is exited. +func (s *BaseTSqlParserListener) ExitERROR_PROCEDURE(ctx *ERROR_PROCEDUREContext) {} + +// EnterERROR_SEVERITY is called when production ERROR_SEVERITY is entered. +func (s *BaseTSqlParserListener) EnterERROR_SEVERITY(ctx *ERROR_SEVERITYContext) {} + +// ExitERROR_SEVERITY is called when production ERROR_SEVERITY is exited. +func (s *BaseTSqlParserListener) ExitERROR_SEVERITY(ctx *ERROR_SEVERITYContext) {} + +// EnterERROR_STATE is called when production ERROR_STATE is entered. +func (s *BaseTSqlParserListener) EnterERROR_STATE(ctx *ERROR_STATEContext) {} + +// ExitERROR_STATE is called when production ERROR_STATE is exited. +func (s *BaseTSqlParserListener) ExitERROR_STATE(ctx *ERROR_STATEContext) {} + +// EnterFORMATMESSAGE is called when production FORMATMESSAGE is entered. +func (s *BaseTSqlParserListener) EnterFORMATMESSAGE(ctx *FORMATMESSAGEContext) {} + +// ExitFORMATMESSAGE is called when production FORMATMESSAGE is exited. +func (s *BaseTSqlParserListener) ExitFORMATMESSAGE(ctx *FORMATMESSAGEContext) {} + +// EnterGET_FILESTREAM_TRANSACTION_CONTEXT is called when production GET_FILESTREAM_TRANSACTION_CONTEXT is entered. +func (s *BaseTSqlParserListener) EnterGET_FILESTREAM_TRANSACTION_CONTEXT(ctx *GET_FILESTREAM_TRANSACTION_CONTEXTContext) { +} + +// ExitGET_FILESTREAM_TRANSACTION_CONTEXT is called when production GET_FILESTREAM_TRANSACTION_CONTEXT is exited. +func (s *BaseTSqlParserListener) ExitGET_FILESTREAM_TRANSACTION_CONTEXT(ctx *GET_FILESTREAM_TRANSACTION_CONTEXTContext) { +} + +// EnterGETANSINULL is called when production GETANSINULL is entered. +func (s *BaseTSqlParserListener) EnterGETANSINULL(ctx *GETANSINULLContext) {} + +// ExitGETANSINULL is called when production GETANSINULL is exited. +func (s *BaseTSqlParserListener) ExitGETANSINULL(ctx *GETANSINULLContext) {} + +// EnterHOST_ID is called when production HOST_ID is entered. +func (s *BaseTSqlParserListener) EnterHOST_ID(ctx *HOST_IDContext) {} + +// ExitHOST_ID is called when production HOST_ID is exited. +func (s *BaseTSqlParserListener) ExitHOST_ID(ctx *HOST_IDContext) {} + +// EnterHOST_NAME is called when production HOST_NAME is entered. +func (s *BaseTSqlParserListener) EnterHOST_NAME(ctx *HOST_NAMEContext) {} + +// ExitHOST_NAME is called when production HOST_NAME is exited. +func (s *BaseTSqlParserListener) ExitHOST_NAME(ctx *HOST_NAMEContext) {} + +// EnterISNULL is called when production ISNULL is entered. +func (s *BaseTSqlParserListener) EnterISNULL(ctx *ISNULLContext) {} + +// ExitISNULL is called when production ISNULL is exited. +func (s *BaseTSqlParserListener) ExitISNULL(ctx *ISNULLContext) {} + +// EnterISNUMERIC is called when production ISNUMERIC is entered. +func (s *BaseTSqlParserListener) EnterISNUMERIC(ctx *ISNUMERICContext) {} + +// ExitISNUMERIC is called when production ISNUMERIC is exited. +func (s *BaseTSqlParserListener) ExitISNUMERIC(ctx *ISNUMERICContext) {} + +// EnterMIN_ACTIVE_ROWVERSION is called when production MIN_ACTIVE_ROWVERSION is entered. +func (s *BaseTSqlParserListener) EnterMIN_ACTIVE_ROWVERSION(ctx *MIN_ACTIVE_ROWVERSIONContext) {} + +// ExitMIN_ACTIVE_ROWVERSION is called when production MIN_ACTIVE_ROWVERSION is exited. +func (s *BaseTSqlParserListener) ExitMIN_ACTIVE_ROWVERSION(ctx *MIN_ACTIVE_ROWVERSIONContext) {} + +// EnterNEWID is called when production NEWID is entered. +func (s *BaseTSqlParserListener) EnterNEWID(ctx *NEWIDContext) {} + +// ExitNEWID is called when production NEWID is exited. +func (s *BaseTSqlParserListener) ExitNEWID(ctx *NEWIDContext) {} + +// EnterNEWSEQUENTIALID is called when production NEWSEQUENTIALID is entered. +func (s *BaseTSqlParserListener) EnterNEWSEQUENTIALID(ctx *NEWSEQUENTIALIDContext) {} + +// ExitNEWSEQUENTIALID is called when production NEWSEQUENTIALID is exited. +func (s *BaseTSqlParserListener) ExitNEWSEQUENTIALID(ctx *NEWSEQUENTIALIDContext) {} + +// EnterROWCOUNT_BIG is called when production ROWCOUNT_BIG is entered. +func (s *BaseTSqlParserListener) EnterROWCOUNT_BIG(ctx *ROWCOUNT_BIGContext) {} + +// ExitROWCOUNT_BIG is called when production ROWCOUNT_BIG is exited. +func (s *BaseTSqlParserListener) ExitROWCOUNT_BIG(ctx *ROWCOUNT_BIGContext) {} + +// EnterSESSION_CONTEXT is called when production SESSION_CONTEXT is entered. +func (s *BaseTSqlParserListener) EnterSESSION_CONTEXT(ctx *SESSION_CONTEXTContext) {} + +// ExitSESSION_CONTEXT is called when production SESSION_CONTEXT is exited. +func (s *BaseTSqlParserListener) ExitSESSION_CONTEXT(ctx *SESSION_CONTEXTContext) {} + +// EnterXACT_STATE is called when production XACT_STATE is entered. +func (s *BaseTSqlParserListener) EnterXACT_STATE(ctx *XACT_STATEContext) {} + +// ExitXACT_STATE is called when production XACT_STATE is exited. +func (s *BaseTSqlParserListener) ExitXACT_STATE(ctx *XACT_STATEContext) {} + +// EnterCAST is called when production CAST is entered. +func (s *BaseTSqlParserListener) EnterCAST(ctx *CASTContext) {} + +// ExitCAST is called when production CAST is exited. +func (s *BaseTSqlParserListener) ExitCAST(ctx *CASTContext) {} + +// EnterTRY_CAST is called when production TRY_CAST is entered. +func (s *BaseTSqlParserListener) EnterTRY_CAST(ctx *TRY_CASTContext) {} + +// ExitTRY_CAST is called when production TRY_CAST is exited. +func (s *BaseTSqlParserListener) ExitTRY_CAST(ctx *TRY_CASTContext) {} + +// EnterCONVERT is called when production CONVERT is entered. +func (s *BaseTSqlParserListener) EnterCONVERT(ctx *CONVERTContext) {} + +// ExitCONVERT is called when production CONVERT is exited. +func (s *BaseTSqlParserListener) ExitCONVERT(ctx *CONVERTContext) {} + +// EnterCOALESCE is called when production COALESCE is entered. +func (s *BaseTSqlParserListener) EnterCOALESCE(ctx *COALESCEContext) {} + +// ExitCOALESCE is called when production COALESCE is exited. +func (s *BaseTSqlParserListener) ExitCOALESCE(ctx *COALESCEContext) {} + +// EnterCURSOR_ROWS is called when production CURSOR_ROWS is entered. +func (s *BaseTSqlParserListener) EnterCURSOR_ROWS(ctx *CURSOR_ROWSContext) {} + +// ExitCURSOR_ROWS is called when production CURSOR_ROWS is exited. +func (s *BaseTSqlParserListener) ExitCURSOR_ROWS(ctx *CURSOR_ROWSContext) {} + +// EnterFETCH_STATUS is called when production FETCH_STATUS is entered. +func (s *BaseTSqlParserListener) EnterFETCH_STATUS(ctx *FETCH_STATUSContext) {} + +// ExitFETCH_STATUS is called when production FETCH_STATUS is exited. +func (s *BaseTSqlParserListener) ExitFETCH_STATUS(ctx *FETCH_STATUSContext) {} + +// EnterCURSOR_STATUS is called when production CURSOR_STATUS is entered. +func (s *BaseTSqlParserListener) EnterCURSOR_STATUS(ctx *CURSOR_STATUSContext) {} + +// ExitCURSOR_STATUS is called when production CURSOR_STATUS is exited. +func (s *BaseTSqlParserListener) ExitCURSOR_STATUS(ctx *CURSOR_STATUSContext) {} + +// EnterCERT_ID is called when production CERT_ID is entered. +func (s *BaseTSqlParserListener) EnterCERT_ID(ctx *CERT_IDContext) {} + +// ExitCERT_ID is called when production CERT_ID is exited. +func (s *BaseTSqlParserListener) ExitCERT_ID(ctx *CERT_IDContext) {} + +// EnterDATALENGTH is called when production DATALENGTH is entered. +func (s *BaseTSqlParserListener) EnterDATALENGTH(ctx *DATALENGTHContext) {} + +// ExitDATALENGTH is called when production DATALENGTH is exited. +func (s *BaseTSqlParserListener) ExitDATALENGTH(ctx *DATALENGTHContext) {} + +// EnterIDENT_CURRENT is called when production IDENT_CURRENT is entered. +func (s *BaseTSqlParserListener) EnterIDENT_CURRENT(ctx *IDENT_CURRENTContext) {} + +// ExitIDENT_CURRENT is called when production IDENT_CURRENT is exited. +func (s *BaseTSqlParserListener) ExitIDENT_CURRENT(ctx *IDENT_CURRENTContext) {} + +// EnterIDENT_INCR is called when production IDENT_INCR is entered. +func (s *BaseTSqlParserListener) EnterIDENT_INCR(ctx *IDENT_INCRContext) {} + +// ExitIDENT_INCR is called when production IDENT_INCR is exited. +func (s *BaseTSqlParserListener) ExitIDENT_INCR(ctx *IDENT_INCRContext) {} + +// EnterIDENT_SEED is called when production IDENT_SEED is entered. +func (s *BaseTSqlParserListener) EnterIDENT_SEED(ctx *IDENT_SEEDContext) {} + +// ExitIDENT_SEED is called when production IDENT_SEED is exited. +func (s *BaseTSqlParserListener) ExitIDENT_SEED(ctx *IDENT_SEEDContext) {} + +// EnterIDENTITY is called when production IDENTITY is entered. +func (s *BaseTSqlParserListener) EnterIDENTITY(ctx *IDENTITYContext) {} + +// ExitIDENTITY is called when production IDENTITY is exited. +func (s *BaseTSqlParserListener) ExitIDENTITY(ctx *IDENTITYContext) {} + +// EnterSQL_VARIANT_PROPERTY is called when production SQL_VARIANT_PROPERTY is entered. +func (s *BaseTSqlParserListener) EnterSQL_VARIANT_PROPERTY(ctx *SQL_VARIANT_PROPERTYContext) {} + +// ExitSQL_VARIANT_PROPERTY is called when production SQL_VARIANT_PROPERTY is exited. +func (s *BaseTSqlParserListener) ExitSQL_VARIANT_PROPERTY(ctx *SQL_VARIANT_PROPERTYContext) {} + +// EnterCURRENT_DATE is called when production CURRENT_DATE is entered. +func (s *BaseTSqlParserListener) EnterCURRENT_DATE(ctx *CURRENT_DATEContext) {} + +// ExitCURRENT_DATE is called when production CURRENT_DATE is exited. +func (s *BaseTSqlParserListener) ExitCURRENT_DATE(ctx *CURRENT_DATEContext) {} + +// EnterCURRENT_TIMESTAMP is called when production CURRENT_TIMESTAMP is entered. +func (s *BaseTSqlParserListener) EnterCURRENT_TIMESTAMP(ctx *CURRENT_TIMESTAMPContext) {} + +// ExitCURRENT_TIMESTAMP is called when production CURRENT_TIMESTAMP is exited. +func (s *BaseTSqlParserListener) ExitCURRENT_TIMESTAMP(ctx *CURRENT_TIMESTAMPContext) {} + +// EnterCURRENT_TIMEZONE is called when production CURRENT_TIMEZONE is entered. +func (s *BaseTSqlParserListener) EnterCURRENT_TIMEZONE(ctx *CURRENT_TIMEZONEContext) {} + +// ExitCURRENT_TIMEZONE is called when production CURRENT_TIMEZONE is exited. +func (s *BaseTSqlParserListener) ExitCURRENT_TIMEZONE(ctx *CURRENT_TIMEZONEContext) {} + +// EnterCURRENT_TIMEZONE_ID is called when production CURRENT_TIMEZONE_ID is entered. +func (s *BaseTSqlParserListener) EnterCURRENT_TIMEZONE_ID(ctx *CURRENT_TIMEZONE_IDContext) {} + +// ExitCURRENT_TIMEZONE_ID is called when production CURRENT_TIMEZONE_ID is exited. +func (s *BaseTSqlParserListener) ExitCURRENT_TIMEZONE_ID(ctx *CURRENT_TIMEZONE_IDContext) {} + +// EnterDATE_BUCKET is called when production DATE_BUCKET is entered. +func (s *BaseTSqlParserListener) EnterDATE_BUCKET(ctx *DATE_BUCKETContext) {} + +// ExitDATE_BUCKET is called when production DATE_BUCKET is exited. +func (s *BaseTSqlParserListener) ExitDATE_BUCKET(ctx *DATE_BUCKETContext) {} + +// EnterDATEADD is called when production DATEADD is entered. +func (s *BaseTSqlParserListener) EnterDATEADD(ctx *DATEADDContext) {} + +// ExitDATEADD is called when production DATEADD is exited. +func (s *BaseTSqlParserListener) ExitDATEADD(ctx *DATEADDContext) {} + +// EnterDATEDIFF is called when production DATEDIFF is entered. +func (s *BaseTSqlParserListener) EnterDATEDIFF(ctx *DATEDIFFContext) {} + +// ExitDATEDIFF is called when production DATEDIFF is exited. +func (s *BaseTSqlParserListener) ExitDATEDIFF(ctx *DATEDIFFContext) {} + +// EnterDATEDIFF_BIG is called when production DATEDIFF_BIG is entered. +func (s *BaseTSqlParserListener) EnterDATEDIFF_BIG(ctx *DATEDIFF_BIGContext) {} + +// ExitDATEDIFF_BIG is called when production DATEDIFF_BIG is exited. +func (s *BaseTSqlParserListener) ExitDATEDIFF_BIG(ctx *DATEDIFF_BIGContext) {} + +// EnterDATEFROMPARTS is called when production DATEFROMPARTS is entered. +func (s *BaseTSqlParserListener) EnterDATEFROMPARTS(ctx *DATEFROMPARTSContext) {} + +// ExitDATEFROMPARTS is called when production DATEFROMPARTS is exited. +func (s *BaseTSqlParserListener) ExitDATEFROMPARTS(ctx *DATEFROMPARTSContext) {} + +// EnterDATENAME is called when production DATENAME is entered. +func (s *BaseTSqlParserListener) EnterDATENAME(ctx *DATENAMEContext) {} + +// ExitDATENAME is called when production DATENAME is exited. +func (s *BaseTSqlParserListener) ExitDATENAME(ctx *DATENAMEContext) {} + +// EnterDATEPART is called when production DATEPART is entered. +func (s *BaseTSqlParserListener) EnterDATEPART(ctx *DATEPARTContext) {} + +// ExitDATEPART is called when production DATEPART is exited. +func (s *BaseTSqlParserListener) ExitDATEPART(ctx *DATEPARTContext) {} + +// EnterDATETIME2FROMPARTS is called when production DATETIME2FROMPARTS is entered. +func (s *BaseTSqlParserListener) EnterDATETIME2FROMPARTS(ctx *DATETIME2FROMPARTSContext) {} + +// ExitDATETIME2FROMPARTS is called when production DATETIME2FROMPARTS is exited. +func (s *BaseTSqlParserListener) ExitDATETIME2FROMPARTS(ctx *DATETIME2FROMPARTSContext) {} + +// EnterDATETIMEFROMPARTS is called when production DATETIMEFROMPARTS is entered. +func (s *BaseTSqlParserListener) EnterDATETIMEFROMPARTS(ctx *DATETIMEFROMPARTSContext) {} + +// ExitDATETIMEFROMPARTS is called when production DATETIMEFROMPARTS is exited. +func (s *BaseTSqlParserListener) ExitDATETIMEFROMPARTS(ctx *DATETIMEFROMPARTSContext) {} + +// EnterDATETIMEOFFSETFROMPARTS is called when production DATETIMEOFFSETFROMPARTS is entered. +func (s *BaseTSqlParserListener) EnterDATETIMEOFFSETFROMPARTS(ctx *DATETIMEOFFSETFROMPARTSContext) {} + +// ExitDATETIMEOFFSETFROMPARTS is called when production DATETIMEOFFSETFROMPARTS is exited. +func (s *BaseTSqlParserListener) ExitDATETIMEOFFSETFROMPARTS(ctx *DATETIMEOFFSETFROMPARTSContext) {} + +// EnterDATETRUNC is called when production DATETRUNC is entered. +func (s *BaseTSqlParserListener) EnterDATETRUNC(ctx *DATETRUNCContext) {} + +// ExitDATETRUNC is called when production DATETRUNC is exited. +func (s *BaseTSqlParserListener) ExitDATETRUNC(ctx *DATETRUNCContext) {} + +// EnterDAY is called when production DAY is entered. +func (s *BaseTSqlParserListener) EnterDAY(ctx *DAYContext) {} + +// ExitDAY is called when production DAY is exited. +func (s *BaseTSqlParserListener) ExitDAY(ctx *DAYContext) {} + +// EnterEOMONTH is called when production EOMONTH is entered. +func (s *BaseTSqlParserListener) EnterEOMONTH(ctx *EOMONTHContext) {} + +// ExitEOMONTH is called when production EOMONTH is exited. +func (s *BaseTSqlParserListener) ExitEOMONTH(ctx *EOMONTHContext) {} + +// EnterGETDATE is called when production GETDATE is entered. +func (s *BaseTSqlParserListener) EnterGETDATE(ctx *GETDATEContext) {} + +// ExitGETDATE is called when production GETDATE is exited. +func (s *BaseTSqlParserListener) ExitGETDATE(ctx *GETDATEContext) {} + +// EnterGETUTCDATE is called when production GETUTCDATE is entered. +func (s *BaseTSqlParserListener) EnterGETUTCDATE(ctx *GETUTCDATEContext) {} + +// ExitGETUTCDATE is called when production GETUTCDATE is exited. +func (s *BaseTSqlParserListener) ExitGETUTCDATE(ctx *GETUTCDATEContext) {} + +// EnterISDATE is called when production ISDATE is entered. +func (s *BaseTSqlParserListener) EnterISDATE(ctx *ISDATEContext) {} + +// ExitISDATE is called when production ISDATE is exited. +func (s *BaseTSqlParserListener) ExitISDATE(ctx *ISDATEContext) {} + +// EnterMONTH is called when production MONTH is entered. +func (s *BaseTSqlParserListener) EnterMONTH(ctx *MONTHContext) {} + +// ExitMONTH is called when production MONTH is exited. +func (s *BaseTSqlParserListener) ExitMONTH(ctx *MONTHContext) {} + +// EnterSMALLDATETIMEFROMPARTS is called when production SMALLDATETIMEFROMPARTS is entered. +func (s *BaseTSqlParserListener) EnterSMALLDATETIMEFROMPARTS(ctx *SMALLDATETIMEFROMPARTSContext) {} + +// ExitSMALLDATETIMEFROMPARTS is called when production SMALLDATETIMEFROMPARTS is exited. +func (s *BaseTSqlParserListener) ExitSMALLDATETIMEFROMPARTS(ctx *SMALLDATETIMEFROMPARTSContext) {} + +// EnterSWITCHOFFSET is called when production SWITCHOFFSET is entered. +func (s *BaseTSqlParserListener) EnterSWITCHOFFSET(ctx *SWITCHOFFSETContext) {} + +// ExitSWITCHOFFSET is called when production SWITCHOFFSET is exited. +func (s *BaseTSqlParserListener) ExitSWITCHOFFSET(ctx *SWITCHOFFSETContext) {} + +// EnterSYSDATETIME is called when production SYSDATETIME is entered. +func (s *BaseTSqlParserListener) EnterSYSDATETIME(ctx *SYSDATETIMEContext) {} + +// ExitSYSDATETIME is called when production SYSDATETIME is exited. +func (s *BaseTSqlParserListener) ExitSYSDATETIME(ctx *SYSDATETIMEContext) {} + +// EnterSYSDATETIMEOFFSET is called when production SYSDATETIMEOFFSET is entered. +func (s *BaseTSqlParserListener) EnterSYSDATETIMEOFFSET(ctx *SYSDATETIMEOFFSETContext) {} + +// ExitSYSDATETIMEOFFSET is called when production SYSDATETIMEOFFSET is exited. +func (s *BaseTSqlParserListener) ExitSYSDATETIMEOFFSET(ctx *SYSDATETIMEOFFSETContext) {} + +// EnterSYSUTCDATETIME is called when production SYSUTCDATETIME is entered. +func (s *BaseTSqlParserListener) EnterSYSUTCDATETIME(ctx *SYSUTCDATETIMEContext) {} + +// ExitSYSUTCDATETIME is called when production SYSUTCDATETIME is exited. +func (s *BaseTSqlParserListener) ExitSYSUTCDATETIME(ctx *SYSUTCDATETIMEContext) {} + +// EnterTIMEFROMPARTS is called when production TIMEFROMPARTS is entered. +func (s *BaseTSqlParserListener) EnterTIMEFROMPARTS(ctx *TIMEFROMPARTSContext) {} + +// ExitTIMEFROMPARTS is called when production TIMEFROMPARTS is exited. +func (s *BaseTSqlParserListener) ExitTIMEFROMPARTS(ctx *TIMEFROMPARTSContext) {} + +// EnterTODATETIMEOFFSET is called when production TODATETIMEOFFSET is entered. +func (s *BaseTSqlParserListener) EnterTODATETIMEOFFSET(ctx *TODATETIMEOFFSETContext) {} + +// ExitTODATETIMEOFFSET is called when production TODATETIMEOFFSET is exited. +func (s *BaseTSqlParserListener) ExitTODATETIMEOFFSET(ctx *TODATETIMEOFFSETContext) {} + +// EnterYEAR is called when production YEAR is entered. +func (s *BaseTSqlParserListener) EnterYEAR(ctx *YEARContext) {} + +// ExitYEAR is called when production YEAR is exited. +func (s *BaseTSqlParserListener) ExitYEAR(ctx *YEARContext) {} + +// EnterNULLIF is called when production NULLIF is entered. +func (s *BaseTSqlParserListener) EnterNULLIF(ctx *NULLIFContext) {} + +// ExitNULLIF is called when production NULLIF is exited. +func (s *BaseTSqlParserListener) ExitNULLIF(ctx *NULLIFContext) {} + +// EnterPARSE is called when production PARSE is entered. +func (s *BaseTSqlParserListener) EnterPARSE(ctx *PARSEContext) {} + +// ExitPARSE is called when production PARSE is exited. +func (s *BaseTSqlParserListener) ExitPARSE(ctx *PARSEContext) {} + +// EnterXML_DATA_TYPE_FUNC is called when production XML_DATA_TYPE_FUNC is entered. +func (s *BaseTSqlParserListener) EnterXML_DATA_TYPE_FUNC(ctx *XML_DATA_TYPE_FUNCContext) {} + +// ExitXML_DATA_TYPE_FUNC is called when production XML_DATA_TYPE_FUNC is exited. +func (s *BaseTSqlParserListener) ExitXML_DATA_TYPE_FUNC(ctx *XML_DATA_TYPE_FUNCContext) {} + +// EnterIIF is called when production IIF is entered. +func (s *BaseTSqlParserListener) EnterIIF(ctx *IIFContext) {} + +// ExitIIF is called when production IIF is exited. +func (s *BaseTSqlParserListener) ExitIIF(ctx *IIFContext) {} + +// EnterISJSON is called when production ISJSON is entered. +func (s *BaseTSqlParserListener) EnterISJSON(ctx *ISJSONContext) {} + +// ExitISJSON is called when production ISJSON is exited. +func (s *BaseTSqlParserListener) ExitISJSON(ctx *ISJSONContext) {} + +// EnterJSON_OBJECT is called when production JSON_OBJECT is entered. +func (s *BaseTSqlParserListener) EnterJSON_OBJECT(ctx *JSON_OBJECTContext) {} + +// ExitJSON_OBJECT is called when production JSON_OBJECT is exited. +func (s *BaseTSqlParserListener) ExitJSON_OBJECT(ctx *JSON_OBJECTContext) {} + +// EnterJSON_ARRAY is called when production JSON_ARRAY is entered. +func (s *BaseTSqlParserListener) EnterJSON_ARRAY(ctx *JSON_ARRAYContext) {} + +// ExitJSON_ARRAY is called when production JSON_ARRAY is exited. +func (s *BaseTSqlParserListener) ExitJSON_ARRAY(ctx *JSON_ARRAYContext) {} + +// EnterJSON_VALUE is called when production JSON_VALUE is entered. +func (s *BaseTSqlParserListener) EnterJSON_VALUE(ctx *JSON_VALUEContext) {} + +// ExitJSON_VALUE is called when production JSON_VALUE is exited. +func (s *BaseTSqlParserListener) ExitJSON_VALUE(ctx *JSON_VALUEContext) {} + +// EnterJSON_QUERY is called when production JSON_QUERY is entered. +func (s *BaseTSqlParserListener) EnterJSON_QUERY(ctx *JSON_QUERYContext) {} + +// ExitJSON_QUERY is called when production JSON_QUERY is exited. +func (s *BaseTSqlParserListener) ExitJSON_QUERY(ctx *JSON_QUERYContext) {} + +// EnterJSON_MODIFY is called when production JSON_MODIFY is entered. +func (s *BaseTSqlParserListener) EnterJSON_MODIFY(ctx *JSON_MODIFYContext) {} + +// ExitJSON_MODIFY is called when production JSON_MODIFY is exited. +func (s *BaseTSqlParserListener) ExitJSON_MODIFY(ctx *JSON_MODIFYContext) {} + +// EnterJSON_PATH_EXISTS is called when production JSON_PATH_EXISTS is entered. +func (s *BaseTSqlParserListener) EnterJSON_PATH_EXISTS(ctx *JSON_PATH_EXISTSContext) {} + +// ExitJSON_PATH_EXISTS is called when production JSON_PATH_EXISTS is exited. +func (s *BaseTSqlParserListener) ExitJSON_PATH_EXISTS(ctx *JSON_PATH_EXISTSContext) {} + +// EnterABS is called when production ABS is entered. +func (s *BaseTSqlParserListener) EnterABS(ctx *ABSContext) {} + +// ExitABS is called when production ABS is exited. +func (s *BaseTSqlParserListener) ExitABS(ctx *ABSContext) {} + +// EnterACOS is called when production ACOS is entered. +func (s *BaseTSqlParserListener) EnterACOS(ctx *ACOSContext) {} + +// ExitACOS is called when production ACOS is exited. +func (s *BaseTSqlParserListener) ExitACOS(ctx *ACOSContext) {} + +// EnterASIN is called when production ASIN is entered. +func (s *BaseTSqlParserListener) EnterASIN(ctx *ASINContext) {} + +// ExitASIN is called when production ASIN is exited. +func (s *BaseTSqlParserListener) ExitASIN(ctx *ASINContext) {} + +// EnterATAN is called when production ATAN is entered. +func (s *BaseTSqlParserListener) EnterATAN(ctx *ATANContext) {} + +// ExitATAN is called when production ATAN is exited. +func (s *BaseTSqlParserListener) ExitATAN(ctx *ATANContext) {} + +// EnterATN2 is called when production ATN2 is entered. +func (s *BaseTSqlParserListener) EnterATN2(ctx *ATN2Context) {} + +// ExitATN2 is called when production ATN2 is exited. +func (s *BaseTSqlParserListener) ExitATN2(ctx *ATN2Context) {} + +// EnterCEILING is called when production CEILING is entered. +func (s *BaseTSqlParserListener) EnterCEILING(ctx *CEILINGContext) {} + +// ExitCEILING is called when production CEILING is exited. +func (s *BaseTSqlParserListener) ExitCEILING(ctx *CEILINGContext) {} + +// EnterCOS is called when production COS is entered. +func (s *BaseTSqlParserListener) EnterCOS(ctx *COSContext) {} + +// ExitCOS is called when production COS is exited. +func (s *BaseTSqlParserListener) ExitCOS(ctx *COSContext) {} + +// EnterCOT is called when production COT is entered. +func (s *BaseTSqlParserListener) EnterCOT(ctx *COTContext) {} + +// ExitCOT is called when production COT is exited. +func (s *BaseTSqlParserListener) ExitCOT(ctx *COTContext) {} + +// EnterDEGREES is called when production DEGREES is entered. +func (s *BaseTSqlParserListener) EnterDEGREES(ctx *DEGREESContext) {} + +// ExitDEGREES is called when production DEGREES is exited. +func (s *BaseTSqlParserListener) ExitDEGREES(ctx *DEGREESContext) {} + +// EnterEXP is called when production EXP is entered. +func (s *BaseTSqlParserListener) EnterEXP(ctx *EXPContext) {} + +// ExitEXP is called when production EXP is exited. +func (s *BaseTSqlParserListener) ExitEXP(ctx *EXPContext) {} + +// EnterFLOOR is called when production FLOOR is entered. +func (s *BaseTSqlParserListener) EnterFLOOR(ctx *FLOORContext) {} + +// ExitFLOOR is called when production FLOOR is exited. +func (s *BaseTSqlParserListener) ExitFLOOR(ctx *FLOORContext) {} + +// EnterLOG is called when production LOG is entered. +func (s *BaseTSqlParserListener) EnterLOG(ctx *LOGContext) {} + +// ExitLOG is called when production LOG is exited. +func (s *BaseTSqlParserListener) ExitLOG(ctx *LOGContext) {} + +// EnterLOG10 is called when production LOG10 is entered. +func (s *BaseTSqlParserListener) EnterLOG10(ctx *LOG10Context) {} + +// ExitLOG10 is called when production LOG10 is exited. +func (s *BaseTSqlParserListener) ExitLOG10(ctx *LOG10Context) {} + +// EnterPI is called when production PI is entered. +func (s *BaseTSqlParserListener) EnterPI(ctx *PIContext) {} + +// ExitPI is called when production PI is exited. +func (s *BaseTSqlParserListener) ExitPI(ctx *PIContext) {} + +// EnterPOWER is called when production POWER is entered. +func (s *BaseTSqlParserListener) EnterPOWER(ctx *POWERContext) {} + +// ExitPOWER is called when production POWER is exited. +func (s *BaseTSqlParserListener) ExitPOWER(ctx *POWERContext) {} + +// EnterRADIANS is called when production RADIANS is entered. +func (s *BaseTSqlParserListener) EnterRADIANS(ctx *RADIANSContext) {} + +// ExitRADIANS is called when production RADIANS is exited. +func (s *BaseTSqlParserListener) ExitRADIANS(ctx *RADIANSContext) {} + +// EnterRAND is called when production RAND is entered. +func (s *BaseTSqlParserListener) EnterRAND(ctx *RANDContext) {} + +// ExitRAND is called when production RAND is exited. +func (s *BaseTSqlParserListener) ExitRAND(ctx *RANDContext) {} + +// EnterROUND is called when production ROUND is entered. +func (s *BaseTSqlParserListener) EnterROUND(ctx *ROUNDContext) {} + +// ExitROUND is called when production ROUND is exited. +func (s *BaseTSqlParserListener) ExitROUND(ctx *ROUNDContext) {} + +// EnterMATH_SIGN is called when production MATH_SIGN is entered. +func (s *BaseTSqlParserListener) EnterMATH_SIGN(ctx *MATH_SIGNContext) {} + +// ExitMATH_SIGN is called when production MATH_SIGN is exited. +func (s *BaseTSqlParserListener) ExitMATH_SIGN(ctx *MATH_SIGNContext) {} + +// EnterSIN is called when production SIN is entered. +func (s *BaseTSqlParserListener) EnterSIN(ctx *SINContext) {} + +// ExitSIN is called when production SIN is exited. +func (s *BaseTSqlParserListener) ExitSIN(ctx *SINContext) {} + +// EnterSQRT is called when production SQRT is entered. +func (s *BaseTSqlParserListener) EnterSQRT(ctx *SQRTContext) {} + +// ExitSQRT is called when production SQRT is exited. +func (s *BaseTSqlParserListener) ExitSQRT(ctx *SQRTContext) {} + +// EnterSQUARE is called when production SQUARE is entered. +func (s *BaseTSqlParserListener) EnterSQUARE(ctx *SQUAREContext) {} + +// ExitSQUARE is called when production SQUARE is exited. +func (s *BaseTSqlParserListener) ExitSQUARE(ctx *SQUAREContext) {} + +// EnterTAN is called when production TAN is entered. +func (s *BaseTSqlParserListener) EnterTAN(ctx *TANContext) {} + +// ExitTAN is called when production TAN is exited. +func (s *BaseTSqlParserListener) ExitTAN(ctx *TANContext) {} + +// EnterGREATEST is called when production GREATEST is entered. +func (s *BaseTSqlParserListener) EnterGREATEST(ctx *GREATESTContext) {} + +// ExitGREATEST is called when production GREATEST is exited. +func (s *BaseTSqlParserListener) ExitGREATEST(ctx *GREATESTContext) {} + +// EnterLEAST is called when production LEAST is entered. +func (s *BaseTSqlParserListener) EnterLEAST(ctx *LEASTContext) {} + +// ExitLEAST is called when production LEAST is exited. +func (s *BaseTSqlParserListener) ExitLEAST(ctx *LEASTContext) {} + +// EnterCERTENCODED is called when production CERTENCODED is entered. +func (s *BaseTSqlParserListener) EnterCERTENCODED(ctx *CERTENCODEDContext) {} + +// ExitCERTENCODED is called when production CERTENCODED is exited. +func (s *BaseTSqlParserListener) ExitCERTENCODED(ctx *CERTENCODEDContext) {} + +// EnterCERTPRIVATEKEY is called when production CERTPRIVATEKEY is entered. +func (s *BaseTSqlParserListener) EnterCERTPRIVATEKEY(ctx *CERTPRIVATEKEYContext) {} + +// ExitCERTPRIVATEKEY is called when production CERTPRIVATEKEY is exited. +func (s *BaseTSqlParserListener) ExitCERTPRIVATEKEY(ctx *CERTPRIVATEKEYContext) {} + +// EnterCURRENT_USER is called when production CURRENT_USER is entered. +func (s *BaseTSqlParserListener) EnterCURRENT_USER(ctx *CURRENT_USERContext) {} + +// ExitCURRENT_USER is called when production CURRENT_USER is exited. +func (s *BaseTSqlParserListener) ExitCURRENT_USER(ctx *CURRENT_USERContext) {} + +// EnterDATABASE_PRINCIPAL_ID is called when production DATABASE_PRINCIPAL_ID is entered. +func (s *BaseTSqlParserListener) EnterDATABASE_PRINCIPAL_ID(ctx *DATABASE_PRINCIPAL_IDContext) {} + +// ExitDATABASE_PRINCIPAL_ID is called when production DATABASE_PRINCIPAL_ID is exited. +func (s *BaseTSqlParserListener) ExitDATABASE_PRINCIPAL_ID(ctx *DATABASE_PRINCIPAL_IDContext) {} + +// EnterHAS_DBACCESS is called when production HAS_DBACCESS is entered. +func (s *BaseTSqlParserListener) EnterHAS_DBACCESS(ctx *HAS_DBACCESSContext) {} + +// ExitHAS_DBACCESS is called when production HAS_DBACCESS is exited. +func (s *BaseTSqlParserListener) ExitHAS_DBACCESS(ctx *HAS_DBACCESSContext) {} + +// EnterHAS_PERMS_BY_NAME is called when production HAS_PERMS_BY_NAME is entered. +func (s *BaseTSqlParserListener) EnterHAS_PERMS_BY_NAME(ctx *HAS_PERMS_BY_NAMEContext) {} + +// ExitHAS_PERMS_BY_NAME is called when production HAS_PERMS_BY_NAME is exited. +func (s *BaseTSqlParserListener) ExitHAS_PERMS_BY_NAME(ctx *HAS_PERMS_BY_NAMEContext) {} + +// EnterIS_MEMBER is called when production IS_MEMBER is entered. +func (s *BaseTSqlParserListener) EnterIS_MEMBER(ctx *IS_MEMBERContext) {} + +// ExitIS_MEMBER is called when production IS_MEMBER is exited. +func (s *BaseTSqlParserListener) ExitIS_MEMBER(ctx *IS_MEMBERContext) {} + +// EnterIS_ROLEMEMBER is called when production IS_ROLEMEMBER is entered. +func (s *BaseTSqlParserListener) EnterIS_ROLEMEMBER(ctx *IS_ROLEMEMBERContext) {} + +// ExitIS_ROLEMEMBER is called when production IS_ROLEMEMBER is exited. +func (s *BaseTSqlParserListener) ExitIS_ROLEMEMBER(ctx *IS_ROLEMEMBERContext) {} + +// EnterIS_SRVROLEMEMBER is called when production IS_SRVROLEMEMBER is entered. +func (s *BaseTSqlParserListener) EnterIS_SRVROLEMEMBER(ctx *IS_SRVROLEMEMBERContext) {} + +// ExitIS_SRVROLEMEMBER is called when production IS_SRVROLEMEMBER is exited. +func (s *BaseTSqlParserListener) ExitIS_SRVROLEMEMBER(ctx *IS_SRVROLEMEMBERContext) {} + +// EnterLOGINPROPERTY is called when production LOGINPROPERTY is entered. +func (s *BaseTSqlParserListener) EnterLOGINPROPERTY(ctx *LOGINPROPERTYContext) {} + +// ExitLOGINPROPERTY is called when production LOGINPROPERTY is exited. +func (s *BaseTSqlParserListener) ExitLOGINPROPERTY(ctx *LOGINPROPERTYContext) {} + +// EnterORIGINAL_LOGIN is called when production ORIGINAL_LOGIN is entered. +func (s *BaseTSqlParserListener) EnterORIGINAL_LOGIN(ctx *ORIGINAL_LOGINContext) {} + +// ExitORIGINAL_LOGIN is called when production ORIGINAL_LOGIN is exited. +func (s *BaseTSqlParserListener) ExitORIGINAL_LOGIN(ctx *ORIGINAL_LOGINContext) {} + +// EnterPERMISSIONS is called when production PERMISSIONS is entered. +func (s *BaseTSqlParserListener) EnterPERMISSIONS(ctx *PERMISSIONSContext) {} + +// ExitPERMISSIONS is called when production PERMISSIONS is exited. +func (s *BaseTSqlParserListener) ExitPERMISSIONS(ctx *PERMISSIONSContext) {} + +// EnterPWDENCRYPT is called when production PWDENCRYPT is entered. +func (s *BaseTSqlParserListener) EnterPWDENCRYPT(ctx *PWDENCRYPTContext) {} + +// ExitPWDENCRYPT is called when production PWDENCRYPT is exited. +func (s *BaseTSqlParserListener) ExitPWDENCRYPT(ctx *PWDENCRYPTContext) {} + +// EnterPWDCOMPARE is called when production PWDCOMPARE is entered. +func (s *BaseTSqlParserListener) EnterPWDCOMPARE(ctx *PWDCOMPAREContext) {} + +// ExitPWDCOMPARE is called when production PWDCOMPARE is exited. +func (s *BaseTSqlParserListener) ExitPWDCOMPARE(ctx *PWDCOMPAREContext) {} + +// EnterSESSION_USER is called when production SESSION_USER is entered. +func (s *BaseTSqlParserListener) EnterSESSION_USER(ctx *SESSION_USERContext) {} + +// ExitSESSION_USER is called when production SESSION_USER is exited. +func (s *BaseTSqlParserListener) ExitSESSION_USER(ctx *SESSION_USERContext) {} + +// EnterSESSIONPROPERTY is called when production SESSIONPROPERTY is entered. +func (s *BaseTSqlParserListener) EnterSESSIONPROPERTY(ctx *SESSIONPROPERTYContext) {} + +// ExitSESSIONPROPERTY is called when production SESSIONPROPERTY is exited. +func (s *BaseTSqlParserListener) ExitSESSIONPROPERTY(ctx *SESSIONPROPERTYContext) {} + +// EnterSUSER_ID is called when production SUSER_ID is entered. +func (s *BaseTSqlParserListener) EnterSUSER_ID(ctx *SUSER_IDContext) {} + +// ExitSUSER_ID is called when production SUSER_ID is exited. +func (s *BaseTSqlParserListener) ExitSUSER_ID(ctx *SUSER_IDContext) {} + +// EnterSUSER_SNAME is called when production SUSER_SNAME is entered. +func (s *BaseTSqlParserListener) EnterSUSER_SNAME(ctx *SUSER_SNAMEContext) {} + +// ExitSUSER_SNAME is called when production SUSER_SNAME is exited. +func (s *BaseTSqlParserListener) ExitSUSER_SNAME(ctx *SUSER_SNAMEContext) {} + +// EnterSUSER_SID is called when production SUSER_SID is entered. +func (s *BaseTSqlParserListener) EnterSUSER_SID(ctx *SUSER_SIDContext) {} + +// ExitSUSER_SID is called when production SUSER_SID is exited. +func (s *BaseTSqlParserListener) ExitSUSER_SID(ctx *SUSER_SIDContext) {} + +// EnterSYSTEM_USER is called when production SYSTEM_USER is entered. +func (s *BaseTSqlParserListener) EnterSYSTEM_USER(ctx *SYSTEM_USERContext) {} + +// ExitSYSTEM_USER is called when production SYSTEM_USER is exited. +func (s *BaseTSqlParserListener) ExitSYSTEM_USER(ctx *SYSTEM_USERContext) {} + +// EnterUSER is called when production USER is entered. +func (s *BaseTSqlParserListener) EnterUSER(ctx *USERContext) {} + +// ExitUSER is called when production USER is exited. +func (s *BaseTSqlParserListener) ExitUSER(ctx *USERContext) {} + +// EnterUSER_ID is called when production USER_ID is entered. +func (s *BaseTSqlParserListener) EnterUSER_ID(ctx *USER_IDContext) {} + +// ExitUSER_ID is called when production USER_ID is exited. +func (s *BaseTSqlParserListener) ExitUSER_ID(ctx *USER_IDContext) {} + +// EnterUSER_NAME is called when production USER_NAME is entered. +func (s *BaseTSqlParserListener) EnterUSER_NAME(ctx *USER_NAMEContext) {} + +// ExitUSER_NAME is called when production USER_NAME is exited. +func (s *BaseTSqlParserListener) ExitUSER_NAME(ctx *USER_NAMEContext) {} + +// EnterXml_data_type_methods is called when production xml_data_type_methods is entered. +func (s *BaseTSqlParserListener) EnterXml_data_type_methods(ctx *Xml_data_type_methodsContext) {} + +// ExitXml_data_type_methods is called when production xml_data_type_methods is exited. +func (s *BaseTSqlParserListener) ExitXml_data_type_methods(ctx *Xml_data_type_methodsContext) {} + +// EnterDateparts_9 is called when production dateparts_9 is entered. +func (s *BaseTSqlParserListener) EnterDateparts_9(ctx *Dateparts_9Context) {} + +// ExitDateparts_9 is called when production dateparts_9 is exited. +func (s *BaseTSqlParserListener) ExitDateparts_9(ctx *Dateparts_9Context) {} + +// EnterDateparts_12 is called when production dateparts_12 is entered. +func (s *BaseTSqlParserListener) EnterDateparts_12(ctx *Dateparts_12Context) {} + +// ExitDateparts_12 is called when production dateparts_12 is exited. +func (s *BaseTSqlParserListener) ExitDateparts_12(ctx *Dateparts_12Context) {} + +// EnterDateparts_15 is called when production dateparts_15 is entered. +func (s *BaseTSqlParserListener) EnterDateparts_15(ctx *Dateparts_15Context) {} + +// ExitDateparts_15 is called when production dateparts_15 is exited. +func (s *BaseTSqlParserListener) ExitDateparts_15(ctx *Dateparts_15Context) {} + +// EnterDateparts_datetrunc is called when production dateparts_datetrunc is entered. +func (s *BaseTSqlParserListener) EnterDateparts_datetrunc(ctx *Dateparts_datetruncContext) {} + +// ExitDateparts_datetrunc is called when production dateparts_datetrunc is exited. +func (s *BaseTSqlParserListener) ExitDateparts_datetrunc(ctx *Dateparts_datetruncContext) {} + +// EnterValue_method is called when production value_method is entered. +func (s *BaseTSqlParserListener) EnterValue_method(ctx *Value_methodContext) {} + +// ExitValue_method is called when production value_method is exited. +func (s *BaseTSqlParserListener) ExitValue_method(ctx *Value_methodContext) {} + +// EnterValue_call is called when production value_call is entered. +func (s *BaseTSqlParserListener) EnterValue_call(ctx *Value_callContext) {} + +// ExitValue_call is called when production value_call is exited. +func (s *BaseTSqlParserListener) ExitValue_call(ctx *Value_callContext) {} + +// EnterQuery_method is called when production query_method is entered. +func (s *BaseTSqlParserListener) EnterQuery_method(ctx *Query_methodContext) {} + +// ExitQuery_method is called when production query_method is exited. +func (s *BaseTSqlParserListener) ExitQuery_method(ctx *Query_methodContext) {} + +// EnterQuery_call is called when production query_call is entered. +func (s *BaseTSqlParserListener) EnterQuery_call(ctx *Query_callContext) {} + +// ExitQuery_call is called when production query_call is exited. +func (s *BaseTSqlParserListener) ExitQuery_call(ctx *Query_callContext) {} + +// EnterExist_method is called when production exist_method is entered. +func (s *BaseTSqlParserListener) EnterExist_method(ctx *Exist_methodContext) {} + +// ExitExist_method is called when production exist_method is exited. +func (s *BaseTSqlParserListener) ExitExist_method(ctx *Exist_methodContext) {} + +// EnterExist_call is called when production exist_call is entered. +func (s *BaseTSqlParserListener) EnterExist_call(ctx *Exist_callContext) {} + +// ExitExist_call is called when production exist_call is exited. +func (s *BaseTSqlParserListener) ExitExist_call(ctx *Exist_callContext) {} + +// EnterModify_method is called when production modify_method is entered. +func (s *BaseTSqlParserListener) EnterModify_method(ctx *Modify_methodContext) {} + +// ExitModify_method is called when production modify_method is exited. +func (s *BaseTSqlParserListener) ExitModify_method(ctx *Modify_methodContext) {} + +// EnterModify_call is called when production modify_call is entered. +func (s *BaseTSqlParserListener) EnterModify_call(ctx *Modify_callContext) {} + +// ExitModify_call is called when production modify_call is exited. +func (s *BaseTSqlParserListener) ExitModify_call(ctx *Modify_callContext) {} + +// EnterHierarchyid_call is called when production hierarchyid_call is entered. +func (s *BaseTSqlParserListener) EnterHierarchyid_call(ctx *Hierarchyid_callContext) {} + +// ExitHierarchyid_call is called when production hierarchyid_call is exited. +func (s *BaseTSqlParserListener) ExitHierarchyid_call(ctx *Hierarchyid_callContext) {} + +// EnterHierarchyid_static_method is called when production hierarchyid_static_method is entered. +func (s *BaseTSqlParserListener) EnterHierarchyid_static_method(ctx *Hierarchyid_static_methodContext) { +} + +// ExitHierarchyid_static_method is called when production hierarchyid_static_method is exited. +func (s *BaseTSqlParserListener) ExitHierarchyid_static_method(ctx *Hierarchyid_static_methodContext) { +} + +// EnterNodes_method is called when production nodes_method is entered. +func (s *BaseTSqlParserListener) EnterNodes_method(ctx *Nodes_methodContext) {} + +// ExitNodes_method is called when production nodes_method is exited. +func (s *BaseTSqlParserListener) ExitNodes_method(ctx *Nodes_methodContext) {} + +// EnterSwitch_section is called when production switch_section is entered. +func (s *BaseTSqlParserListener) EnterSwitch_section(ctx *Switch_sectionContext) {} + +// ExitSwitch_section is called when production switch_section is exited. +func (s *BaseTSqlParserListener) ExitSwitch_section(ctx *Switch_sectionContext) {} + +// EnterSwitch_search_condition_section is called when production switch_search_condition_section is entered. +func (s *BaseTSqlParserListener) EnterSwitch_search_condition_section(ctx *Switch_search_condition_sectionContext) { +} + +// ExitSwitch_search_condition_section is called when production switch_search_condition_section is exited. +func (s *BaseTSqlParserListener) ExitSwitch_search_condition_section(ctx *Switch_search_condition_sectionContext) { +} + +// EnterAs_column_alias is called when production as_column_alias is entered. +func (s *BaseTSqlParserListener) EnterAs_column_alias(ctx *As_column_aliasContext) {} + +// ExitAs_column_alias is called when production as_column_alias is exited. +func (s *BaseTSqlParserListener) ExitAs_column_alias(ctx *As_column_aliasContext) {} + +// EnterAs_table_alias is called when production as_table_alias is entered. +func (s *BaseTSqlParserListener) EnterAs_table_alias(ctx *As_table_aliasContext) {} + +// ExitAs_table_alias is called when production as_table_alias is exited. +func (s *BaseTSqlParserListener) ExitAs_table_alias(ctx *As_table_aliasContext) {} + +// EnterTable_alias is called when production table_alias is entered. +func (s *BaseTSqlParserListener) EnterTable_alias(ctx *Table_aliasContext) {} + +// ExitTable_alias is called when production table_alias is exited. +func (s *BaseTSqlParserListener) ExitTable_alias(ctx *Table_aliasContext) {} + +// EnterWith_table_hints is called when production with_table_hints is entered. +func (s *BaseTSqlParserListener) EnterWith_table_hints(ctx *With_table_hintsContext) {} + +// ExitWith_table_hints is called when production with_table_hints is exited. +func (s *BaseTSqlParserListener) ExitWith_table_hints(ctx *With_table_hintsContext) {} + +// EnterDeprecated_table_hint is called when production deprecated_table_hint is entered. +func (s *BaseTSqlParserListener) EnterDeprecated_table_hint(ctx *Deprecated_table_hintContext) {} + +// ExitDeprecated_table_hint is called when production deprecated_table_hint is exited. +func (s *BaseTSqlParserListener) ExitDeprecated_table_hint(ctx *Deprecated_table_hintContext) {} + +// EnterSybase_legacy_hints is called when production sybase_legacy_hints is entered. +func (s *BaseTSqlParserListener) EnterSybase_legacy_hints(ctx *Sybase_legacy_hintsContext) {} + +// ExitSybase_legacy_hints is called when production sybase_legacy_hints is exited. +func (s *BaseTSqlParserListener) ExitSybase_legacy_hints(ctx *Sybase_legacy_hintsContext) {} + +// EnterSybase_legacy_hint is called when production sybase_legacy_hint is entered. +func (s *BaseTSqlParserListener) EnterSybase_legacy_hint(ctx *Sybase_legacy_hintContext) {} + +// ExitSybase_legacy_hint is called when production sybase_legacy_hint is exited. +func (s *BaseTSqlParserListener) ExitSybase_legacy_hint(ctx *Sybase_legacy_hintContext) {} + +// EnterTable_hint is called when production table_hint is entered. +func (s *BaseTSqlParserListener) EnterTable_hint(ctx *Table_hintContext) {} + +// ExitTable_hint is called when production table_hint is exited. +func (s *BaseTSqlParserListener) ExitTable_hint(ctx *Table_hintContext) {} + +// EnterIndex_value is called when production index_value is entered. +func (s *BaseTSqlParserListener) EnterIndex_value(ctx *Index_valueContext) {} + +// ExitIndex_value is called when production index_value is exited. +func (s *BaseTSqlParserListener) ExitIndex_value(ctx *Index_valueContext) {} + +// EnterColumn_alias_list is called when production column_alias_list is entered. +func (s *BaseTSqlParserListener) EnterColumn_alias_list(ctx *Column_alias_listContext) {} + +// ExitColumn_alias_list is called when production column_alias_list is exited. +func (s *BaseTSqlParserListener) ExitColumn_alias_list(ctx *Column_alias_listContext) {} + +// EnterColumn_alias is called when production column_alias is entered. +func (s *BaseTSqlParserListener) EnterColumn_alias(ctx *Column_aliasContext) {} + +// ExitColumn_alias is called when production column_alias is exited. +func (s *BaseTSqlParserListener) ExitColumn_alias(ctx *Column_aliasContext) {} + +// EnterTable_value_constructor is called when production table_value_constructor is entered. +func (s *BaseTSqlParserListener) EnterTable_value_constructor(ctx *Table_value_constructorContext) {} + +// ExitTable_value_constructor is called when production table_value_constructor is exited. +func (s *BaseTSqlParserListener) ExitTable_value_constructor(ctx *Table_value_constructorContext) {} + +// EnterExpression_list_ is called when production expression_list_ is entered. +func (s *BaseTSqlParserListener) EnterExpression_list_(ctx *Expression_list_Context) {} + +// ExitExpression_list_ is called when production expression_list_ is exited. +func (s *BaseTSqlParserListener) ExitExpression_list_(ctx *Expression_list_Context) {} + +// EnterRanking_windowed_function is called when production ranking_windowed_function is entered. +func (s *BaseTSqlParserListener) EnterRanking_windowed_function(ctx *Ranking_windowed_functionContext) { +} + +// ExitRanking_windowed_function is called when production ranking_windowed_function is exited. +func (s *BaseTSqlParserListener) ExitRanking_windowed_function(ctx *Ranking_windowed_functionContext) { +} + +// EnterAggregate_windowed_function is called when production aggregate_windowed_function is entered. +func (s *BaseTSqlParserListener) EnterAggregate_windowed_function(ctx *Aggregate_windowed_functionContext) { +} + +// ExitAggregate_windowed_function is called when production aggregate_windowed_function is exited. +func (s *BaseTSqlParserListener) ExitAggregate_windowed_function(ctx *Aggregate_windowed_functionContext) { +} + +// EnterAnalytic_windowed_function is called when production analytic_windowed_function is entered. +func (s *BaseTSqlParserListener) EnterAnalytic_windowed_function(ctx *Analytic_windowed_functionContext) { +} + +// ExitAnalytic_windowed_function is called when production analytic_windowed_function is exited. +func (s *BaseTSqlParserListener) ExitAnalytic_windowed_function(ctx *Analytic_windowed_functionContext) { +} + +// EnterAll_distinct_expression is called when production all_distinct_expression is entered. +func (s *BaseTSqlParserListener) EnterAll_distinct_expression(ctx *All_distinct_expressionContext) {} + +// ExitAll_distinct_expression is called when production all_distinct_expression is exited. +func (s *BaseTSqlParserListener) ExitAll_distinct_expression(ctx *All_distinct_expressionContext) {} + +// EnterOver_clause is called when production over_clause is entered. +func (s *BaseTSqlParserListener) EnterOver_clause(ctx *Over_clauseContext) {} + +// ExitOver_clause is called when production over_clause is exited. +func (s *BaseTSqlParserListener) ExitOver_clause(ctx *Over_clauseContext) {} + +// EnterRow_or_range_clause is called when production row_or_range_clause is entered. +func (s *BaseTSqlParserListener) EnterRow_or_range_clause(ctx *Row_or_range_clauseContext) {} + +// ExitRow_or_range_clause is called when production row_or_range_clause is exited. +func (s *BaseTSqlParserListener) ExitRow_or_range_clause(ctx *Row_or_range_clauseContext) {} + +// EnterWindow_frame_extent is called when production window_frame_extent is entered. +func (s *BaseTSqlParserListener) EnterWindow_frame_extent(ctx *Window_frame_extentContext) {} + +// ExitWindow_frame_extent is called when production window_frame_extent is exited. +func (s *BaseTSqlParserListener) ExitWindow_frame_extent(ctx *Window_frame_extentContext) {} + +// EnterWindow_frame_bound is called when production window_frame_bound is entered. +func (s *BaseTSqlParserListener) EnterWindow_frame_bound(ctx *Window_frame_boundContext) {} + +// ExitWindow_frame_bound is called when production window_frame_bound is exited. +func (s *BaseTSqlParserListener) ExitWindow_frame_bound(ctx *Window_frame_boundContext) {} + +// EnterWindow_frame_preceding is called when production window_frame_preceding is entered. +func (s *BaseTSqlParserListener) EnterWindow_frame_preceding(ctx *Window_frame_precedingContext) {} + +// ExitWindow_frame_preceding is called when production window_frame_preceding is exited. +func (s *BaseTSqlParserListener) ExitWindow_frame_preceding(ctx *Window_frame_precedingContext) {} + +// EnterWindow_frame_following is called when production window_frame_following is entered. +func (s *BaseTSqlParserListener) EnterWindow_frame_following(ctx *Window_frame_followingContext) {} + +// ExitWindow_frame_following is called when production window_frame_following is exited. +func (s *BaseTSqlParserListener) ExitWindow_frame_following(ctx *Window_frame_followingContext) {} + +// EnterCreate_database_option is called when production create_database_option is entered. +func (s *BaseTSqlParserListener) EnterCreate_database_option(ctx *Create_database_optionContext) {} + +// ExitCreate_database_option is called when production create_database_option is exited. +func (s *BaseTSqlParserListener) ExitCreate_database_option(ctx *Create_database_optionContext) {} + +// EnterDatabase_filestream_option is called when production database_filestream_option is entered. +func (s *BaseTSqlParserListener) EnterDatabase_filestream_option(ctx *Database_filestream_optionContext) { +} + +// ExitDatabase_filestream_option is called when production database_filestream_option is exited. +func (s *BaseTSqlParserListener) ExitDatabase_filestream_option(ctx *Database_filestream_optionContext) { +} + +// EnterDatabase_file_spec is called when production database_file_spec is entered. +func (s *BaseTSqlParserListener) EnterDatabase_file_spec(ctx *Database_file_specContext) {} + +// ExitDatabase_file_spec is called when production database_file_spec is exited. +func (s *BaseTSqlParserListener) ExitDatabase_file_spec(ctx *Database_file_specContext) {} + +// EnterFile_group is called when production file_group is entered. +func (s *BaseTSqlParserListener) EnterFile_group(ctx *File_groupContext) {} + +// ExitFile_group is called when production file_group is exited. +func (s *BaseTSqlParserListener) ExitFile_group(ctx *File_groupContext) {} + +// EnterFile_spec is called when production file_spec is entered. +func (s *BaseTSqlParserListener) EnterFile_spec(ctx *File_specContext) {} + +// ExitFile_spec is called when production file_spec is exited. +func (s *BaseTSqlParserListener) ExitFile_spec(ctx *File_specContext) {} + +// EnterEntity_name is called when production entity_name is entered. +func (s *BaseTSqlParserListener) EnterEntity_name(ctx *Entity_nameContext) {} + +// ExitEntity_name is called when production entity_name is exited. +func (s *BaseTSqlParserListener) ExitEntity_name(ctx *Entity_nameContext) {} + +// EnterEntity_name_for_azure_dw is called when production entity_name_for_azure_dw is entered. +func (s *BaseTSqlParserListener) EnterEntity_name_for_azure_dw(ctx *Entity_name_for_azure_dwContext) { +} + +// ExitEntity_name_for_azure_dw is called when production entity_name_for_azure_dw is exited. +func (s *BaseTSqlParserListener) ExitEntity_name_for_azure_dw(ctx *Entity_name_for_azure_dwContext) {} + +// EnterEntity_name_for_parallel_dw is called when production entity_name_for_parallel_dw is entered. +func (s *BaseTSqlParserListener) EnterEntity_name_for_parallel_dw(ctx *Entity_name_for_parallel_dwContext) { +} + +// ExitEntity_name_for_parallel_dw is called when production entity_name_for_parallel_dw is exited. +func (s *BaseTSqlParserListener) ExitEntity_name_for_parallel_dw(ctx *Entity_name_for_parallel_dwContext) { +} + +// EnterFull_table_name is called when production full_table_name is entered. +func (s *BaseTSqlParserListener) EnterFull_table_name(ctx *Full_table_nameContext) {} + +// ExitFull_table_name is called when production full_table_name is exited. +func (s *BaseTSqlParserListener) ExitFull_table_name(ctx *Full_table_nameContext) {} + +// EnterDotID is called when production dotID is entered. +func (s *BaseTSqlParserListener) EnterDotID(ctx *DotIDContext) {} + +// ExitDotID is called when production dotID is exited. +func (s *BaseTSqlParserListener) ExitDotID(ctx *DotIDContext) {} + +// EnterDoubleDotID is called when production doubleDotID is entered. +func (s *BaseTSqlParserListener) EnterDoubleDotID(ctx *DoubleDotIDContext) {} + +// ExitDoubleDotID is called when production doubleDotID is exited. +func (s *BaseTSqlParserListener) ExitDoubleDotID(ctx *DoubleDotIDContext) {} + +// EnterTable_name is called when production table_name is entered. +func (s *BaseTSqlParserListener) EnterTable_name(ctx *Table_nameContext) {} + +// ExitTable_name is called when production table_name is exited. +func (s *BaseTSqlParserListener) ExitTable_name(ctx *Table_nameContext) {} + +// EnterSimple_name is called when production simple_name is entered. +func (s *BaseTSqlParserListener) EnterSimple_name(ctx *Simple_nameContext) {} + +// ExitSimple_name is called when production simple_name is exited. +func (s *BaseTSqlParserListener) ExitSimple_name(ctx *Simple_nameContext) {} + +// EnterFunc_proc_name_schema is called when production func_proc_name_schema is entered. +func (s *BaseTSqlParserListener) EnterFunc_proc_name_schema(ctx *Func_proc_name_schemaContext) {} + +// ExitFunc_proc_name_schema is called when production func_proc_name_schema is exited. +func (s *BaseTSqlParserListener) ExitFunc_proc_name_schema(ctx *Func_proc_name_schemaContext) {} + +// EnterFunc_proc_name_database_schema is called when production func_proc_name_database_schema is entered. +func (s *BaseTSqlParserListener) EnterFunc_proc_name_database_schema(ctx *Func_proc_name_database_schemaContext) { +} + +// ExitFunc_proc_name_database_schema is called when production func_proc_name_database_schema is exited. +func (s *BaseTSqlParserListener) ExitFunc_proc_name_database_schema(ctx *Func_proc_name_database_schemaContext) { +} + +// EnterFunc_proc_name_server_database_schema is called when production func_proc_name_server_database_schema is entered. +func (s *BaseTSqlParserListener) EnterFunc_proc_name_server_database_schema(ctx *Func_proc_name_server_database_schemaContext) { +} + +// ExitFunc_proc_name_server_database_schema is called when production func_proc_name_server_database_schema is exited. +func (s *BaseTSqlParserListener) ExitFunc_proc_name_server_database_schema(ctx *Func_proc_name_server_database_schemaContext) { +} + +// EnterDdl_object is called when production ddl_object is entered. +func (s *BaseTSqlParserListener) EnterDdl_object(ctx *Ddl_objectContext) {} + +// ExitDdl_object is called when production ddl_object is exited. +func (s *BaseTSqlParserListener) ExitDdl_object(ctx *Ddl_objectContext) {} + +// EnterFull_column_name is called when production full_column_name is entered. +func (s *BaseTSqlParserListener) EnterFull_column_name(ctx *Full_column_nameContext) {} + +// ExitFull_column_name is called when production full_column_name is exited. +func (s *BaseTSqlParserListener) ExitFull_column_name(ctx *Full_column_nameContext) {} + +// EnterColumn_name_list_with_order is called when production column_name_list_with_order is entered. +func (s *BaseTSqlParserListener) EnterColumn_name_list_with_order(ctx *Column_name_list_with_orderContext) { +} + +// ExitColumn_name_list_with_order is called when production column_name_list_with_order is exited. +func (s *BaseTSqlParserListener) ExitColumn_name_list_with_order(ctx *Column_name_list_with_orderContext) { +} + +// EnterColumn_name_with_order is called when production column_name_with_order is entered. +func (s *BaseTSqlParserListener) EnterColumn_name_with_order(ctx *Column_name_with_orderContext) {} + +// ExitColumn_name_with_order is called when production column_name_with_order is exited. +func (s *BaseTSqlParserListener) ExitColumn_name_with_order(ctx *Column_name_with_orderContext) {} + +// EnterInsert_column_name_list is called when production insert_column_name_list is entered. +func (s *BaseTSqlParserListener) EnterInsert_column_name_list(ctx *Insert_column_name_listContext) {} + +// ExitInsert_column_name_list is called when production insert_column_name_list is exited. +func (s *BaseTSqlParserListener) ExitInsert_column_name_list(ctx *Insert_column_name_listContext) {} + +// EnterInsert_column_id is called when production insert_column_id is entered. +func (s *BaseTSqlParserListener) EnterInsert_column_id(ctx *Insert_column_idContext) {} + +// ExitInsert_column_id is called when production insert_column_id is exited. +func (s *BaseTSqlParserListener) ExitInsert_column_id(ctx *Insert_column_idContext) {} + +// EnterColumn_name_list is called when production column_name_list is entered. +func (s *BaseTSqlParserListener) EnterColumn_name_list(ctx *Column_name_listContext) {} + +// ExitColumn_name_list is called when production column_name_list is exited. +func (s *BaseTSqlParserListener) ExitColumn_name_list(ctx *Column_name_listContext) {} + +// EnterCursor_name is called when production cursor_name is entered. +func (s *BaseTSqlParserListener) EnterCursor_name(ctx *Cursor_nameContext) {} + +// ExitCursor_name is called when production cursor_name is exited. +func (s *BaseTSqlParserListener) ExitCursor_name(ctx *Cursor_nameContext) {} + +// EnterOn_off is called when production on_off is entered. +func (s *BaseTSqlParserListener) EnterOn_off(ctx *On_offContext) {} + +// ExitOn_off is called when production on_off is exited. +func (s *BaseTSqlParserListener) ExitOn_off(ctx *On_offContext) {} + +// EnterClustered is called when production clustered is entered. +func (s *BaseTSqlParserListener) EnterClustered(ctx *ClusteredContext) {} + +// ExitClustered is called when production clustered is exited. +func (s *BaseTSqlParserListener) ExitClustered(ctx *ClusteredContext) {} + +// EnterNull_notnull is called when production null_notnull is entered. +func (s *BaseTSqlParserListener) EnterNull_notnull(ctx *Null_notnullContext) {} + +// ExitNull_notnull is called when production null_notnull is exited. +func (s *BaseTSqlParserListener) ExitNull_notnull(ctx *Null_notnullContext) {} + +// EnterScalar_function_name is called when production scalar_function_name is entered. +func (s *BaseTSqlParserListener) EnterScalar_function_name(ctx *Scalar_function_nameContext) {} + +// ExitScalar_function_name is called when production scalar_function_name is exited. +func (s *BaseTSqlParserListener) ExitScalar_function_name(ctx *Scalar_function_nameContext) {} + +// EnterBegin_conversation_timer is called when production begin_conversation_timer is entered. +func (s *BaseTSqlParserListener) EnterBegin_conversation_timer(ctx *Begin_conversation_timerContext) { +} + +// ExitBegin_conversation_timer is called when production begin_conversation_timer is exited. +func (s *BaseTSqlParserListener) ExitBegin_conversation_timer(ctx *Begin_conversation_timerContext) {} + +// EnterBegin_conversation_dialog is called when production begin_conversation_dialog is entered. +func (s *BaseTSqlParserListener) EnterBegin_conversation_dialog(ctx *Begin_conversation_dialogContext) { +} + +// ExitBegin_conversation_dialog is called when production begin_conversation_dialog is exited. +func (s *BaseTSqlParserListener) ExitBegin_conversation_dialog(ctx *Begin_conversation_dialogContext) { +} + +// EnterContract_name is called when production contract_name is entered. +func (s *BaseTSqlParserListener) EnterContract_name(ctx *Contract_nameContext) {} + +// ExitContract_name is called when production contract_name is exited. +func (s *BaseTSqlParserListener) ExitContract_name(ctx *Contract_nameContext) {} + +// EnterService_name is called when production service_name is entered. +func (s *BaseTSqlParserListener) EnterService_name(ctx *Service_nameContext) {} + +// ExitService_name is called when production service_name is exited. +func (s *BaseTSqlParserListener) ExitService_name(ctx *Service_nameContext) {} + +// EnterEnd_conversation is called when production end_conversation is entered. +func (s *BaseTSqlParserListener) EnterEnd_conversation(ctx *End_conversationContext) {} + +// ExitEnd_conversation is called when production end_conversation is exited. +func (s *BaseTSqlParserListener) ExitEnd_conversation(ctx *End_conversationContext) {} + +// EnterWaitfor_conversation is called when production waitfor_conversation is entered. +func (s *BaseTSqlParserListener) EnterWaitfor_conversation(ctx *Waitfor_conversationContext) {} + +// ExitWaitfor_conversation is called when production waitfor_conversation is exited. +func (s *BaseTSqlParserListener) ExitWaitfor_conversation(ctx *Waitfor_conversationContext) {} + +// EnterGet_conversation is called when production get_conversation is entered. +func (s *BaseTSqlParserListener) EnterGet_conversation(ctx *Get_conversationContext) {} + +// ExitGet_conversation is called when production get_conversation is exited. +func (s *BaseTSqlParserListener) ExitGet_conversation(ctx *Get_conversationContext) {} + +// EnterQueue_id is called when production queue_id is entered. +func (s *BaseTSqlParserListener) EnterQueue_id(ctx *Queue_idContext) {} + +// ExitQueue_id is called when production queue_id is exited. +func (s *BaseTSqlParserListener) ExitQueue_id(ctx *Queue_idContext) {} + +// EnterSend_conversation is called when production send_conversation is entered. +func (s *BaseTSqlParserListener) EnterSend_conversation(ctx *Send_conversationContext) {} + +// ExitSend_conversation is called when production send_conversation is exited. +func (s *BaseTSqlParserListener) ExitSend_conversation(ctx *Send_conversationContext) {} + +// EnterData_type is called when production data_type is entered. +func (s *BaseTSqlParserListener) EnterData_type(ctx *Data_typeContext) {} + +// ExitData_type is called when production data_type is exited. +func (s *BaseTSqlParserListener) ExitData_type(ctx *Data_typeContext) {} + +// EnterConstant is called when production constant is entered. +func (s *BaseTSqlParserListener) EnterConstant(ctx *ConstantContext) {} + +// ExitConstant is called when production constant is exited. +func (s *BaseTSqlParserListener) ExitConstant(ctx *ConstantContext) {} + +// EnterPrimitive_constant is called when production primitive_constant is entered. +func (s *BaseTSqlParserListener) EnterPrimitive_constant(ctx *Primitive_constantContext) {} + +// ExitPrimitive_constant is called when production primitive_constant is exited. +func (s *BaseTSqlParserListener) ExitPrimitive_constant(ctx *Primitive_constantContext) {} + +// EnterKeyword is called when production keyword is entered. +func (s *BaseTSqlParserListener) EnterKeyword(ctx *KeywordContext) {} + +// ExitKeyword is called when production keyword is exited. +func (s *BaseTSqlParserListener) ExitKeyword(ctx *KeywordContext) {} + +// EnterId_ is called when production id_ is entered. +func (s *BaseTSqlParserListener) EnterId_(ctx *Id_Context) {} + +// ExitId_ is called when production id_ is exited. +func (s *BaseTSqlParserListener) ExitId_(ctx *Id_Context) {} + +// EnterSimple_id is called when production simple_id is entered. +func (s *BaseTSqlParserListener) EnterSimple_id(ctx *Simple_idContext) {} + +// ExitSimple_id is called when production simple_id is exited. +func (s *BaseTSqlParserListener) ExitSimple_id(ctx *Simple_idContext) {} + +// EnterId_or_string is called when production id_or_string is entered. +func (s *BaseTSqlParserListener) EnterId_or_string(ctx *Id_or_stringContext) {} + +// ExitId_or_string is called when production id_or_string is exited. +func (s *BaseTSqlParserListener) ExitId_or_string(ctx *Id_or_stringContext) {} + +// EnterComparison_operator is called when production comparison_operator is entered. +func (s *BaseTSqlParserListener) EnterComparison_operator(ctx *Comparison_operatorContext) {} + +// ExitComparison_operator is called when production comparison_operator is exited. +func (s *BaseTSqlParserListener) ExitComparison_operator(ctx *Comparison_operatorContext) {} + +// EnterAssignment_operator is called when production assignment_operator is entered. +func (s *BaseTSqlParserListener) EnterAssignment_operator(ctx *Assignment_operatorContext) {} + +// ExitAssignment_operator is called when production assignment_operator is exited. +func (s *BaseTSqlParserListener) ExitAssignment_operator(ctx *Assignment_operatorContext) {} + +// EnterFile_size is called when production file_size is entered. +func (s *BaseTSqlParserListener) EnterFile_size(ctx *File_sizeContext) {} + +// ExitFile_size is called when production file_size is exited. +func (s *BaseTSqlParserListener) ExitFile_size(ctx *File_sizeContext) {} diff --git a/tsql/tsqlparser_base_visitor.go b/tsql/tsqlparser_base_visitor.go new file mode 100644 index 0000000..a37a581 --- /dev/null +++ b/tsql/tsqlparser_base_visitor.go @@ -0,0 +1,3312 @@ +// Code generated from TSqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package tsql // TSqlParser +import "github.com/antlr4-go/antlr/v4" + +type BaseTSqlParserVisitor struct { + *antlr.BaseParseTreeVisitor +} + +func (v *BaseTSqlParserVisitor) VisitTsql_file(ctx *Tsql_fileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBatch_without_go(ctx *Batch_without_goContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBatch_level_statement(ctx *Batch_level_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSql_clauses(ctx *Sql_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDml_clause(ctx *Dml_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDdl_clause(ctx *Ddl_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBackup_statement(ctx *Backup_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCfl_statement(ctx *Cfl_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBlock_statement(ctx *Block_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBreak_statement(ctx *Break_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitContinue_statement(ctx *Continue_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitGoto_statement(ctx *Goto_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitReturn_statement(ctx *Return_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitIf_statement(ctx *If_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitThrow_statement(ctx *Throw_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitThrow_error_number(ctx *Throw_error_numberContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitThrow_message(ctx *Throw_messageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitThrow_state(ctx *Throw_stateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTry_catch_statement(ctx *Try_catch_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitWaitfor_statement(ctx *Waitfor_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitWhile_statement(ctx *While_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPrint_statement(ctx *Print_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRaiseerror_statement(ctx *Raiseerror_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEmpty_statement(ctx *Empty_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAnother_statement(ctx *Another_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_application_role(ctx *Alter_application_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_xml_schema_collection(ctx *Alter_xml_schema_collectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_application_role(ctx *Create_application_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_aggregate(ctx *Drop_aggregateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_application_role(ctx *Drop_application_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly(ctx *Alter_assemblyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_start(ctx *Alter_assembly_startContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_clause(ctx *Alter_assembly_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_from_clause(ctx *Alter_assembly_from_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_from_clause_start(ctx *Alter_assembly_from_clause_startContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_drop_clause(ctx *Alter_assembly_drop_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_drop_multiple_files(ctx *Alter_assembly_drop_multiple_filesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_drop(ctx *Alter_assembly_dropContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_add_clause(ctx *Alter_assembly_add_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_asssembly_add_clause_start(ctx *Alter_asssembly_add_clause_startContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_client_file_clause(ctx *Alter_assembly_client_file_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_file_name(ctx *Alter_assembly_file_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_file_bits(ctx *Alter_assembly_file_bitsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_as(ctx *Alter_assembly_asContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_with_clause(ctx *Alter_assembly_with_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_assembly_with(ctx *Alter_assembly_withContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitClient_assembly_specifier(ctx *Client_assembly_specifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAssembly_option(ctx *Assembly_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitNetwork_file_share(ctx *Network_file_shareContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitNetwork_computer(ctx *Network_computerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitNetwork_file_start(ctx *Network_file_startContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFile_path(ctx *File_pathContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFile_directory_path_separator(ctx *File_directory_path_separatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitLocal_file(ctx *Local_fileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitLocal_drive(ctx *Local_driveContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMultiple_local_files(ctx *Multiple_local_filesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMultiple_local_file_start(ctx *Multiple_local_file_startContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_assembly(ctx *Create_assemblyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_assembly(ctx *Drop_assemblyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_asymmetric_key(ctx *Alter_asymmetric_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_asymmetric_key_start(ctx *Alter_asymmetric_key_startContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAsymmetric_key_option(ctx *Asymmetric_key_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAsymmetric_key_option_start(ctx *Asymmetric_key_option_startContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAsymmetric_key_password_change_option(ctx *Asymmetric_key_password_change_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_asymmetric_key(ctx *Create_asymmetric_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_asymmetric_key(ctx *Drop_asymmetric_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_authorization(ctx *Alter_authorizationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAuthorization_grantee(ctx *Authorization_granteeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEntity_to(ctx *Entity_toContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColon_colon(ctx *Colon_colonContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_authorization_start(ctx *Alter_authorization_startContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_authorization_for_sql_database(ctx *Alter_authorization_for_sql_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_authorization_for_azure_dw(ctx *Alter_authorization_for_azure_dwContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_authorization_for_parallel_dw(ctx *Alter_authorization_for_parallel_dwContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitClass_type(ctx *Class_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitClass_type_for_sql_database(ctx *Class_type_for_sql_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitClass_type_for_azure_dw(ctx *Class_type_for_azure_dwContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitClass_type_for_parallel_dw(ctx *Class_type_for_parallel_dwContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitClass_type_for_grant(ctx *Class_type_for_grantContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_availability_group(ctx *Drop_availability_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_availability_group(ctx *Alter_availability_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_availability_group_start(ctx *Alter_availability_group_startContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_availability_group_options(ctx *Alter_availability_group_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitIp_v4_failover(ctx *Ip_v4_failoverContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitIp_v6_failover(ctx *Ip_v6_failoverContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_or_alter_broker_priority(ctx *Create_or_alter_broker_priorityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_broker_priority(ctx *Drop_broker_priorityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_certificate(ctx *Alter_certificateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_column_encryption_key(ctx *Alter_column_encryption_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_column_encryption_key(ctx *Create_column_encryption_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_certificate(ctx *Drop_certificateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_column_encryption_key(ctx *Drop_column_encryption_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_column_master_key(ctx *Drop_column_master_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_contract(ctx *Drop_contractContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_credential(ctx *Drop_credentialContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_cryptograhic_provider(ctx *Drop_cryptograhic_providerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_database(ctx *Drop_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_database_audit_specification(ctx *Drop_database_audit_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_database_encryption_key(ctx *Drop_database_encryption_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_database_scoped_credential(ctx *Drop_database_scoped_credentialContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_default(ctx *Drop_defaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_endpoint(ctx *Drop_endpointContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_external_data_source(ctx *Drop_external_data_sourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_external_file_format(ctx *Drop_external_file_formatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_external_library(ctx *Drop_external_libraryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_external_resource_pool(ctx *Drop_external_resource_poolContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_external_table(ctx *Drop_external_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_event_notifications(ctx *Drop_event_notificationsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_event_session(ctx *Drop_event_sessionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_fulltext_catalog(ctx *Drop_fulltext_catalogContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_fulltext_index(ctx *Drop_fulltext_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_fulltext_stoplist(ctx *Drop_fulltext_stoplistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_login(ctx *Drop_loginContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_master_key(ctx *Drop_master_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_message_type(ctx *Drop_message_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_partition_function(ctx *Drop_partition_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_partition_scheme(ctx *Drop_partition_schemeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_queue(ctx *Drop_queueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_remote_service_binding(ctx *Drop_remote_service_bindingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_resource_pool(ctx *Drop_resource_poolContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_db_role(ctx *Drop_db_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_route(ctx *Drop_routeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_rule(ctx *Drop_ruleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_schema(ctx *Drop_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_search_property_list(ctx *Drop_search_property_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_security_policy(ctx *Drop_security_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_sequence(ctx *Drop_sequenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_server_audit(ctx *Drop_server_auditContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_server_audit_specification(ctx *Drop_server_audit_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_server_role(ctx *Drop_server_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_service(ctx *Drop_serviceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_signature(ctx *Drop_signatureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_statistics_name_azure_dw_and_pdw(ctx *Drop_statistics_name_azure_dw_and_pdwContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_symmetric_key(ctx *Drop_symmetric_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_synonym(ctx *Drop_synonymContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_user(ctx *Drop_userContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_workload_group(ctx *Drop_workload_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_xml_schema_collection(ctx *Drop_xml_schema_collectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDisable_trigger(ctx *Disable_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEnable_trigger(ctx *Enable_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitLock_table(ctx *Lock_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTruncate_table(ctx *Truncate_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_column_master_key(ctx *Create_column_master_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_credential(ctx *Alter_credentialContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_credential(ctx *Create_credentialContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_cryptographic_provider(ctx *Alter_cryptographic_providerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_cryptographic_provider(ctx *Create_cryptographic_providerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_endpoint(ctx *Create_endpointContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEndpoint_encryption_alogorithm_clause(ctx *Endpoint_encryption_alogorithm_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEndpoint_authentication_clause(ctx *Endpoint_authentication_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEndpoint_listener_clause(ctx *Endpoint_listener_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_event_notification(ctx *Create_event_notificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_or_alter_event_session(ctx *Create_or_alter_event_sessionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEvent_session_predicate_expression(ctx *Event_session_predicate_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEvent_session_predicate_factor(ctx *Event_session_predicate_factorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEvent_session_predicate_leaf(ctx *Event_session_predicate_leafContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_external_data_source(ctx *Alter_external_data_sourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_external_library(ctx *Alter_external_libraryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_external_library(ctx *Create_external_libraryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_external_resource_pool(ctx *Alter_external_resource_poolContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_external_resource_pool(ctx *Create_external_resource_poolContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_fulltext_catalog(ctx *Alter_fulltext_catalogContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_fulltext_catalog(ctx *Create_fulltext_catalogContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_fulltext_stoplist(ctx *Alter_fulltext_stoplistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_fulltext_stoplist(ctx *Create_fulltext_stoplistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_login_sql_server(ctx *Alter_login_sql_serverContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_login_sql_server(ctx *Create_login_sql_serverContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_login_azure_sql(ctx *Alter_login_azure_sqlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_login_azure_sql(ctx *Create_login_azure_sqlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_login_azure_sql_dw_and_pdw(ctx *Alter_login_azure_sql_dw_and_pdwContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_login_pdw(ctx *Create_login_pdwContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_master_key_sql_server(ctx *Alter_master_key_sql_serverContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_master_key_sql_server(ctx *Create_master_key_sql_serverContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_master_key_azure_sql(ctx *Alter_master_key_azure_sqlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_master_key_azure_sql(ctx *Create_master_key_azure_sqlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_message_type(ctx *Alter_message_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_partition_function(ctx *Alter_partition_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_partition_scheme(ctx *Alter_partition_schemeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_remote_service_binding(ctx *Alter_remote_service_bindingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_remote_service_binding(ctx *Create_remote_service_bindingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_resource_pool(ctx *Create_resource_poolContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_resource_governor(ctx *Alter_resource_governorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_database_audit_specification(ctx *Alter_database_audit_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAudit_action_spec_group(ctx *Audit_action_spec_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAudit_action_specification(ctx *Audit_action_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAction_specification(ctx *Action_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAudit_class_name(ctx *Audit_class_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAudit_securable(ctx *Audit_securableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_db_role(ctx *Alter_db_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_database_audit_specification(ctx *Create_database_audit_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_db_role(ctx *Create_db_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_route(ctx *Create_routeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_rule(ctx *Create_ruleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_schema_sql(ctx *Alter_schema_sqlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_schema(ctx *Create_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_schema_azure_sql_dw_and_pdw(ctx *Create_schema_azure_sql_dw_and_pdwContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_schema_azure_sql_dw_and_pdw(ctx *Alter_schema_azure_sql_dw_and_pdwContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_search_property_list(ctx *Create_search_property_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_security_policy(ctx *Create_security_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_sequence(ctx *Alter_sequenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_sequence(ctx *Create_sequenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_server_audit(ctx *Alter_server_auditContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_server_audit(ctx *Create_server_auditContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_server_audit_specification(ctx *Alter_server_audit_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_server_audit_specification(ctx *Create_server_audit_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_server_configuration(ctx *Alter_server_configurationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_server_role(ctx *Alter_server_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_server_role(ctx *Create_server_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_server_role_pdw(ctx *Alter_server_role_pdwContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_service(ctx *Alter_serviceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOpt_arg_clause(ctx *Opt_arg_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_service(ctx *Create_serviceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_service_master_key(ctx *Alter_service_master_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_symmetric_key(ctx *Alter_symmetric_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_synonym(ctx *Create_synonymContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_user(ctx *Alter_userContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_user(ctx *Create_userContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_user_azure_sql_dw(ctx *Create_user_azure_sql_dwContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_user_azure_sql(ctx *Alter_user_azure_sqlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_workload_group(ctx *Alter_workload_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_workload_group(ctx *Create_workload_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_xml_schema_collection(ctx *Create_xml_schema_collectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_partition_function(ctx *Create_partition_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_partition_scheme(ctx *Create_partition_schemeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_queue(ctx *Create_queueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitQueue_settings(ctx *Queue_settingsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_queue(ctx *Alter_queueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitQueue_action(ctx *Queue_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitQueue_rebuild_options(ctx *Queue_rebuild_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_contract(ctx *Create_contractContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitConversation_statement(ctx *Conversation_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMessage_statement(ctx *Message_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMerge_statement(ctx *Merge_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitWhen_matches(ctx *When_matchesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMerge_matched(ctx *Merge_matchedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMerge_not_matched(ctx *Merge_not_matchedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDelete_statement(ctx *Delete_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDelete_statement_from(ctx *Delete_statement_fromContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitInsert_statement(ctx *Insert_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitInsert_statement_value(ctx *Insert_statement_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitReceive_statement(ctx *Receive_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSelect_statement_standalone(ctx *Select_statement_standaloneContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSelect_statement(ctx *Select_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTime(ctx *TimeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUpdate_statement(ctx *Update_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOutput_clause(ctx *Output_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOutput_dml_list_elem(ctx *Output_dml_list_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_database(ctx *Create_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_index(ctx *Create_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_spatial_index(ctx *Create_spatial_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSpatial_tessellation_scheme(ctx *Spatial_tessellation_schemeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSpatial_index_options(ctx *Spatial_index_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSpatial_index_option(ctx *Spatial_index_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSigned_decimal(ctx *Signed_decimalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSpatial_grid_level(ctx *Spatial_grid_levelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSpatial_grid_density(ctx *Spatial_grid_densityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_index_options(ctx *Create_index_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRelational_index_option(ctx *Relational_index_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_index(ctx *Alter_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitResumable_index_options(ctx *Resumable_index_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitResumable_index_option(ctx *Resumable_index_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitReorganize_partition(ctx *Reorganize_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitReorganize_options(ctx *Reorganize_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitReorganize_option(ctx *Reorganize_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSet_index_options(ctx *Set_index_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSet_index_option(ctx *Set_index_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRebuild_partition(ctx *Rebuild_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRebuild_index_options(ctx *Rebuild_index_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRebuild_index_option(ctx *Rebuild_index_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSingle_partition_rebuild_index_options(ctx *Single_partition_rebuild_index_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSingle_partition_rebuild_index_option(ctx *Single_partition_rebuild_index_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOn_partitions(ctx *On_partitionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_columnstore_index(ctx *Create_columnstore_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_columnstore_index_options(ctx *Create_columnstore_index_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumnstore_index_option(ctx *Columnstore_index_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_nonclustered_columnstore_index(ctx *Create_nonclustered_columnstore_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_xml_index(ctx *Create_xml_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitXml_index_options(ctx *Xml_index_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitXml_index_option(ctx *Xml_index_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_or_alter_procedure(ctx *Create_or_alter_procedureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAs_external_name(ctx *As_external_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_or_alter_trigger(ctx *Create_or_alter_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_or_alter_dml_trigger(ctx *Create_or_alter_dml_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDml_trigger_option(ctx *Dml_trigger_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDml_trigger_operation(ctx *Dml_trigger_operationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_or_alter_ddl_trigger(ctx *Create_or_alter_ddl_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDdl_trigger_operation(ctx *Ddl_trigger_operationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_or_alter_function(ctx *Create_or_alter_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFunc_body_returns_select(ctx *Func_body_returns_selectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFunc_body_returns_table(ctx *Func_body_returns_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFunc_body_returns_scalar(ctx *Func_body_returns_scalarContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitProcedure_param_default_value(ctx *Procedure_param_default_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitProcedure_param(ctx *Procedure_paramContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitProcedure_option(ctx *Procedure_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFunction_option(ctx *Function_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_statistics(ctx *Create_statisticsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUpdate_statistics(ctx *Update_statisticsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUpdate_statistics_options(ctx *Update_statistics_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUpdate_statistics_option(ctx *Update_statistics_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_table(ctx *Create_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTable_indices(ctx *Table_indicesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTable_options(ctx *Table_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTable_option(ctx *Table_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_table_index_options(ctx *Create_table_index_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_table_index_option(ctx *Create_table_index_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_view(ctx *Create_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitView_attribute(ctx *View_attributeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_table(ctx *Alter_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSwitch_partition(ctx *Switch_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitLow_priority_lock_wait(ctx *Low_priority_lock_waitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_database(ctx *Alter_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAdd_or_modify_files(ctx *Add_or_modify_filesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFilespec(ctx *FilespecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAdd_or_modify_filegroups(ctx *Add_or_modify_filegroupsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFilegroup_updatability_option(ctx *Filegroup_updatability_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDatabase_optionspec(ctx *Database_optionspecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAuto_option(ctx *Auto_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitChange_tracking_option(ctx *Change_tracking_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitChange_tracking_option_list(ctx *Change_tracking_option_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitContainment_option(ctx *Containment_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCursor_option(ctx *Cursor_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_endpoint(ctx *Alter_endpointContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDatabase_mirroring_option(ctx *Database_mirroring_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMirroring_set_option(ctx *Mirroring_set_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMirroring_partner(ctx *Mirroring_partnerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMirroring_witness(ctx *Mirroring_witnessContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitWitness_partner_equal(ctx *Witness_partner_equalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPartner_option(ctx *Partner_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitWitness_option(ctx *Witness_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitWitness_server(ctx *Witness_serverContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPartner_server(ctx *Partner_serverContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMirroring_host_port_seperator(ctx *Mirroring_host_port_seperatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPartner_server_tcp_prefix(ctx *Partner_server_tcp_prefixContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPort_number(ctx *Port_numberContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitHost(ctx *HostContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDate_correlation_optimization_option(ctx *Date_correlation_optimization_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDb_encryption_option(ctx *Db_encryption_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDb_state_option(ctx *Db_state_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDb_update_option(ctx *Db_update_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDb_user_access_option(ctx *Db_user_access_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDelayed_durability_option(ctx *Delayed_durability_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExternal_access_option(ctx *External_access_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitHadr_options(ctx *Hadr_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMixed_page_allocation_option(ctx *Mixed_page_allocation_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitParameterization_option(ctx *Parameterization_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRecovery_option(ctx *Recovery_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitService_broker_option(ctx *Service_broker_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSnapshot_option(ctx *Snapshot_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSql_option(ctx *Sql_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTarget_recovery_time_option(ctx *Target_recovery_time_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTermination(ctx *TerminationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_index(ctx *Drop_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_relational_or_xml_or_spatial_index(ctx *Drop_relational_or_xml_or_spatial_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_backward_compatible_index(ctx *Drop_backward_compatible_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_procedure(ctx *Drop_procedureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_trigger(ctx *Drop_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_dml_trigger(ctx *Drop_dml_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_ddl_trigger(ctx *Drop_ddl_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_function(ctx *Drop_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_statistics(ctx *Drop_statisticsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_table(ctx *Drop_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_view(ctx *Drop_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_type(ctx *Create_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDrop_type(ctx *Drop_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRowset_function_limited(ctx *Rowset_function_limitedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOpenquery(ctx *OpenqueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOpendatasource(ctx *OpendatasourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDeclare_statement(ctx *Declare_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitXml_declaration(ctx *Xml_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCursor_statement(ctx *Cursor_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBackup_database(ctx *Backup_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBackup_log(ctx *Backup_logContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBackup_certificate(ctx *Backup_certificateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBackup_master_key(ctx *Backup_master_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBackup_service_master_key(ctx *Backup_service_master_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitKill_statement(ctx *Kill_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitKill_process(ctx *Kill_processContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitKill_query_notification(ctx *Kill_query_notificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitKill_stats_job(ctx *Kill_stats_jobContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExecute_statement(ctx *Execute_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExecute_body_batch(ctx *Execute_body_batchContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExecute_body(ctx *Execute_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExecute_statement_arg(ctx *Execute_statement_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExecute_statement_arg_named(ctx *Execute_statement_arg_namedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExecute_statement_arg_unnamed(ctx *Execute_statement_arg_unnamedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExecute_parameter(ctx *Execute_parameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExecute_var_string(ctx *Execute_var_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSecurity_statement(ctx *Security_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPrincipal_id(ctx *Principal_idContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_certificate(ctx *Create_certificateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExisting_keys(ctx *Existing_keysContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPrivate_key_options(ctx *Private_key_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitGenerate_new_keys(ctx *Generate_new_keysContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDate_options(ctx *Date_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOpen_key(ctx *Open_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitClose_key(ctx *Close_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_key(ctx *Create_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitKey_options(ctx *Key_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlgorithm(ctx *AlgorithmContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEncryption_mechanism(ctx *Encryption_mechanismContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDecryption_mechanism(ctx *Decryption_mechanismContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitGrant_permission(ctx *Grant_permissionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSet_statement(ctx *Set_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTransaction_statement(ctx *Transaction_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitGo_statement(ctx *Go_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUse_statement(ctx *Use_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSetuser_statement(ctx *Setuser_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitReconfigure_statement(ctx *Reconfigure_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitShutdown_statement(ctx *Shutdown_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCheckpoint_statement(ctx *Checkpoint_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_checkalloc_option(ctx *Dbcc_checkalloc_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_checkalloc(ctx *Dbcc_checkallocContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_checkcatalog(ctx *Dbcc_checkcatalogContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_checkconstraints_option(ctx *Dbcc_checkconstraints_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_checkconstraints(ctx *Dbcc_checkconstraintsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_checkdb_table_option(ctx *Dbcc_checkdb_table_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_checkdb(ctx *Dbcc_checkdbContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_checkfilegroup_option(ctx *Dbcc_checkfilegroup_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_checkfilegroup(ctx *Dbcc_checkfilegroupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_checktable(ctx *Dbcc_checktableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_cleantable(ctx *Dbcc_cleantableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_clonedatabase_option(ctx *Dbcc_clonedatabase_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_clonedatabase(ctx *Dbcc_clonedatabaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_pdw_showspaceused(ctx *Dbcc_pdw_showspaceusedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_proccache(ctx *Dbcc_proccacheContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_showcontig_option(ctx *Dbcc_showcontig_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_showcontig(ctx *Dbcc_showcontigContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_shrinklog(ctx *Dbcc_shrinklogContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_dbreindex(ctx *Dbcc_dbreindexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_dll_free(ctx *Dbcc_dll_freeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_dropcleanbuffers(ctx *Dbcc_dropcleanbuffersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDbcc_clause(ctx *Dbcc_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExecute_clause(ctx *Execute_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDeclare_local(ctx *Declare_localContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTable_type_definition(ctx *Table_type_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTable_type_indices(ctx *Table_type_indicesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitXml_type_definition(ctx *Xml_type_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitXml_schema_collection(ctx *Xml_schema_collectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumn_def_table_constraints(ctx *Column_def_table_constraintsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumn_def_table_constraint(ctx *Column_def_table_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumn_definition(ctx *Column_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumn_definition_element(ctx *Column_definition_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumn_modifier(ctx *Column_modifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMaterialized_column_definition(ctx *Materialized_column_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumn_constraint(ctx *Column_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumn_index(ctx *Column_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOn_partition_or_filegroup(ctx *On_partition_or_filegroupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTable_constraint(ctx *Table_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitConnection_node(ctx *Connection_nodeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPrimary_key_options(ctx *Primary_key_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitForeign_key_options(ctx *Foreign_key_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCheck_constraint(ctx *Check_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOn_delete(ctx *On_deleteContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOn_update(ctx *On_updateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_table_index_options(ctx *Alter_table_index_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAlter_table_index_option(ctx *Alter_table_index_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDeclare_cursor(ctx *Declare_cursorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDeclare_set_cursor_common(ctx *Declare_set_cursor_commonContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDeclare_set_cursor_common_partial(ctx *Declare_set_cursor_common_partialContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFetch_cursor(ctx *Fetch_cursorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSet_special(ctx *Set_specialContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSpecial_list(ctx *Special_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitConstant_LOCAL_ID(ctx *Constant_LOCAL_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExpression(ctx *ExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitParameter(ctx *ParameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTime_zone(ctx *Time_zoneContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPrimitive_expression(ctx *Primitive_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCase_expression(ctx *Case_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUnary_operator_expression(ctx *Unary_operator_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBracket_expression(ctx *Bracket_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSubquery(ctx *SubqueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitWith_expression(ctx *With_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCommon_table_expression(ctx *Common_table_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUpdate_elem(ctx *Update_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUpdate_elem_merge(ctx *Update_elem_mergeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSearch_condition(ctx *Search_conditionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPredicate(ctx *PredicateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitQuery_expression(ctx *Query_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSql_union(ctx *Sql_unionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitQuery_specification(ctx *Query_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitGroup_by_clause(ctx *Group_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitHaving_clause(ctx *Having_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFrom_table_sources(ctx *From_table_sourcesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTop_clause(ctx *Top_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTop_percent(ctx *Top_percentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTop_count(ctx *Top_countContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOrder_by_clause(ctx *Order_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSelect_order_by_clause(ctx *Select_order_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFor_clause(ctx *For_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitXml_common_directives(ctx *Xml_common_directivesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOrder_by_expression(ctx *Order_by_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitGrouping_sets_item(ctx *Grouping_sets_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitGroup_by_item(ctx *Group_by_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOption_clause(ctx *Option_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOption(ctx *OptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOptimize_for_arg(ctx *Optimize_for_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSelect_list(ctx *Select_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUdt_method_arguments(ctx *Udt_method_argumentsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAsterisk(ctx *AsteriskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUdt_elem(ctx *Udt_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExpression_elem(ctx *Expression_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSelect_list_elem(ctx *Select_list_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTable_sources(ctx *Table_sourcesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTable_source(ctx *Table_sourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTable_source_item(ctx *Table_source_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOpen_xml(ctx *Open_xmlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOpen_json(ctx *Open_jsonContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitJson_declaration(ctx *Json_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitJson_column_declaration(ctx *Json_column_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSchema_declaration(ctx *Schema_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumn_declaration(ctx *Column_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitChange_table(ctx *Change_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitChange_table_changes(ctx *Change_table_changesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitChange_table_version(ctx *Change_table_versionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitJoin_part(ctx *Join_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitJoin_on(ctx *Join_onContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCross_join(ctx *Cross_joinContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitApply_(ctx *Apply_Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPivot(ctx *PivotContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUnpivot(ctx *UnpivotContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPivot_clause(ctx *Pivot_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUnpivot_clause(ctx *Unpivot_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFull_column_name_list(ctx *Full_column_name_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRowset_function(ctx *Rowset_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBulk_option(ctx *Bulk_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDerived_table(ctx *Derived_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRANKING_WINDOWED_FUNC(ctx *RANKING_WINDOWED_FUNCContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAGGREGATE_WINDOWED_FUNC(ctx *AGGREGATE_WINDOWED_FUNCContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitANALYTIC_WINDOWED_FUNC(ctx *ANALYTIC_WINDOWED_FUNCContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBUILT_IN_FUNC(ctx *BUILT_IN_FUNCContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSCALAR_FUNCTION(ctx *SCALAR_FUNCTIONContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFREE_TEXT(ctx *FREE_TEXTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPARTITION_FUNC(ctx *PARTITION_FUNCContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitHIERARCHYID_METHOD(ctx *HIERARCHYID_METHODContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPartition_function(ctx *Partition_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFreetext_function(ctx *Freetext_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFreetext_predicate(ctx *Freetext_predicateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitJson_key_value(ctx *Json_key_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitJson_null_clause(ctx *Json_null_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAPP_NAME(ctx *APP_NAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAPPLOCK_MODE(ctx *APPLOCK_MODEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAPPLOCK_TEST(ctx *APPLOCK_TESTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitASSEMBLYPROPERTY(ctx *ASSEMBLYPROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCOL_LENGTH(ctx *COL_LENGTHContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCOL_NAME(ctx *COL_NAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCOLUMNPROPERTY(ctx *COLUMNPROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATABASEPROPERTYEX(ctx *DATABASEPROPERTYEXContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDB_ID(ctx *DB_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDB_NAME(ctx *DB_NAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFILE_ID(ctx *FILE_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFILE_IDEX(ctx *FILE_IDEXContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFILE_NAME(ctx *FILE_NAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFILEGROUP_ID(ctx *FILEGROUP_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFILEGROUP_NAME(ctx *FILEGROUP_NAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFILEGROUPPROPERTY(ctx *FILEGROUPPROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFILEPROPERTY(ctx *FILEPROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFILEPROPERTYEX(ctx *FILEPROPERTYEXContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFULLTEXTCATALOGPROPERTY(ctx *FULLTEXTCATALOGPROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFULLTEXTSERVICEPROPERTY(ctx *FULLTEXTSERVICEPROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitINDEX_COL(ctx *INDEX_COLContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitINDEXKEY_PROPERTY(ctx *INDEXKEY_PROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitINDEXPROPERTY(ctx *INDEXPROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitNEXT_VALUE_FOR(ctx *NEXT_VALUE_FORContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOBJECT_DEFINITION(ctx *OBJECT_DEFINITIONContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOBJECT_ID(ctx *OBJECT_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOBJECT_NAME(ctx *OBJECT_NAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOBJECT_SCHEMA_NAME(ctx *OBJECT_SCHEMA_NAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOBJECTPROPERTY(ctx *OBJECTPROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOBJECTPROPERTYEX(ctx *OBJECTPROPERTYEXContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitORIGINAL_DB_NAME(ctx *ORIGINAL_DB_NAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPARSENAME(ctx *PARSENAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSCHEMA_ID(ctx *SCHEMA_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSCHEMA_NAME(ctx *SCHEMA_NAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSCOPE_IDENTITY(ctx *SCOPE_IDENTITYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSERVERPROPERTY(ctx *SERVERPROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSTATS_DATE(ctx *STATS_DATEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTYPE_ID(ctx *TYPE_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTYPE_NAME(ctx *TYPE_NAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTYPEPROPERTY(ctx *TYPEPROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitASCII(ctx *ASCIIContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCHAR(ctx *CHARContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCHARINDEX(ctx *CHARINDEXContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCONCAT(ctx *CONCATContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCONCAT_WS(ctx *CONCAT_WSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDIFFERENCE(ctx *DIFFERENCEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFORMAT(ctx *FORMATContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitLEFT(ctx *LEFTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitLEN(ctx *LENContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitLOWER(ctx *LOWERContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitLTRIM(ctx *LTRIMContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitNCHAR(ctx *NCHARContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPATINDEX(ctx *PATINDEXContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitQUOTENAME(ctx *QUOTENAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitREPLACE(ctx *REPLACEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitREPLICATE(ctx *REPLICATEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitREVERSE(ctx *REVERSEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRIGHT(ctx *RIGHTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRTRIM(ctx *RTRIMContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSOUNDEX(ctx *SOUNDEXContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSPACE(ctx *SPACEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSTR(ctx *STRContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSTRINGAGG(ctx *STRINGAGGContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSTRING_ESCAPE(ctx *STRING_ESCAPEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSTUFF(ctx *STUFFContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSUBSTRING(ctx *SUBSTRINGContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTRANSLATE(ctx *TRANSLATEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTRIM(ctx *TRIMContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUNICODE(ctx *UNICODEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUPPER(ctx *UPPERContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBINARY_CHECKSUM(ctx *BINARY_CHECKSUMContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCHECKSUM(ctx *CHECKSUMContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCOMPRESS(ctx *COMPRESSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCONNECTIONPROPERTY(ctx *CONNECTIONPROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCONTEXT_INFO(ctx *CONTEXT_INFOContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCURRENT_REQUEST_ID(ctx *CURRENT_REQUEST_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCURRENT_TRANSACTION_ID(ctx *CURRENT_TRANSACTION_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDECOMPRESS(ctx *DECOMPRESSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitERROR_LINE(ctx *ERROR_LINEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitERROR_MESSAGE(ctx *ERROR_MESSAGEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitERROR_NUMBER(ctx *ERROR_NUMBERContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitERROR_PROCEDURE(ctx *ERROR_PROCEDUREContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitERROR_SEVERITY(ctx *ERROR_SEVERITYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitERROR_STATE(ctx *ERROR_STATEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFORMATMESSAGE(ctx *FORMATMESSAGEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitGET_FILESTREAM_TRANSACTION_CONTEXT(ctx *GET_FILESTREAM_TRANSACTION_CONTEXTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitGETANSINULL(ctx *GETANSINULLContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitHOST_ID(ctx *HOST_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitHOST_NAME(ctx *HOST_NAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitISNULL(ctx *ISNULLContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitISNUMERIC(ctx *ISNUMERICContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMIN_ACTIVE_ROWVERSION(ctx *MIN_ACTIVE_ROWVERSIONContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitNEWID(ctx *NEWIDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitNEWSEQUENTIALID(ctx *NEWSEQUENTIALIDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitROWCOUNT_BIG(ctx *ROWCOUNT_BIGContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSESSION_CONTEXT(ctx *SESSION_CONTEXTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitXACT_STATE(ctx *XACT_STATEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCAST(ctx *CASTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTRY_CAST(ctx *TRY_CASTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCONVERT(ctx *CONVERTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCOALESCE(ctx *COALESCEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCURSOR_ROWS(ctx *CURSOR_ROWSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFETCH_STATUS(ctx *FETCH_STATUSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCURSOR_STATUS(ctx *CURSOR_STATUSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCERT_ID(ctx *CERT_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATALENGTH(ctx *DATALENGTHContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitIDENT_CURRENT(ctx *IDENT_CURRENTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitIDENT_INCR(ctx *IDENT_INCRContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitIDENT_SEED(ctx *IDENT_SEEDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitIDENTITY(ctx *IDENTITYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSQL_VARIANT_PROPERTY(ctx *SQL_VARIANT_PROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCURRENT_DATE(ctx *CURRENT_DATEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCURRENT_TIMESTAMP(ctx *CURRENT_TIMESTAMPContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCURRENT_TIMEZONE(ctx *CURRENT_TIMEZONEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCURRENT_TIMEZONE_ID(ctx *CURRENT_TIMEZONE_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATE_BUCKET(ctx *DATE_BUCKETContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATEADD(ctx *DATEADDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATEDIFF(ctx *DATEDIFFContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATEDIFF_BIG(ctx *DATEDIFF_BIGContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATEFROMPARTS(ctx *DATEFROMPARTSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATENAME(ctx *DATENAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATEPART(ctx *DATEPARTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATETIME2FROMPARTS(ctx *DATETIME2FROMPARTSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATETIMEFROMPARTS(ctx *DATETIMEFROMPARTSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATETIMEOFFSETFROMPARTS(ctx *DATETIMEOFFSETFROMPARTSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATETRUNC(ctx *DATETRUNCContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDAY(ctx *DAYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEOMONTH(ctx *EOMONTHContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitGETDATE(ctx *GETDATEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitGETUTCDATE(ctx *GETUTCDATEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitISDATE(ctx *ISDATEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMONTH(ctx *MONTHContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSMALLDATETIMEFROMPARTS(ctx *SMALLDATETIMEFROMPARTSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSWITCHOFFSET(ctx *SWITCHOFFSETContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSYSDATETIME(ctx *SYSDATETIMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSYSDATETIMEOFFSET(ctx *SYSDATETIMEOFFSETContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSYSUTCDATETIME(ctx *SYSUTCDATETIMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTIMEFROMPARTS(ctx *TIMEFROMPARTSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTODATETIMEOFFSET(ctx *TODATETIMEOFFSETContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitYEAR(ctx *YEARContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitNULLIF(ctx *NULLIFContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPARSE(ctx *PARSEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitXML_DATA_TYPE_FUNC(ctx *XML_DATA_TYPE_FUNCContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitIIF(ctx *IIFContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitISJSON(ctx *ISJSONContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitJSON_OBJECT(ctx *JSON_OBJECTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitJSON_ARRAY(ctx *JSON_ARRAYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitJSON_VALUE(ctx *JSON_VALUEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitJSON_QUERY(ctx *JSON_QUERYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitJSON_MODIFY(ctx *JSON_MODIFYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitJSON_PATH_EXISTS(ctx *JSON_PATH_EXISTSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitABS(ctx *ABSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitACOS(ctx *ACOSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitASIN(ctx *ASINContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitATAN(ctx *ATANContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitATN2(ctx *ATN2Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCEILING(ctx *CEILINGContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCOS(ctx *COSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCOT(ctx *COTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDEGREES(ctx *DEGREESContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEXP(ctx *EXPContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFLOOR(ctx *FLOORContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitLOG(ctx *LOGContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitLOG10(ctx *LOG10Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPI(ctx *PIContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPOWER(ctx *POWERContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRADIANS(ctx *RADIANSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRAND(ctx *RANDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitROUND(ctx *ROUNDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitMATH_SIGN(ctx *MATH_SIGNContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSIN(ctx *SINContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSQRT(ctx *SQRTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSQUARE(ctx *SQUAREContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTAN(ctx *TANContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitGREATEST(ctx *GREATESTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitLEAST(ctx *LEASTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCERTENCODED(ctx *CERTENCODEDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCERTPRIVATEKEY(ctx *CERTPRIVATEKEYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCURRENT_USER(ctx *CURRENT_USERContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDATABASE_PRINCIPAL_ID(ctx *DATABASE_PRINCIPAL_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitHAS_DBACCESS(ctx *HAS_DBACCESSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitHAS_PERMS_BY_NAME(ctx *HAS_PERMS_BY_NAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitIS_MEMBER(ctx *IS_MEMBERContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitIS_ROLEMEMBER(ctx *IS_ROLEMEMBERContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitIS_SRVROLEMEMBER(ctx *IS_SRVROLEMEMBERContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitLOGINPROPERTY(ctx *LOGINPROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitORIGINAL_LOGIN(ctx *ORIGINAL_LOGINContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPERMISSIONS(ctx *PERMISSIONSContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPWDENCRYPT(ctx *PWDENCRYPTContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPWDCOMPARE(ctx *PWDCOMPAREContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSESSION_USER(ctx *SESSION_USERContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSESSIONPROPERTY(ctx *SESSIONPROPERTYContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSUSER_ID(ctx *SUSER_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSUSER_SNAME(ctx *SUSER_SNAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSUSER_SID(ctx *SUSER_SIDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSYSTEM_USER(ctx *SYSTEM_USERContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUSER(ctx *USERContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUSER_ID(ctx *USER_IDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitUSER_NAME(ctx *USER_NAMEContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitXml_data_type_methods(ctx *Xml_data_type_methodsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDateparts_9(ctx *Dateparts_9Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDateparts_12(ctx *Dateparts_12Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDateparts_15(ctx *Dateparts_15Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDateparts_datetrunc(ctx *Dateparts_datetruncContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitValue_method(ctx *Value_methodContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitValue_call(ctx *Value_callContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitQuery_method(ctx *Query_methodContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitQuery_call(ctx *Query_callContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExist_method(ctx *Exist_methodContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExist_call(ctx *Exist_callContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitModify_method(ctx *Modify_methodContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitModify_call(ctx *Modify_callContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitHierarchyid_call(ctx *Hierarchyid_callContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitHierarchyid_static_method(ctx *Hierarchyid_static_methodContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitNodes_method(ctx *Nodes_methodContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSwitch_section(ctx *Switch_sectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSwitch_search_condition_section(ctx *Switch_search_condition_sectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAs_column_alias(ctx *As_column_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAs_table_alias(ctx *As_table_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTable_alias(ctx *Table_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitWith_table_hints(ctx *With_table_hintsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDeprecated_table_hint(ctx *Deprecated_table_hintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSybase_legacy_hints(ctx *Sybase_legacy_hintsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSybase_legacy_hint(ctx *Sybase_legacy_hintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTable_hint(ctx *Table_hintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitIndex_value(ctx *Index_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumn_alias_list(ctx *Column_alias_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumn_alias(ctx *Column_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTable_value_constructor(ctx *Table_value_constructorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitExpression_list_(ctx *Expression_list_Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRanking_windowed_function(ctx *Ranking_windowed_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAggregate_windowed_function(ctx *Aggregate_windowed_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAnalytic_windowed_function(ctx *Analytic_windowed_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAll_distinct_expression(ctx *All_distinct_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOver_clause(ctx *Over_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitRow_or_range_clause(ctx *Row_or_range_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitWindow_frame_extent(ctx *Window_frame_extentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitWindow_frame_bound(ctx *Window_frame_boundContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitWindow_frame_preceding(ctx *Window_frame_precedingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitWindow_frame_following(ctx *Window_frame_followingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCreate_database_option(ctx *Create_database_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDatabase_filestream_option(ctx *Database_filestream_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDatabase_file_spec(ctx *Database_file_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFile_group(ctx *File_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFile_spec(ctx *File_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEntity_name(ctx *Entity_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEntity_name_for_azure_dw(ctx *Entity_name_for_azure_dwContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEntity_name_for_parallel_dw(ctx *Entity_name_for_parallel_dwContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFull_table_name(ctx *Full_table_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDotID(ctx *DotIDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDoubleDotID(ctx *DoubleDotIDContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitTable_name(ctx *Table_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSimple_name(ctx *Simple_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFunc_proc_name_schema(ctx *Func_proc_name_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFunc_proc_name_database_schema(ctx *Func_proc_name_database_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFunc_proc_name_server_database_schema(ctx *Func_proc_name_server_database_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitDdl_object(ctx *Ddl_objectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFull_column_name(ctx *Full_column_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumn_name_list_with_order(ctx *Column_name_list_with_orderContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumn_name_with_order(ctx *Column_name_with_orderContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitInsert_column_name_list(ctx *Insert_column_name_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitInsert_column_id(ctx *Insert_column_idContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitColumn_name_list(ctx *Column_name_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitCursor_name(ctx *Cursor_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitOn_off(ctx *On_offContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitClustered(ctx *ClusteredContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitNull_notnull(ctx *Null_notnullContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitScalar_function_name(ctx *Scalar_function_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBegin_conversation_timer(ctx *Begin_conversation_timerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitBegin_conversation_dialog(ctx *Begin_conversation_dialogContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitContract_name(ctx *Contract_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitService_name(ctx *Service_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitEnd_conversation(ctx *End_conversationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitWaitfor_conversation(ctx *Waitfor_conversationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitGet_conversation(ctx *Get_conversationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitQueue_id(ctx *Queue_idContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSend_conversation(ctx *Send_conversationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitData_type(ctx *Data_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitConstant(ctx *ConstantContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitPrimitive_constant(ctx *Primitive_constantContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitKeyword(ctx *KeywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitId_(ctx *Id_Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitSimple_id(ctx *Simple_idContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitId_or_string(ctx *Id_or_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitComparison_operator(ctx *Comparison_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitAssignment_operator(ctx *Assignment_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseTSqlParserVisitor) VisitFile_size(ctx *File_sizeContext) interface{} { + return v.VisitChildren(ctx) +} diff --git a/tsql/tsqlparser_listener.go b/tsql/tsqlparser_listener.go new file mode 100644 index 0000000..f59a191 --- /dev/null +++ b/tsql/tsqlparser_listener.go @@ -0,0 +1,4965 @@ +// Code generated from TSqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package tsql // TSqlParser +import "github.com/antlr4-go/antlr/v4" + +// TSqlParserListener is a complete listener for a parse tree produced by TSqlParser. +type TSqlParserListener interface { + antlr.ParseTreeListener + + // EnterTsql_file is called when entering the tsql_file production. + EnterTsql_file(c *Tsql_fileContext) + + // EnterBatch_without_go is called when entering the batch_without_go production. + EnterBatch_without_go(c *Batch_without_goContext) + + // EnterBatch_level_statement is called when entering the batch_level_statement production. + EnterBatch_level_statement(c *Batch_level_statementContext) + + // EnterSql_clauses is called when entering the sql_clauses production. + EnterSql_clauses(c *Sql_clausesContext) + + // EnterDml_clause is called when entering the dml_clause production. + EnterDml_clause(c *Dml_clauseContext) + + // EnterDdl_clause is called when entering the ddl_clause production. + EnterDdl_clause(c *Ddl_clauseContext) + + // EnterBackup_statement is called when entering the backup_statement production. + EnterBackup_statement(c *Backup_statementContext) + + // EnterCfl_statement is called when entering the cfl_statement production. + EnterCfl_statement(c *Cfl_statementContext) + + // EnterBlock_statement is called when entering the block_statement production. + EnterBlock_statement(c *Block_statementContext) + + // EnterBreak_statement is called when entering the break_statement production. + EnterBreak_statement(c *Break_statementContext) + + // EnterContinue_statement is called when entering the continue_statement production. + EnterContinue_statement(c *Continue_statementContext) + + // EnterGoto_statement is called when entering the goto_statement production. + EnterGoto_statement(c *Goto_statementContext) + + // EnterReturn_statement is called when entering the return_statement production. + EnterReturn_statement(c *Return_statementContext) + + // EnterIf_statement is called when entering the if_statement production. + EnterIf_statement(c *If_statementContext) + + // EnterThrow_statement is called when entering the throw_statement production. + EnterThrow_statement(c *Throw_statementContext) + + // EnterThrow_error_number is called when entering the throw_error_number production. + EnterThrow_error_number(c *Throw_error_numberContext) + + // EnterThrow_message is called when entering the throw_message production. + EnterThrow_message(c *Throw_messageContext) + + // EnterThrow_state is called when entering the throw_state production. + EnterThrow_state(c *Throw_stateContext) + + // EnterTry_catch_statement is called when entering the try_catch_statement production. + EnterTry_catch_statement(c *Try_catch_statementContext) + + // EnterWaitfor_statement is called when entering the waitfor_statement production. + EnterWaitfor_statement(c *Waitfor_statementContext) + + // EnterWhile_statement is called when entering the while_statement production. + EnterWhile_statement(c *While_statementContext) + + // EnterPrint_statement is called when entering the print_statement production. + EnterPrint_statement(c *Print_statementContext) + + // EnterRaiseerror_statement is called when entering the raiseerror_statement production. + EnterRaiseerror_statement(c *Raiseerror_statementContext) + + // EnterEmpty_statement is called when entering the empty_statement production. + EnterEmpty_statement(c *Empty_statementContext) + + // EnterAnother_statement is called when entering the another_statement production. + EnterAnother_statement(c *Another_statementContext) + + // EnterAlter_application_role is called when entering the alter_application_role production. + EnterAlter_application_role(c *Alter_application_roleContext) + + // EnterAlter_xml_schema_collection is called when entering the alter_xml_schema_collection production. + EnterAlter_xml_schema_collection(c *Alter_xml_schema_collectionContext) + + // EnterCreate_application_role is called when entering the create_application_role production. + EnterCreate_application_role(c *Create_application_roleContext) + + // EnterDrop_aggregate is called when entering the drop_aggregate production. + EnterDrop_aggregate(c *Drop_aggregateContext) + + // EnterDrop_application_role is called when entering the drop_application_role production. + EnterDrop_application_role(c *Drop_application_roleContext) + + // EnterAlter_assembly is called when entering the alter_assembly production. + EnterAlter_assembly(c *Alter_assemblyContext) + + // EnterAlter_assembly_start is called when entering the alter_assembly_start production. + EnterAlter_assembly_start(c *Alter_assembly_startContext) + + // EnterAlter_assembly_clause is called when entering the alter_assembly_clause production. + EnterAlter_assembly_clause(c *Alter_assembly_clauseContext) + + // EnterAlter_assembly_from_clause is called when entering the alter_assembly_from_clause production. + EnterAlter_assembly_from_clause(c *Alter_assembly_from_clauseContext) + + // EnterAlter_assembly_from_clause_start is called when entering the alter_assembly_from_clause_start production. + EnterAlter_assembly_from_clause_start(c *Alter_assembly_from_clause_startContext) + + // EnterAlter_assembly_drop_clause is called when entering the alter_assembly_drop_clause production. + EnterAlter_assembly_drop_clause(c *Alter_assembly_drop_clauseContext) + + // EnterAlter_assembly_drop_multiple_files is called when entering the alter_assembly_drop_multiple_files production. + EnterAlter_assembly_drop_multiple_files(c *Alter_assembly_drop_multiple_filesContext) + + // EnterAlter_assembly_drop is called when entering the alter_assembly_drop production. + EnterAlter_assembly_drop(c *Alter_assembly_dropContext) + + // EnterAlter_assembly_add_clause is called when entering the alter_assembly_add_clause production. + EnterAlter_assembly_add_clause(c *Alter_assembly_add_clauseContext) + + // EnterAlter_asssembly_add_clause_start is called when entering the alter_asssembly_add_clause_start production. + EnterAlter_asssembly_add_clause_start(c *Alter_asssembly_add_clause_startContext) + + // EnterAlter_assembly_client_file_clause is called when entering the alter_assembly_client_file_clause production. + EnterAlter_assembly_client_file_clause(c *Alter_assembly_client_file_clauseContext) + + // EnterAlter_assembly_file_name is called when entering the alter_assembly_file_name production. + EnterAlter_assembly_file_name(c *Alter_assembly_file_nameContext) + + // EnterAlter_assembly_file_bits is called when entering the alter_assembly_file_bits production. + EnterAlter_assembly_file_bits(c *Alter_assembly_file_bitsContext) + + // EnterAlter_assembly_as is called when entering the alter_assembly_as production. + EnterAlter_assembly_as(c *Alter_assembly_asContext) + + // EnterAlter_assembly_with_clause is called when entering the alter_assembly_with_clause production. + EnterAlter_assembly_with_clause(c *Alter_assembly_with_clauseContext) + + // EnterAlter_assembly_with is called when entering the alter_assembly_with production. + EnterAlter_assembly_with(c *Alter_assembly_withContext) + + // EnterClient_assembly_specifier is called when entering the client_assembly_specifier production. + EnterClient_assembly_specifier(c *Client_assembly_specifierContext) + + // EnterAssembly_option is called when entering the assembly_option production. + EnterAssembly_option(c *Assembly_optionContext) + + // EnterNetwork_file_share is called when entering the network_file_share production. + EnterNetwork_file_share(c *Network_file_shareContext) + + // EnterNetwork_computer is called when entering the network_computer production. + EnterNetwork_computer(c *Network_computerContext) + + // EnterNetwork_file_start is called when entering the network_file_start production. + EnterNetwork_file_start(c *Network_file_startContext) + + // EnterFile_path is called when entering the file_path production. + EnterFile_path(c *File_pathContext) + + // EnterFile_directory_path_separator is called when entering the file_directory_path_separator production. + EnterFile_directory_path_separator(c *File_directory_path_separatorContext) + + // EnterLocal_file is called when entering the local_file production. + EnterLocal_file(c *Local_fileContext) + + // EnterLocal_drive is called when entering the local_drive production. + EnterLocal_drive(c *Local_driveContext) + + // EnterMultiple_local_files is called when entering the multiple_local_files production. + EnterMultiple_local_files(c *Multiple_local_filesContext) + + // EnterMultiple_local_file_start is called when entering the multiple_local_file_start production. + EnterMultiple_local_file_start(c *Multiple_local_file_startContext) + + // EnterCreate_assembly is called when entering the create_assembly production. + EnterCreate_assembly(c *Create_assemblyContext) + + // EnterDrop_assembly is called when entering the drop_assembly production. + EnterDrop_assembly(c *Drop_assemblyContext) + + // EnterAlter_asymmetric_key is called when entering the alter_asymmetric_key production. + EnterAlter_asymmetric_key(c *Alter_asymmetric_keyContext) + + // EnterAlter_asymmetric_key_start is called when entering the alter_asymmetric_key_start production. + EnterAlter_asymmetric_key_start(c *Alter_asymmetric_key_startContext) + + // EnterAsymmetric_key_option is called when entering the asymmetric_key_option production. + EnterAsymmetric_key_option(c *Asymmetric_key_optionContext) + + // EnterAsymmetric_key_option_start is called when entering the asymmetric_key_option_start production. + EnterAsymmetric_key_option_start(c *Asymmetric_key_option_startContext) + + // EnterAsymmetric_key_password_change_option is called when entering the asymmetric_key_password_change_option production. + EnterAsymmetric_key_password_change_option(c *Asymmetric_key_password_change_optionContext) + + // EnterCreate_asymmetric_key is called when entering the create_asymmetric_key production. + EnterCreate_asymmetric_key(c *Create_asymmetric_keyContext) + + // EnterDrop_asymmetric_key is called when entering the drop_asymmetric_key production. + EnterDrop_asymmetric_key(c *Drop_asymmetric_keyContext) + + // EnterAlter_authorization is called when entering the alter_authorization production. + EnterAlter_authorization(c *Alter_authorizationContext) + + // EnterAuthorization_grantee is called when entering the authorization_grantee production. + EnterAuthorization_grantee(c *Authorization_granteeContext) + + // EnterEntity_to is called when entering the entity_to production. + EnterEntity_to(c *Entity_toContext) + + // EnterColon_colon is called when entering the colon_colon production. + EnterColon_colon(c *Colon_colonContext) + + // EnterAlter_authorization_start is called when entering the alter_authorization_start production. + EnterAlter_authorization_start(c *Alter_authorization_startContext) + + // EnterAlter_authorization_for_sql_database is called when entering the alter_authorization_for_sql_database production. + EnterAlter_authorization_for_sql_database(c *Alter_authorization_for_sql_databaseContext) + + // EnterAlter_authorization_for_azure_dw is called when entering the alter_authorization_for_azure_dw production. + EnterAlter_authorization_for_azure_dw(c *Alter_authorization_for_azure_dwContext) + + // EnterAlter_authorization_for_parallel_dw is called when entering the alter_authorization_for_parallel_dw production. + EnterAlter_authorization_for_parallel_dw(c *Alter_authorization_for_parallel_dwContext) + + // EnterClass_type is called when entering the class_type production. + EnterClass_type(c *Class_typeContext) + + // EnterClass_type_for_sql_database is called when entering the class_type_for_sql_database production. + EnterClass_type_for_sql_database(c *Class_type_for_sql_databaseContext) + + // EnterClass_type_for_azure_dw is called when entering the class_type_for_azure_dw production. + EnterClass_type_for_azure_dw(c *Class_type_for_azure_dwContext) + + // EnterClass_type_for_parallel_dw is called when entering the class_type_for_parallel_dw production. + EnterClass_type_for_parallel_dw(c *Class_type_for_parallel_dwContext) + + // EnterClass_type_for_grant is called when entering the class_type_for_grant production. + EnterClass_type_for_grant(c *Class_type_for_grantContext) + + // EnterDrop_availability_group is called when entering the drop_availability_group production. + EnterDrop_availability_group(c *Drop_availability_groupContext) + + // EnterAlter_availability_group is called when entering the alter_availability_group production. + EnterAlter_availability_group(c *Alter_availability_groupContext) + + // EnterAlter_availability_group_start is called when entering the alter_availability_group_start production. + EnterAlter_availability_group_start(c *Alter_availability_group_startContext) + + // EnterAlter_availability_group_options is called when entering the alter_availability_group_options production. + EnterAlter_availability_group_options(c *Alter_availability_group_optionsContext) + + // EnterIp_v4_failover is called when entering the ip_v4_failover production. + EnterIp_v4_failover(c *Ip_v4_failoverContext) + + // EnterIp_v6_failover is called when entering the ip_v6_failover production. + EnterIp_v6_failover(c *Ip_v6_failoverContext) + + // EnterCreate_or_alter_broker_priority is called when entering the create_or_alter_broker_priority production. + EnterCreate_or_alter_broker_priority(c *Create_or_alter_broker_priorityContext) + + // EnterDrop_broker_priority is called when entering the drop_broker_priority production. + EnterDrop_broker_priority(c *Drop_broker_priorityContext) + + // EnterAlter_certificate is called when entering the alter_certificate production. + EnterAlter_certificate(c *Alter_certificateContext) + + // EnterAlter_column_encryption_key is called when entering the alter_column_encryption_key production. + EnterAlter_column_encryption_key(c *Alter_column_encryption_keyContext) + + // EnterCreate_column_encryption_key is called when entering the create_column_encryption_key production. + EnterCreate_column_encryption_key(c *Create_column_encryption_keyContext) + + // EnterDrop_certificate is called when entering the drop_certificate production. + EnterDrop_certificate(c *Drop_certificateContext) + + // EnterDrop_column_encryption_key is called when entering the drop_column_encryption_key production. + EnterDrop_column_encryption_key(c *Drop_column_encryption_keyContext) + + // EnterDrop_column_master_key is called when entering the drop_column_master_key production. + EnterDrop_column_master_key(c *Drop_column_master_keyContext) + + // EnterDrop_contract is called when entering the drop_contract production. + EnterDrop_contract(c *Drop_contractContext) + + // EnterDrop_credential is called when entering the drop_credential production. + EnterDrop_credential(c *Drop_credentialContext) + + // EnterDrop_cryptograhic_provider is called when entering the drop_cryptograhic_provider production. + EnterDrop_cryptograhic_provider(c *Drop_cryptograhic_providerContext) + + // EnterDrop_database is called when entering the drop_database production. + EnterDrop_database(c *Drop_databaseContext) + + // EnterDrop_database_audit_specification is called when entering the drop_database_audit_specification production. + EnterDrop_database_audit_specification(c *Drop_database_audit_specificationContext) + + // EnterDrop_database_encryption_key is called when entering the drop_database_encryption_key production. + EnterDrop_database_encryption_key(c *Drop_database_encryption_keyContext) + + // EnterDrop_database_scoped_credential is called when entering the drop_database_scoped_credential production. + EnterDrop_database_scoped_credential(c *Drop_database_scoped_credentialContext) + + // EnterDrop_default is called when entering the drop_default production. + EnterDrop_default(c *Drop_defaultContext) + + // EnterDrop_endpoint is called when entering the drop_endpoint production. + EnterDrop_endpoint(c *Drop_endpointContext) + + // EnterDrop_external_data_source is called when entering the drop_external_data_source production. + EnterDrop_external_data_source(c *Drop_external_data_sourceContext) + + // EnterDrop_external_file_format is called when entering the drop_external_file_format production. + EnterDrop_external_file_format(c *Drop_external_file_formatContext) + + // EnterDrop_external_library is called when entering the drop_external_library production. + EnterDrop_external_library(c *Drop_external_libraryContext) + + // EnterDrop_external_resource_pool is called when entering the drop_external_resource_pool production. + EnterDrop_external_resource_pool(c *Drop_external_resource_poolContext) + + // EnterDrop_external_table is called when entering the drop_external_table production. + EnterDrop_external_table(c *Drop_external_tableContext) + + // EnterDrop_event_notifications is called when entering the drop_event_notifications production. + EnterDrop_event_notifications(c *Drop_event_notificationsContext) + + // EnterDrop_event_session is called when entering the drop_event_session production. + EnterDrop_event_session(c *Drop_event_sessionContext) + + // EnterDrop_fulltext_catalog is called when entering the drop_fulltext_catalog production. + EnterDrop_fulltext_catalog(c *Drop_fulltext_catalogContext) + + // EnterDrop_fulltext_index is called when entering the drop_fulltext_index production. + EnterDrop_fulltext_index(c *Drop_fulltext_indexContext) + + // EnterDrop_fulltext_stoplist is called when entering the drop_fulltext_stoplist production. + EnterDrop_fulltext_stoplist(c *Drop_fulltext_stoplistContext) + + // EnterDrop_login is called when entering the drop_login production. + EnterDrop_login(c *Drop_loginContext) + + // EnterDrop_master_key is called when entering the drop_master_key production. + EnterDrop_master_key(c *Drop_master_keyContext) + + // EnterDrop_message_type is called when entering the drop_message_type production. + EnterDrop_message_type(c *Drop_message_typeContext) + + // EnterDrop_partition_function is called when entering the drop_partition_function production. + EnterDrop_partition_function(c *Drop_partition_functionContext) + + // EnterDrop_partition_scheme is called when entering the drop_partition_scheme production. + EnterDrop_partition_scheme(c *Drop_partition_schemeContext) + + // EnterDrop_queue is called when entering the drop_queue production. + EnterDrop_queue(c *Drop_queueContext) + + // EnterDrop_remote_service_binding is called when entering the drop_remote_service_binding production. + EnterDrop_remote_service_binding(c *Drop_remote_service_bindingContext) + + // EnterDrop_resource_pool is called when entering the drop_resource_pool production. + EnterDrop_resource_pool(c *Drop_resource_poolContext) + + // EnterDrop_db_role is called when entering the drop_db_role production. + EnterDrop_db_role(c *Drop_db_roleContext) + + // EnterDrop_route is called when entering the drop_route production. + EnterDrop_route(c *Drop_routeContext) + + // EnterDrop_rule is called when entering the drop_rule production. + EnterDrop_rule(c *Drop_ruleContext) + + // EnterDrop_schema is called when entering the drop_schema production. + EnterDrop_schema(c *Drop_schemaContext) + + // EnterDrop_search_property_list is called when entering the drop_search_property_list production. + EnterDrop_search_property_list(c *Drop_search_property_listContext) + + // EnterDrop_security_policy is called when entering the drop_security_policy production. + EnterDrop_security_policy(c *Drop_security_policyContext) + + // EnterDrop_sequence is called when entering the drop_sequence production. + EnterDrop_sequence(c *Drop_sequenceContext) + + // EnterDrop_server_audit is called when entering the drop_server_audit production. + EnterDrop_server_audit(c *Drop_server_auditContext) + + // EnterDrop_server_audit_specification is called when entering the drop_server_audit_specification production. + EnterDrop_server_audit_specification(c *Drop_server_audit_specificationContext) + + // EnterDrop_server_role is called when entering the drop_server_role production. + EnterDrop_server_role(c *Drop_server_roleContext) + + // EnterDrop_service is called when entering the drop_service production. + EnterDrop_service(c *Drop_serviceContext) + + // EnterDrop_signature is called when entering the drop_signature production. + EnterDrop_signature(c *Drop_signatureContext) + + // EnterDrop_statistics_name_azure_dw_and_pdw is called when entering the drop_statistics_name_azure_dw_and_pdw production. + EnterDrop_statistics_name_azure_dw_and_pdw(c *Drop_statistics_name_azure_dw_and_pdwContext) + + // EnterDrop_symmetric_key is called when entering the drop_symmetric_key production. + EnterDrop_symmetric_key(c *Drop_symmetric_keyContext) + + // EnterDrop_synonym is called when entering the drop_synonym production. + EnterDrop_synonym(c *Drop_synonymContext) + + // EnterDrop_user is called when entering the drop_user production. + EnterDrop_user(c *Drop_userContext) + + // EnterDrop_workload_group is called when entering the drop_workload_group production. + EnterDrop_workload_group(c *Drop_workload_groupContext) + + // EnterDrop_xml_schema_collection is called when entering the drop_xml_schema_collection production. + EnterDrop_xml_schema_collection(c *Drop_xml_schema_collectionContext) + + // EnterDisable_trigger is called when entering the disable_trigger production. + EnterDisable_trigger(c *Disable_triggerContext) + + // EnterEnable_trigger is called when entering the enable_trigger production. + EnterEnable_trigger(c *Enable_triggerContext) + + // EnterLock_table is called when entering the lock_table production. + EnterLock_table(c *Lock_tableContext) + + // EnterTruncate_table is called when entering the truncate_table production. + EnterTruncate_table(c *Truncate_tableContext) + + // EnterCreate_column_master_key is called when entering the create_column_master_key production. + EnterCreate_column_master_key(c *Create_column_master_keyContext) + + // EnterAlter_credential is called when entering the alter_credential production. + EnterAlter_credential(c *Alter_credentialContext) + + // EnterCreate_credential is called when entering the create_credential production. + EnterCreate_credential(c *Create_credentialContext) + + // EnterAlter_cryptographic_provider is called when entering the alter_cryptographic_provider production. + EnterAlter_cryptographic_provider(c *Alter_cryptographic_providerContext) + + // EnterCreate_cryptographic_provider is called when entering the create_cryptographic_provider production. + EnterCreate_cryptographic_provider(c *Create_cryptographic_providerContext) + + // EnterCreate_endpoint is called when entering the create_endpoint production. + EnterCreate_endpoint(c *Create_endpointContext) + + // EnterEndpoint_encryption_alogorithm_clause is called when entering the endpoint_encryption_alogorithm_clause production. + EnterEndpoint_encryption_alogorithm_clause(c *Endpoint_encryption_alogorithm_clauseContext) + + // EnterEndpoint_authentication_clause is called when entering the endpoint_authentication_clause production. + EnterEndpoint_authentication_clause(c *Endpoint_authentication_clauseContext) + + // EnterEndpoint_listener_clause is called when entering the endpoint_listener_clause production. + EnterEndpoint_listener_clause(c *Endpoint_listener_clauseContext) + + // EnterCreate_event_notification is called when entering the create_event_notification production. + EnterCreate_event_notification(c *Create_event_notificationContext) + + // EnterCreate_or_alter_event_session is called when entering the create_or_alter_event_session production. + EnterCreate_or_alter_event_session(c *Create_or_alter_event_sessionContext) + + // EnterEvent_session_predicate_expression is called when entering the event_session_predicate_expression production. + EnterEvent_session_predicate_expression(c *Event_session_predicate_expressionContext) + + // EnterEvent_session_predicate_factor is called when entering the event_session_predicate_factor production. + EnterEvent_session_predicate_factor(c *Event_session_predicate_factorContext) + + // EnterEvent_session_predicate_leaf is called when entering the event_session_predicate_leaf production. + EnterEvent_session_predicate_leaf(c *Event_session_predicate_leafContext) + + // EnterAlter_external_data_source is called when entering the alter_external_data_source production. + EnterAlter_external_data_source(c *Alter_external_data_sourceContext) + + // EnterAlter_external_library is called when entering the alter_external_library production. + EnterAlter_external_library(c *Alter_external_libraryContext) + + // EnterCreate_external_library is called when entering the create_external_library production. + EnterCreate_external_library(c *Create_external_libraryContext) + + // EnterAlter_external_resource_pool is called when entering the alter_external_resource_pool production. + EnterAlter_external_resource_pool(c *Alter_external_resource_poolContext) + + // EnterCreate_external_resource_pool is called when entering the create_external_resource_pool production. + EnterCreate_external_resource_pool(c *Create_external_resource_poolContext) + + // EnterAlter_fulltext_catalog is called when entering the alter_fulltext_catalog production. + EnterAlter_fulltext_catalog(c *Alter_fulltext_catalogContext) + + // EnterCreate_fulltext_catalog is called when entering the create_fulltext_catalog production. + EnterCreate_fulltext_catalog(c *Create_fulltext_catalogContext) + + // EnterAlter_fulltext_stoplist is called when entering the alter_fulltext_stoplist production. + EnterAlter_fulltext_stoplist(c *Alter_fulltext_stoplistContext) + + // EnterCreate_fulltext_stoplist is called when entering the create_fulltext_stoplist production. + EnterCreate_fulltext_stoplist(c *Create_fulltext_stoplistContext) + + // EnterAlter_login_sql_server is called when entering the alter_login_sql_server production. + EnterAlter_login_sql_server(c *Alter_login_sql_serverContext) + + // EnterCreate_login_sql_server is called when entering the create_login_sql_server production. + EnterCreate_login_sql_server(c *Create_login_sql_serverContext) + + // EnterAlter_login_azure_sql is called when entering the alter_login_azure_sql production. + EnterAlter_login_azure_sql(c *Alter_login_azure_sqlContext) + + // EnterCreate_login_azure_sql is called when entering the create_login_azure_sql production. + EnterCreate_login_azure_sql(c *Create_login_azure_sqlContext) + + // EnterAlter_login_azure_sql_dw_and_pdw is called when entering the alter_login_azure_sql_dw_and_pdw production. + EnterAlter_login_azure_sql_dw_and_pdw(c *Alter_login_azure_sql_dw_and_pdwContext) + + // EnterCreate_login_pdw is called when entering the create_login_pdw production. + EnterCreate_login_pdw(c *Create_login_pdwContext) + + // EnterAlter_master_key_sql_server is called when entering the alter_master_key_sql_server production. + EnterAlter_master_key_sql_server(c *Alter_master_key_sql_serverContext) + + // EnterCreate_master_key_sql_server is called when entering the create_master_key_sql_server production. + EnterCreate_master_key_sql_server(c *Create_master_key_sql_serverContext) + + // EnterAlter_master_key_azure_sql is called when entering the alter_master_key_azure_sql production. + EnterAlter_master_key_azure_sql(c *Alter_master_key_azure_sqlContext) + + // EnterCreate_master_key_azure_sql is called when entering the create_master_key_azure_sql production. + EnterCreate_master_key_azure_sql(c *Create_master_key_azure_sqlContext) + + // EnterAlter_message_type is called when entering the alter_message_type production. + EnterAlter_message_type(c *Alter_message_typeContext) + + // EnterAlter_partition_function is called when entering the alter_partition_function production. + EnterAlter_partition_function(c *Alter_partition_functionContext) + + // EnterAlter_partition_scheme is called when entering the alter_partition_scheme production. + EnterAlter_partition_scheme(c *Alter_partition_schemeContext) + + // EnterAlter_remote_service_binding is called when entering the alter_remote_service_binding production. + EnterAlter_remote_service_binding(c *Alter_remote_service_bindingContext) + + // EnterCreate_remote_service_binding is called when entering the create_remote_service_binding production. + EnterCreate_remote_service_binding(c *Create_remote_service_bindingContext) + + // EnterCreate_resource_pool is called when entering the create_resource_pool production. + EnterCreate_resource_pool(c *Create_resource_poolContext) + + // EnterAlter_resource_governor is called when entering the alter_resource_governor production. + EnterAlter_resource_governor(c *Alter_resource_governorContext) + + // EnterAlter_database_audit_specification is called when entering the alter_database_audit_specification production. + EnterAlter_database_audit_specification(c *Alter_database_audit_specificationContext) + + // EnterAudit_action_spec_group is called when entering the audit_action_spec_group production. + EnterAudit_action_spec_group(c *Audit_action_spec_groupContext) + + // EnterAudit_action_specification is called when entering the audit_action_specification production. + EnterAudit_action_specification(c *Audit_action_specificationContext) + + // EnterAction_specification is called when entering the action_specification production. + EnterAction_specification(c *Action_specificationContext) + + // EnterAudit_class_name is called when entering the audit_class_name production. + EnterAudit_class_name(c *Audit_class_nameContext) + + // EnterAudit_securable is called when entering the audit_securable production. + EnterAudit_securable(c *Audit_securableContext) + + // EnterAlter_db_role is called when entering the alter_db_role production. + EnterAlter_db_role(c *Alter_db_roleContext) + + // EnterCreate_database_audit_specification is called when entering the create_database_audit_specification production. + EnterCreate_database_audit_specification(c *Create_database_audit_specificationContext) + + // EnterCreate_db_role is called when entering the create_db_role production. + EnterCreate_db_role(c *Create_db_roleContext) + + // EnterCreate_route is called when entering the create_route production. + EnterCreate_route(c *Create_routeContext) + + // EnterCreate_rule is called when entering the create_rule production. + EnterCreate_rule(c *Create_ruleContext) + + // EnterAlter_schema_sql is called when entering the alter_schema_sql production. + EnterAlter_schema_sql(c *Alter_schema_sqlContext) + + // EnterCreate_schema is called when entering the create_schema production. + EnterCreate_schema(c *Create_schemaContext) + + // EnterCreate_schema_azure_sql_dw_and_pdw is called when entering the create_schema_azure_sql_dw_and_pdw production. + EnterCreate_schema_azure_sql_dw_and_pdw(c *Create_schema_azure_sql_dw_and_pdwContext) + + // EnterAlter_schema_azure_sql_dw_and_pdw is called when entering the alter_schema_azure_sql_dw_and_pdw production. + EnterAlter_schema_azure_sql_dw_and_pdw(c *Alter_schema_azure_sql_dw_and_pdwContext) + + // EnterCreate_search_property_list is called when entering the create_search_property_list production. + EnterCreate_search_property_list(c *Create_search_property_listContext) + + // EnterCreate_security_policy is called when entering the create_security_policy production. + EnterCreate_security_policy(c *Create_security_policyContext) + + // EnterAlter_sequence is called when entering the alter_sequence production. + EnterAlter_sequence(c *Alter_sequenceContext) + + // EnterCreate_sequence is called when entering the create_sequence production. + EnterCreate_sequence(c *Create_sequenceContext) + + // EnterAlter_server_audit is called when entering the alter_server_audit production. + EnterAlter_server_audit(c *Alter_server_auditContext) + + // EnterCreate_server_audit is called when entering the create_server_audit production. + EnterCreate_server_audit(c *Create_server_auditContext) + + // EnterAlter_server_audit_specification is called when entering the alter_server_audit_specification production. + EnterAlter_server_audit_specification(c *Alter_server_audit_specificationContext) + + // EnterCreate_server_audit_specification is called when entering the create_server_audit_specification production. + EnterCreate_server_audit_specification(c *Create_server_audit_specificationContext) + + // EnterAlter_server_configuration is called when entering the alter_server_configuration production. + EnterAlter_server_configuration(c *Alter_server_configurationContext) + + // EnterAlter_server_role is called when entering the alter_server_role production. + EnterAlter_server_role(c *Alter_server_roleContext) + + // EnterCreate_server_role is called when entering the create_server_role production. + EnterCreate_server_role(c *Create_server_roleContext) + + // EnterAlter_server_role_pdw is called when entering the alter_server_role_pdw production. + EnterAlter_server_role_pdw(c *Alter_server_role_pdwContext) + + // EnterAlter_service is called when entering the alter_service production. + EnterAlter_service(c *Alter_serviceContext) + + // EnterOpt_arg_clause is called when entering the opt_arg_clause production. + EnterOpt_arg_clause(c *Opt_arg_clauseContext) + + // EnterCreate_service is called when entering the create_service production. + EnterCreate_service(c *Create_serviceContext) + + // EnterAlter_service_master_key is called when entering the alter_service_master_key production. + EnterAlter_service_master_key(c *Alter_service_master_keyContext) + + // EnterAlter_symmetric_key is called when entering the alter_symmetric_key production. + EnterAlter_symmetric_key(c *Alter_symmetric_keyContext) + + // EnterCreate_synonym is called when entering the create_synonym production. + EnterCreate_synonym(c *Create_synonymContext) + + // EnterAlter_user is called when entering the alter_user production. + EnterAlter_user(c *Alter_userContext) + + // EnterCreate_user is called when entering the create_user production. + EnterCreate_user(c *Create_userContext) + + // EnterCreate_user_azure_sql_dw is called when entering the create_user_azure_sql_dw production. + EnterCreate_user_azure_sql_dw(c *Create_user_azure_sql_dwContext) + + // EnterAlter_user_azure_sql is called when entering the alter_user_azure_sql production. + EnterAlter_user_azure_sql(c *Alter_user_azure_sqlContext) + + // EnterAlter_workload_group is called when entering the alter_workload_group production. + EnterAlter_workload_group(c *Alter_workload_groupContext) + + // EnterCreate_workload_group is called when entering the create_workload_group production. + EnterCreate_workload_group(c *Create_workload_groupContext) + + // EnterCreate_xml_schema_collection is called when entering the create_xml_schema_collection production. + EnterCreate_xml_schema_collection(c *Create_xml_schema_collectionContext) + + // EnterCreate_partition_function is called when entering the create_partition_function production. + EnterCreate_partition_function(c *Create_partition_functionContext) + + // EnterCreate_partition_scheme is called when entering the create_partition_scheme production. + EnterCreate_partition_scheme(c *Create_partition_schemeContext) + + // EnterCreate_queue is called when entering the create_queue production. + EnterCreate_queue(c *Create_queueContext) + + // EnterQueue_settings is called when entering the queue_settings production. + EnterQueue_settings(c *Queue_settingsContext) + + // EnterAlter_queue is called when entering the alter_queue production. + EnterAlter_queue(c *Alter_queueContext) + + // EnterQueue_action is called when entering the queue_action production. + EnterQueue_action(c *Queue_actionContext) + + // EnterQueue_rebuild_options is called when entering the queue_rebuild_options production. + EnterQueue_rebuild_options(c *Queue_rebuild_optionsContext) + + // EnterCreate_contract is called when entering the create_contract production. + EnterCreate_contract(c *Create_contractContext) + + // EnterConversation_statement is called when entering the conversation_statement production. + EnterConversation_statement(c *Conversation_statementContext) + + // EnterMessage_statement is called when entering the message_statement production. + EnterMessage_statement(c *Message_statementContext) + + // EnterMerge_statement is called when entering the merge_statement production. + EnterMerge_statement(c *Merge_statementContext) + + // EnterWhen_matches is called when entering the when_matches production. + EnterWhen_matches(c *When_matchesContext) + + // EnterMerge_matched is called when entering the merge_matched production. + EnterMerge_matched(c *Merge_matchedContext) + + // EnterMerge_not_matched is called when entering the merge_not_matched production. + EnterMerge_not_matched(c *Merge_not_matchedContext) + + // EnterDelete_statement is called when entering the delete_statement production. + EnterDelete_statement(c *Delete_statementContext) + + // EnterDelete_statement_from is called when entering the delete_statement_from production. + EnterDelete_statement_from(c *Delete_statement_fromContext) + + // EnterInsert_statement is called when entering the insert_statement production. + EnterInsert_statement(c *Insert_statementContext) + + // EnterInsert_statement_value is called when entering the insert_statement_value production. + EnterInsert_statement_value(c *Insert_statement_valueContext) + + // EnterReceive_statement is called when entering the receive_statement production. + EnterReceive_statement(c *Receive_statementContext) + + // EnterSelect_statement_standalone is called when entering the select_statement_standalone production. + EnterSelect_statement_standalone(c *Select_statement_standaloneContext) + + // EnterSelect_statement is called when entering the select_statement production. + EnterSelect_statement(c *Select_statementContext) + + // EnterTime is called when entering the time production. + EnterTime(c *TimeContext) + + // EnterUpdate_statement is called when entering the update_statement production. + EnterUpdate_statement(c *Update_statementContext) + + // EnterOutput_clause is called when entering the output_clause production. + EnterOutput_clause(c *Output_clauseContext) + + // EnterOutput_dml_list_elem is called when entering the output_dml_list_elem production. + EnterOutput_dml_list_elem(c *Output_dml_list_elemContext) + + // EnterCreate_database is called when entering the create_database production. + EnterCreate_database(c *Create_databaseContext) + + // EnterCreate_index is called when entering the create_index production. + EnterCreate_index(c *Create_indexContext) + + // EnterCreate_spatial_index is called when entering the create_spatial_index production. + EnterCreate_spatial_index(c *Create_spatial_indexContext) + + // EnterSpatial_tessellation_scheme is called when entering the spatial_tessellation_scheme production. + EnterSpatial_tessellation_scheme(c *Spatial_tessellation_schemeContext) + + // EnterSpatial_index_options is called when entering the spatial_index_options production. + EnterSpatial_index_options(c *Spatial_index_optionsContext) + + // EnterSpatial_index_option is called when entering the spatial_index_option production. + EnterSpatial_index_option(c *Spatial_index_optionContext) + + // EnterSigned_decimal is called when entering the signed_decimal production. + EnterSigned_decimal(c *Signed_decimalContext) + + // EnterSpatial_grid_level is called when entering the spatial_grid_level production. + EnterSpatial_grid_level(c *Spatial_grid_levelContext) + + // EnterSpatial_grid_density is called when entering the spatial_grid_density production. + EnterSpatial_grid_density(c *Spatial_grid_densityContext) + + // EnterCreate_index_options is called when entering the create_index_options production. + EnterCreate_index_options(c *Create_index_optionsContext) + + // EnterRelational_index_option is called when entering the relational_index_option production. + EnterRelational_index_option(c *Relational_index_optionContext) + + // EnterAlter_index is called when entering the alter_index production. + EnterAlter_index(c *Alter_indexContext) + + // EnterResumable_index_options is called when entering the resumable_index_options production. + EnterResumable_index_options(c *Resumable_index_optionsContext) + + // EnterResumable_index_option is called when entering the resumable_index_option production. + EnterResumable_index_option(c *Resumable_index_optionContext) + + // EnterReorganize_partition is called when entering the reorganize_partition production. + EnterReorganize_partition(c *Reorganize_partitionContext) + + // EnterReorganize_options is called when entering the reorganize_options production. + EnterReorganize_options(c *Reorganize_optionsContext) + + // EnterReorganize_option is called when entering the reorganize_option production. + EnterReorganize_option(c *Reorganize_optionContext) + + // EnterSet_index_options is called when entering the set_index_options production. + EnterSet_index_options(c *Set_index_optionsContext) + + // EnterSet_index_option is called when entering the set_index_option production. + EnterSet_index_option(c *Set_index_optionContext) + + // EnterRebuild_partition is called when entering the rebuild_partition production. + EnterRebuild_partition(c *Rebuild_partitionContext) + + // EnterRebuild_index_options is called when entering the rebuild_index_options production. + EnterRebuild_index_options(c *Rebuild_index_optionsContext) + + // EnterRebuild_index_option is called when entering the rebuild_index_option production. + EnterRebuild_index_option(c *Rebuild_index_optionContext) + + // EnterSingle_partition_rebuild_index_options is called when entering the single_partition_rebuild_index_options production. + EnterSingle_partition_rebuild_index_options(c *Single_partition_rebuild_index_optionsContext) + + // EnterSingle_partition_rebuild_index_option is called when entering the single_partition_rebuild_index_option production. + EnterSingle_partition_rebuild_index_option(c *Single_partition_rebuild_index_optionContext) + + // EnterOn_partitions is called when entering the on_partitions production. + EnterOn_partitions(c *On_partitionsContext) + + // EnterCreate_columnstore_index is called when entering the create_columnstore_index production. + EnterCreate_columnstore_index(c *Create_columnstore_indexContext) + + // EnterCreate_columnstore_index_options is called when entering the create_columnstore_index_options production. + EnterCreate_columnstore_index_options(c *Create_columnstore_index_optionsContext) + + // EnterColumnstore_index_option is called when entering the columnstore_index_option production. + EnterColumnstore_index_option(c *Columnstore_index_optionContext) + + // EnterCreate_nonclustered_columnstore_index is called when entering the create_nonclustered_columnstore_index production. + EnterCreate_nonclustered_columnstore_index(c *Create_nonclustered_columnstore_indexContext) + + // EnterCreate_xml_index is called when entering the create_xml_index production. + EnterCreate_xml_index(c *Create_xml_indexContext) + + // EnterXml_index_options is called when entering the xml_index_options production. + EnterXml_index_options(c *Xml_index_optionsContext) + + // EnterXml_index_option is called when entering the xml_index_option production. + EnterXml_index_option(c *Xml_index_optionContext) + + // EnterCreate_or_alter_procedure is called when entering the create_or_alter_procedure production. + EnterCreate_or_alter_procedure(c *Create_or_alter_procedureContext) + + // EnterAs_external_name is called when entering the as_external_name production. + EnterAs_external_name(c *As_external_nameContext) + + // EnterCreate_or_alter_trigger is called when entering the create_or_alter_trigger production. + EnterCreate_or_alter_trigger(c *Create_or_alter_triggerContext) + + // EnterCreate_or_alter_dml_trigger is called when entering the create_or_alter_dml_trigger production. + EnterCreate_or_alter_dml_trigger(c *Create_or_alter_dml_triggerContext) + + // EnterDml_trigger_option is called when entering the dml_trigger_option production. + EnterDml_trigger_option(c *Dml_trigger_optionContext) + + // EnterDml_trigger_operation is called when entering the dml_trigger_operation production. + EnterDml_trigger_operation(c *Dml_trigger_operationContext) + + // EnterCreate_or_alter_ddl_trigger is called when entering the create_or_alter_ddl_trigger production. + EnterCreate_or_alter_ddl_trigger(c *Create_or_alter_ddl_triggerContext) + + // EnterDdl_trigger_operation is called when entering the ddl_trigger_operation production. + EnterDdl_trigger_operation(c *Ddl_trigger_operationContext) + + // EnterCreate_or_alter_function is called when entering the create_or_alter_function production. + EnterCreate_or_alter_function(c *Create_or_alter_functionContext) + + // EnterFunc_body_returns_select is called when entering the func_body_returns_select production. + EnterFunc_body_returns_select(c *Func_body_returns_selectContext) + + // EnterFunc_body_returns_table is called when entering the func_body_returns_table production. + EnterFunc_body_returns_table(c *Func_body_returns_tableContext) + + // EnterFunc_body_returns_scalar is called when entering the func_body_returns_scalar production. + EnterFunc_body_returns_scalar(c *Func_body_returns_scalarContext) + + // EnterProcedure_param_default_value is called when entering the procedure_param_default_value production. + EnterProcedure_param_default_value(c *Procedure_param_default_valueContext) + + // EnterProcedure_param is called when entering the procedure_param production. + EnterProcedure_param(c *Procedure_paramContext) + + // EnterProcedure_option is called when entering the procedure_option production. + EnterProcedure_option(c *Procedure_optionContext) + + // EnterFunction_option is called when entering the function_option production. + EnterFunction_option(c *Function_optionContext) + + // EnterCreate_statistics is called when entering the create_statistics production. + EnterCreate_statistics(c *Create_statisticsContext) + + // EnterUpdate_statistics is called when entering the update_statistics production. + EnterUpdate_statistics(c *Update_statisticsContext) + + // EnterUpdate_statistics_options is called when entering the update_statistics_options production. + EnterUpdate_statistics_options(c *Update_statistics_optionsContext) + + // EnterUpdate_statistics_option is called when entering the update_statistics_option production. + EnterUpdate_statistics_option(c *Update_statistics_optionContext) + + // EnterCreate_table is called when entering the create_table production. + EnterCreate_table(c *Create_tableContext) + + // EnterTable_indices is called when entering the table_indices production. + EnterTable_indices(c *Table_indicesContext) + + // EnterTable_options is called when entering the table_options production. + EnterTable_options(c *Table_optionsContext) + + // EnterTable_option is called when entering the table_option production. + EnterTable_option(c *Table_optionContext) + + // EnterCreate_table_index_options is called when entering the create_table_index_options production. + EnterCreate_table_index_options(c *Create_table_index_optionsContext) + + // EnterCreate_table_index_option is called when entering the create_table_index_option production. + EnterCreate_table_index_option(c *Create_table_index_optionContext) + + // EnterCreate_view is called when entering the create_view production. + EnterCreate_view(c *Create_viewContext) + + // EnterView_attribute is called when entering the view_attribute production. + EnterView_attribute(c *View_attributeContext) + + // EnterAlter_table is called when entering the alter_table production. + EnterAlter_table(c *Alter_tableContext) + + // EnterSwitch_partition is called when entering the switch_partition production. + EnterSwitch_partition(c *Switch_partitionContext) + + // EnterLow_priority_lock_wait is called when entering the low_priority_lock_wait production. + EnterLow_priority_lock_wait(c *Low_priority_lock_waitContext) + + // EnterAlter_database is called when entering the alter_database production. + EnterAlter_database(c *Alter_databaseContext) + + // EnterAdd_or_modify_files is called when entering the add_or_modify_files production. + EnterAdd_or_modify_files(c *Add_or_modify_filesContext) + + // EnterFilespec is called when entering the filespec production. + EnterFilespec(c *FilespecContext) + + // EnterAdd_or_modify_filegroups is called when entering the add_or_modify_filegroups production. + EnterAdd_or_modify_filegroups(c *Add_or_modify_filegroupsContext) + + // EnterFilegroup_updatability_option is called when entering the filegroup_updatability_option production. + EnterFilegroup_updatability_option(c *Filegroup_updatability_optionContext) + + // EnterDatabase_optionspec is called when entering the database_optionspec production. + EnterDatabase_optionspec(c *Database_optionspecContext) + + // EnterAuto_option is called when entering the auto_option production. + EnterAuto_option(c *Auto_optionContext) + + // EnterChange_tracking_option is called when entering the change_tracking_option production. + EnterChange_tracking_option(c *Change_tracking_optionContext) + + // EnterChange_tracking_option_list is called when entering the change_tracking_option_list production. + EnterChange_tracking_option_list(c *Change_tracking_option_listContext) + + // EnterContainment_option is called when entering the containment_option production. + EnterContainment_option(c *Containment_optionContext) + + // EnterCursor_option is called when entering the cursor_option production. + EnterCursor_option(c *Cursor_optionContext) + + // EnterAlter_endpoint is called when entering the alter_endpoint production. + EnterAlter_endpoint(c *Alter_endpointContext) + + // EnterDatabase_mirroring_option is called when entering the database_mirroring_option production. + EnterDatabase_mirroring_option(c *Database_mirroring_optionContext) + + // EnterMirroring_set_option is called when entering the mirroring_set_option production. + EnterMirroring_set_option(c *Mirroring_set_optionContext) + + // EnterMirroring_partner is called when entering the mirroring_partner production. + EnterMirroring_partner(c *Mirroring_partnerContext) + + // EnterMirroring_witness is called when entering the mirroring_witness production. + EnterMirroring_witness(c *Mirroring_witnessContext) + + // EnterWitness_partner_equal is called when entering the witness_partner_equal production. + EnterWitness_partner_equal(c *Witness_partner_equalContext) + + // EnterPartner_option is called when entering the partner_option production. + EnterPartner_option(c *Partner_optionContext) + + // EnterWitness_option is called when entering the witness_option production. + EnterWitness_option(c *Witness_optionContext) + + // EnterWitness_server is called when entering the witness_server production. + EnterWitness_server(c *Witness_serverContext) + + // EnterPartner_server is called when entering the partner_server production. + EnterPartner_server(c *Partner_serverContext) + + // EnterMirroring_host_port_seperator is called when entering the mirroring_host_port_seperator production. + EnterMirroring_host_port_seperator(c *Mirroring_host_port_seperatorContext) + + // EnterPartner_server_tcp_prefix is called when entering the partner_server_tcp_prefix production. + EnterPartner_server_tcp_prefix(c *Partner_server_tcp_prefixContext) + + // EnterPort_number is called when entering the port_number production. + EnterPort_number(c *Port_numberContext) + + // EnterHost is called when entering the host production. + EnterHost(c *HostContext) + + // EnterDate_correlation_optimization_option is called when entering the date_correlation_optimization_option production. + EnterDate_correlation_optimization_option(c *Date_correlation_optimization_optionContext) + + // EnterDb_encryption_option is called when entering the db_encryption_option production. + EnterDb_encryption_option(c *Db_encryption_optionContext) + + // EnterDb_state_option is called when entering the db_state_option production. + EnterDb_state_option(c *Db_state_optionContext) + + // EnterDb_update_option is called when entering the db_update_option production. + EnterDb_update_option(c *Db_update_optionContext) + + // EnterDb_user_access_option is called when entering the db_user_access_option production. + EnterDb_user_access_option(c *Db_user_access_optionContext) + + // EnterDelayed_durability_option is called when entering the delayed_durability_option production. + EnterDelayed_durability_option(c *Delayed_durability_optionContext) + + // EnterExternal_access_option is called when entering the external_access_option production. + EnterExternal_access_option(c *External_access_optionContext) + + // EnterHadr_options is called when entering the hadr_options production. + EnterHadr_options(c *Hadr_optionsContext) + + // EnterMixed_page_allocation_option is called when entering the mixed_page_allocation_option production. + EnterMixed_page_allocation_option(c *Mixed_page_allocation_optionContext) + + // EnterParameterization_option is called when entering the parameterization_option production. + EnterParameterization_option(c *Parameterization_optionContext) + + // EnterRecovery_option is called when entering the recovery_option production. + EnterRecovery_option(c *Recovery_optionContext) + + // EnterService_broker_option is called when entering the service_broker_option production. + EnterService_broker_option(c *Service_broker_optionContext) + + // EnterSnapshot_option is called when entering the snapshot_option production. + EnterSnapshot_option(c *Snapshot_optionContext) + + // EnterSql_option is called when entering the sql_option production. + EnterSql_option(c *Sql_optionContext) + + // EnterTarget_recovery_time_option is called when entering the target_recovery_time_option production. + EnterTarget_recovery_time_option(c *Target_recovery_time_optionContext) + + // EnterTermination is called when entering the termination production. + EnterTermination(c *TerminationContext) + + // EnterDrop_index is called when entering the drop_index production. + EnterDrop_index(c *Drop_indexContext) + + // EnterDrop_relational_or_xml_or_spatial_index is called when entering the drop_relational_or_xml_or_spatial_index production. + EnterDrop_relational_or_xml_or_spatial_index(c *Drop_relational_or_xml_or_spatial_indexContext) + + // EnterDrop_backward_compatible_index is called when entering the drop_backward_compatible_index production. + EnterDrop_backward_compatible_index(c *Drop_backward_compatible_indexContext) + + // EnterDrop_procedure is called when entering the drop_procedure production. + EnterDrop_procedure(c *Drop_procedureContext) + + // EnterDrop_trigger is called when entering the drop_trigger production. + EnterDrop_trigger(c *Drop_triggerContext) + + // EnterDrop_dml_trigger is called when entering the drop_dml_trigger production. + EnterDrop_dml_trigger(c *Drop_dml_triggerContext) + + // EnterDrop_ddl_trigger is called when entering the drop_ddl_trigger production. + EnterDrop_ddl_trigger(c *Drop_ddl_triggerContext) + + // EnterDrop_function is called when entering the drop_function production. + EnterDrop_function(c *Drop_functionContext) + + // EnterDrop_statistics is called when entering the drop_statistics production. + EnterDrop_statistics(c *Drop_statisticsContext) + + // EnterDrop_table is called when entering the drop_table production. + EnterDrop_table(c *Drop_tableContext) + + // EnterDrop_view is called when entering the drop_view production. + EnterDrop_view(c *Drop_viewContext) + + // EnterCreate_type is called when entering the create_type production. + EnterCreate_type(c *Create_typeContext) + + // EnterDrop_type is called when entering the drop_type production. + EnterDrop_type(c *Drop_typeContext) + + // EnterRowset_function_limited is called when entering the rowset_function_limited production. + EnterRowset_function_limited(c *Rowset_function_limitedContext) + + // EnterOpenquery is called when entering the openquery production. + EnterOpenquery(c *OpenqueryContext) + + // EnterOpendatasource is called when entering the opendatasource production. + EnterOpendatasource(c *OpendatasourceContext) + + // EnterDeclare_statement is called when entering the declare_statement production. + EnterDeclare_statement(c *Declare_statementContext) + + // EnterXml_declaration is called when entering the xml_declaration production. + EnterXml_declaration(c *Xml_declarationContext) + + // EnterCursor_statement is called when entering the cursor_statement production. + EnterCursor_statement(c *Cursor_statementContext) + + // EnterBackup_database is called when entering the backup_database production. + EnterBackup_database(c *Backup_databaseContext) + + // EnterBackup_log is called when entering the backup_log production. + EnterBackup_log(c *Backup_logContext) + + // EnterBackup_certificate is called when entering the backup_certificate production. + EnterBackup_certificate(c *Backup_certificateContext) + + // EnterBackup_master_key is called when entering the backup_master_key production. + EnterBackup_master_key(c *Backup_master_keyContext) + + // EnterBackup_service_master_key is called when entering the backup_service_master_key production. + EnterBackup_service_master_key(c *Backup_service_master_keyContext) + + // EnterKill_statement is called when entering the kill_statement production. + EnterKill_statement(c *Kill_statementContext) + + // EnterKill_process is called when entering the kill_process production. + EnterKill_process(c *Kill_processContext) + + // EnterKill_query_notification is called when entering the kill_query_notification production. + EnterKill_query_notification(c *Kill_query_notificationContext) + + // EnterKill_stats_job is called when entering the kill_stats_job production. + EnterKill_stats_job(c *Kill_stats_jobContext) + + // EnterExecute_statement is called when entering the execute_statement production. + EnterExecute_statement(c *Execute_statementContext) + + // EnterExecute_body_batch is called when entering the execute_body_batch production. + EnterExecute_body_batch(c *Execute_body_batchContext) + + // EnterExecute_body is called when entering the execute_body production. + EnterExecute_body(c *Execute_bodyContext) + + // EnterExecute_statement_arg is called when entering the execute_statement_arg production. + EnterExecute_statement_arg(c *Execute_statement_argContext) + + // EnterExecute_statement_arg_named is called when entering the execute_statement_arg_named production. + EnterExecute_statement_arg_named(c *Execute_statement_arg_namedContext) + + // EnterExecute_statement_arg_unnamed is called when entering the execute_statement_arg_unnamed production. + EnterExecute_statement_arg_unnamed(c *Execute_statement_arg_unnamedContext) + + // EnterExecute_parameter is called when entering the execute_parameter production. + EnterExecute_parameter(c *Execute_parameterContext) + + // EnterExecute_var_string is called when entering the execute_var_string production. + EnterExecute_var_string(c *Execute_var_stringContext) + + // EnterSecurity_statement is called when entering the security_statement production. + EnterSecurity_statement(c *Security_statementContext) + + // EnterPrincipal_id is called when entering the principal_id production. + EnterPrincipal_id(c *Principal_idContext) + + // EnterCreate_certificate is called when entering the create_certificate production. + EnterCreate_certificate(c *Create_certificateContext) + + // EnterExisting_keys is called when entering the existing_keys production. + EnterExisting_keys(c *Existing_keysContext) + + // EnterPrivate_key_options is called when entering the private_key_options production. + EnterPrivate_key_options(c *Private_key_optionsContext) + + // EnterGenerate_new_keys is called when entering the generate_new_keys production. + EnterGenerate_new_keys(c *Generate_new_keysContext) + + // EnterDate_options is called when entering the date_options production. + EnterDate_options(c *Date_optionsContext) + + // EnterOpen_key is called when entering the open_key production. + EnterOpen_key(c *Open_keyContext) + + // EnterClose_key is called when entering the close_key production. + EnterClose_key(c *Close_keyContext) + + // EnterCreate_key is called when entering the create_key production. + EnterCreate_key(c *Create_keyContext) + + // EnterKey_options is called when entering the key_options production. + EnterKey_options(c *Key_optionsContext) + + // EnterAlgorithm is called when entering the algorithm production. + EnterAlgorithm(c *AlgorithmContext) + + // EnterEncryption_mechanism is called when entering the encryption_mechanism production. + EnterEncryption_mechanism(c *Encryption_mechanismContext) + + // EnterDecryption_mechanism is called when entering the decryption_mechanism production. + EnterDecryption_mechanism(c *Decryption_mechanismContext) + + // EnterGrant_permission is called when entering the grant_permission production. + EnterGrant_permission(c *Grant_permissionContext) + + // EnterSet_statement is called when entering the set_statement production. + EnterSet_statement(c *Set_statementContext) + + // EnterTransaction_statement is called when entering the transaction_statement production. + EnterTransaction_statement(c *Transaction_statementContext) + + // EnterGo_statement is called when entering the go_statement production. + EnterGo_statement(c *Go_statementContext) + + // EnterUse_statement is called when entering the use_statement production. + EnterUse_statement(c *Use_statementContext) + + // EnterSetuser_statement is called when entering the setuser_statement production. + EnterSetuser_statement(c *Setuser_statementContext) + + // EnterReconfigure_statement is called when entering the reconfigure_statement production. + EnterReconfigure_statement(c *Reconfigure_statementContext) + + // EnterShutdown_statement is called when entering the shutdown_statement production. + EnterShutdown_statement(c *Shutdown_statementContext) + + // EnterCheckpoint_statement is called when entering the checkpoint_statement production. + EnterCheckpoint_statement(c *Checkpoint_statementContext) + + // EnterDbcc_checkalloc_option is called when entering the dbcc_checkalloc_option production. + EnterDbcc_checkalloc_option(c *Dbcc_checkalloc_optionContext) + + // EnterDbcc_checkalloc is called when entering the dbcc_checkalloc production. + EnterDbcc_checkalloc(c *Dbcc_checkallocContext) + + // EnterDbcc_checkcatalog is called when entering the dbcc_checkcatalog production. + EnterDbcc_checkcatalog(c *Dbcc_checkcatalogContext) + + // EnterDbcc_checkconstraints_option is called when entering the dbcc_checkconstraints_option production. + EnterDbcc_checkconstraints_option(c *Dbcc_checkconstraints_optionContext) + + // EnterDbcc_checkconstraints is called when entering the dbcc_checkconstraints production. + EnterDbcc_checkconstraints(c *Dbcc_checkconstraintsContext) + + // EnterDbcc_checkdb_table_option is called when entering the dbcc_checkdb_table_option production. + EnterDbcc_checkdb_table_option(c *Dbcc_checkdb_table_optionContext) + + // EnterDbcc_checkdb is called when entering the dbcc_checkdb production. + EnterDbcc_checkdb(c *Dbcc_checkdbContext) + + // EnterDbcc_checkfilegroup_option is called when entering the dbcc_checkfilegroup_option production. + EnterDbcc_checkfilegroup_option(c *Dbcc_checkfilegroup_optionContext) + + // EnterDbcc_checkfilegroup is called when entering the dbcc_checkfilegroup production. + EnterDbcc_checkfilegroup(c *Dbcc_checkfilegroupContext) + + // EnterDbcc_checktable is called when entering the dbcc_checktable production. + EnterDbcc_checktable(c *Dbcc_checktableContext) + + // EnterDbcc_cleantable is called when entering the dbcc_cleantable production. + EnterDbcc_cleantable(c *Dbcc_cleantableContext) + + // EnterDbcc_clonedatabase_option is called when entering the dbcc_clonedatabase_option production. + EnterDbcc_clonedatabase_option(c *Dbcc_clonedatabase_optionContext) + + // EnterDbcc_clonedatabase is called when entering the dbcc_clonedatabase production. + EnterDbcc_clonedatabase(c *Dbcc_clonedatabaseContext) + + // EnterDbcc_pdw_showspaceused is called when entering the dbcc_pdw_showspaceused production. + EnterDbcc_pdw_showspaceused(c *Dbcc_pdw_showspaceusedContext) + + // EnterDbcc_proccache is called when entering the dbcc_proccache production. + EnterDbcc_proccache(c *Dbcc_proccacheContext) + + // EnterDbcc_showcontig_option is called when entering the dbcc_showcontig_option production. + EnterDbcc_showcontig_option(c *Dbcc_showcontig_optionContext) + + // EnterDbcc_showcontig is called when entering the dbcc_showcontig production. + EnterDbcc_showcontig(c *Dbcc_showcontigContext) + + // EnterDbcc_shrinklog is called when entering the dbcc_shrinklog production. + EnterDbcc_shrinklog(c *Dbcc_shrinklogContext) + + // EnterDbcc_dbreindex is called when entering the dbcc_dbreindex production. + EnterDbcc_dbreindex(c *Dbcc_dbreindexContext) + + // EnterDbcc_dll_free is called when entering the dbcc_dll_free production. + EnterDbcc_dll_free(c *Dbcc_dll_freeContext) + + // EnterDbcc_dropcleanbuffers is called when entering the dbcc_dropcleanbuffers production. + EnterDbcc_dropcleanbuffers(c *Dbcc_dropcleanbuffersContext) + + // EnterDbcc_clause is called when entering the dbcc_clause production. + EnterDbcc_clause(c *Dbcc_clauseContext) + + // EnterExecute_clause is called when entering the execute_clause production. + EnterExecute_clause(c *Execute_clauseContext) + + // EnterDeclare_local is called when entering the declare_local production. + EnterDeclare_local(c *Declare_localContext) + + // EnterTable_type_definition is called when entering the table_type_definition production. + EnterTable_type_definition(c *Table_type_definitionContext) + + // EnterTable_type_indices is called when entering the table_type_indices production. + EnterTable_type_indices(c *Table_type_indicesContext) + + // EnterXml_type_definition is called when entering the xml_type_definition production. + EnterXml_type_definition(c *Xml_type_definitionContext) + + // EnterXml_schema_collection is called when entering the xml_schema_collection production. + EnterXml_schema_collection(c *Xml_schema_collectionContext) + + // EnterColumn_def_table_constraints is called when entering the column_def_table_constraints production. + EnterColumn_def_table_constraints(c *Column_def_table_constraintsContext) + + // EnterColumn_def_table_constraint is called when entering the column_def_table_constraint production. + EnterColumn_def_table_constraint(c *Column_def_table_constraintContext) + + // EnterColumn_definition is called when entering the column_definition production. + EnterColumn_definition(c *Column_definitionContext) + + // EnterColumn_definition_element is called when entering the column_definition_element production. + EnterColumn_definition_element(c *Column_definition_elementContext) + + // EnterColumn_modifier is called when entering the column_modifier production. + EnterColumn_modifier(c *Column_modifierContext) + + // EnterMaterialized_column_definition is called when entering the materialized_column_definition production. + EnterMaterialized_column_definition(c *Materialized_column_definitionContext) + + // EnterColumn_constraint is called when entering the column_constraint production. + EnterColumn_constraint(c *Column_constraintContext) + + // EnterColumn_index is called when entering the column_index production. + EnterColumn_index(c *Column_indexContext) + + // EnterOn_partition_or_filegroup is called when entering the on_partition_or_filegroup production. + EnterOn_partition_or_filegroup(c *On_partition_or_filegroupContext) + + // EnterTable_constraint is called when entering the table_constraint production. + EnterTable_constraint(c *Table_constraintContext) + + // EnterConnection_node is called when entering the connection_node production. + EnterConnection_node(c *Connection_nodeContext) + + // EnterPrimary_key_options is called when entering the primary_key_options production. + EnterPrimary_key_options(c *Primary_key_optionsContext) + + // EnterForeign_key_options is called when entering the foreign_key_options production. + EnterForeign_key_options(c *Foreign_key_optionsContext) + + // EnterCheck_constraint is called when entering the check_constraint production. + EnterCheck_constraint(c *Check_constraintContext) + + // EnterOn_delete is called when entering the on_delete production. + EnterOn_delete(c *On_deleteContext) + + // EnterOn_update is called when entering the on_update production. + EnterOn_update(c *On_updateContext) + + // EnterAlter_table_index_options is called when entering the alter_table_index_options production. + EnterAlter_table_index_options(c *Alter_table_index_optionsContext) + + // EnterAlter_table_index_option is called when entering the alter_table_index_option production. + EnterAlter_table_index_option(c *Alter_table_index_optionContext) + + // EnterDeclare_cursor is called when entering the declare_cursor production. + EnterDeclare_cursor(c *Declare_cursorContext) + + // EnterDeclare_set_cursor_common is called when entering the declare_set_cursor_common production. + EnterDeclare_set_cursor_common(c *Declare_set_cursor_commonContext) + + // EnterDeclare_set_cursor_common_partial is called when entering the declare_set_cursor_common_partial production. + EnterDeclare_set_cursor_common_partial(c *Declare_set_cursor_common_partialContext) + + // EnterFetch_cursor is called when entering the fetch_cursor production. + EnterFetch_cursor(c *Fetch_cursorContext) + + // EnterSet_special is called when entering the set_special production. + EnterSet_special(c *Set_specialContext) + + // EnterSpecial_list is called when entering the special_list production. + EnterSpecial_list(c *Special_listContext) + + // EnterConstant_LOCAL_ID is called when entering the constant_LOCAL_ID production. + EnterConstant_LOCAL_ID(c *Constant_LOCAL_IDContext) + + // EnterExpression is called when entering the expression production. + EnterExpression(c *ExpressionContext) + + // EnterParameter is called when entering the parameter production. + EnterParameter(c *ParameterContext) + + // EnterTime_zone is called when entering the time_zone production. + EnterTime_zone(c *Time_zoneContext) + + // EnterPrimitive_expression is called when entering the primitive_expression production. + EnterPrimitive_expression(c *Primitive_expressionContext) + + // EnterCase_expression is called when entering the case_expression production. + EnterCase_expression(c *Case_expressionContext) + + // EnterUnary_operator_expression is called when entering the unary_operator_expression production. + EnterUnary_operator_expression(c *Unary_operator_expressionContext) + + // EnterBracket_expression is called when entering the bracket_expression production. + EnterBracket_expression(c *Bracket_expressionContext) + + // EnterSubquery is called when entering the subquery production. + EnterSubquery(c *SubqueryContext) + + // EnterWith_expression is called when entering the with_expression production. + EnterWith_expression(c *With_expressionContext) + + // EnterCommon_table_expression is called when entering the common_table_expression production. + EnterCommon_table_expression(c *Common_table_expressionContext) + + // EnterUpdate_elem is called when entering the update_elem production. + EnterUpdate_elem(c *Update_elemContext) + + // EnterUpdate_elem_merge is called when entering the update_elem_merge production. + EnterUpdate_elem_merge(c *Update_elem_mergeContext) + + // EnterSearch_condition is called when entering the search_condition production. + EnterSearch_condition(c *Search_conditionContext) + + // EnterPredicate is called when entering the predicate production. + EnterPredicate(c *PredicateContext) + + // EnterQuery_expression is called when entering the query_expression production. + EnterQuery_expression(c *Query_expressionContext) + + // EnterSql_union is called when entering the sql_union production. + EnterSql_union(c *Sql_unionContext) + + // EnterQuery_specification is called when entering the query_specification production. + EnterQuery_specification(c *Query_specificationContext) + + // EnterGroup_by_clause is called when entering the group_by_clause production. + EnterGroup_by_clause(c *Group_by_clauseContext) + + // EnterHaving_clause is called when entering the having_clause production. + EnterHaving_clause(c *Having_clauseContext) + + // EnterFrom_table_sources is called when entering the from_table_sources production. + EnterFrom_table_sources(c *From_table_sourcesContext) + + // EnterTop_clause is called when entering the top_clause production. + EnterTop_clause(c *Top_clauseContext) + + // EnterTop_percent is called when entering the top_percent production. + EnterTop_percent(c *Top_percentContext) + + // EnterTop_count is called when entering the top_count production. + EnterTop_count(c *Top_countContext) + + // EnterOrder_by_clause is called when entering the order_by_clause production. + EnterOrder_by_clause(c *Order_by_clauseContext) + + // EnterSelect_order_by_clause is called when entering the select_order_by_clause production. + EnterSelect_order_by_clause(c *Select_order_by_clauseContext) + + // EnterFor_clause is called when entering the for_clause production. + EnterFor_clause(c *For_clauseContext) + + // EnterXml_common_directives is called when entering the xml_common_directives production. + EnterXml_common_directives(c *Xml_common_directivesContext) + + // EnterOrder_by_expression is called when entering the order_by_expression production. + EnterOrder_by_expression(c *Order_by_expressionContext) + + // EnterGrouping_sets_item is called when entering the grouping_sets_item production. + EnterGrouping_sets_item(c *Grouping_sets_itemContext) + + // EnterGroup_by_item is called when entering the group_by_item production. + EnterGroup_by_item(c *Group_by_itemContext) + + // EnterOption_clause is called when entering the option_clause production. + EnterOption_clause(c *Option_clauseContext) + + // EnterOption is called when entering the option production. + EnterOption(c *OptionContext) + + // EnterOptimize_for_arg is called when entering the optimize_for_arg production. + EnterOptimize_for_arg(c *Optimize_for_argContext) + + // EnterSelect_list is called when entering the select_list production. + EnterSelect_list(c *Select_listContext) + + // EnterUdt_method_arguments is called when entering the udt_method_arguments production. + EnterUdt_method_arguments(c *Udt_method_argumentsContext) + + // EnterAsterisk is called when entering the asterisk production. + EnterAsterisk(c *AsteriskContext) + + // EnterUdt_elem is called when entering the udt_elem production. + EnterUdt_elem(c *Udt_elemContext) + + // EnterExpression_elem is called when entering the expression_elem production. + EnterExpression_elem(c *Expression_elemContext) + + // EnterSelect_list_elem is called when entering the select_list_elem production. + EnterSelect_list_elem(c *Select_list_elemContext) + + // EnterTable_sources is called when entering the table_sources production. + EnterTable_sources(c *Table_sourcesContext) + + // EnterTable_source is called when entering the table_source production. + EnterTable_source(c *Table_sourceContext) + + // EnterTable_source_item is called when entering the table_source_item production. + EnterTable_source_item(c *Table_source_itemContext) + + // EnterOpen_xml is called when entering the open_xml production. + EnterOpen_xml(c *Open_xmlContext) + + // EnterOpen_json is called when entering the open_json production. + EnterOpen_json(c *Open_jsonContext) + + // EnterJson_declaration is called when entering the json_declaration production. + EnterJson_declaration(c *Json_declarationContext) + + // EnterJson_column_declaration is called when entering the json_column_declaration production. + EnterJson_column_declaration(c *Json_column_declarationContext) + + // EnterSchema_declaration is called when entering the schema_declaration production. + EnterSchema_declaration(c *Schema_declarationContext) + + // EnterColumn_declaration is called when entering the column_declaration production. + EnterColumn_declaration(c *Column_declarationContext) + + // EnterChange_table is called when entering the change_table production. + EnterChange_table(c *Change_tableContext) + + // EnterChange_table_changes is called when entering the change_table_changes production. + EnterChange_table_changes(c *Change_table_changesContext) + + // EnterChange_table_version is called when entering the change_table_version production. + EnterChange_table_version(c *Change_table_versionContext) + + // EnterJoin_part is called when entering the join_part production. + EnterJoin_part(c *Join_partContext) + + // EnterJoin_on is called when entering the join_on production. + EnterJoin_on(c *Join_onContext) + + // EnterCross_join is called when entering the cross_join production. + EnterCross_join(c *Cross_joinContext) + + // EnterApply_ is called when entering the apply_ production. + EnterApply_(c *Apply_Context) + + // EnterPivot is called when entering the pivot production. + EnterPivot(c *PivotContext) + + // EnterUnpivot is called when entering the unpivot production. + EnterUnpivot(c *UnpivotContext) + + // EnterPivot_clause is called when entering the pivot_clause production. + EnterPivot_clause(c *Pivot_clauseContext) + + // EnterUnpivot_clause is called when entering the unpivot_clause production. + EnterUnpivot_clause(c *Unpivot_clauseContext) + + // EnterFull_column_name_list is called when entering the full_column_name_list production. + EnterFull_column_name_list(c *Full_column_name_listContext) + + // EnterRowset_function is called when entering the rowset_function production. + EnterRowset_function(c *Rowset_functionContext) + + // EnterBulk_option is called when entering the bulk_option production. + EnterBulk_option(c *Bulk_optionContext) + + // EnterDerived_table is called when entering the derived_table production. + EnterDerived_table(c *Derived_tableContext) + + // EnterRANKING_WINDOWED_FUNC is called when entering the RANKING_WINDOWED_FUNC production. + EnterRANKING_WINDOWED_FUNC(c *RANKING_WINDOWED_FUNCContext) + + // EnterAGGREGATE_WINDOWED_FUNC is called when entering the AGGREGATE_WINDOWED_FUNC production. + EnterAGGREGATE_WINDOWED_FUNC(c *AGGREGATE_WINDOWED_FUNCContext) + + // EnterANALYTIC_WINDOWED_FUNC is called when entering the ANALYTIC_WINDOWED_FUNC production. + EnterANALYTIC_WINDOWED_FUNC(c *ANALYTIC_WINDOWED_FUNCContext) + + // EnterBUILT_IN_FUNC is called when entering the BUILT_IN_FUNC production. + EnterBUILT_IN_FUNC(c *BUILT_IN_FUNCContext) + + // EnterSCALAR_FUNCTION is called when entering the SCALAR_FUNCTION production. + EnterSCALAR_FUNCTION(c *SCALAR_FUNCTIONContext) + + // EnterFREE_TEXT is called when entering the FREE_TEXT production. + EnterFREE_TEXT(c *FREE_TEXTContext) + + // EnterPARTITION_FUNC is called when entering the PARTITION_FUNC production. + EnterPARTITION_FUNC(c *PARTITION_FUNCContext) + + // EnterHIERARCHYID_METHOD is called when entering the HIERARCHYID_METHOD production. + EnterHIERARCHYID_METHOD(c *HIERARCHYID_METHODContext) + + // EnterPartition_function is called when entering the partition_function production. + EnterPartition_function(c *Partition_functionContext) + + // EnterFreetext_function is called when entering the freetext_function production. + EnterFreetext_function(c *Freetext_functionContext) + + // EnterFreetext_predicate is called when entering the freetext_predicate production. + EnterFreetext_predicate(c *Freetext_predicateContext) + + // EnterJson_key_value is called when entering the json_key_value production. + EnterJson_key_value(c *Json_key_valueContext) + + // EnterJson_null_clause is called when entering the json_null_clause production. + EnterJson_null_clause(c *Json_null_clauseContext) + + // EnterAPP_NAME is called when entering the APP_NAME production. + EnterAPP_NAME(c *APP_NAMEContext) + + // EnterAPPLOCK_MODE is called when entering the APPLOCK_MODE production. + EnterAPPLOCK_MODE(c *APPLOCK_MODEContext) + + // EnterAPPLOCK_TEST is called when entering the APPLOCK_TEST production. + EnterAPPLOCK_TEST(c *APPLOCK_TESTContext) + + // EnterASSEMBLYPROPERTY is called when entering the ASSEMBLYPROPERTY production. + EnterASSEMBLYPROPERTY(c *ASSEMBLYPROPERTYContext) + + // EnterCOL_LENGTH is called when entering the COL_LENGTH production. + EnterCOL_LENGTH(c *COL_LENGTHContext) + + // EnterCOL_NAME is called when entering the COL_NAME production. + EnterCOL_NAME(c *COL_NAMEContext) + + // EnterCOLUMNPROPERTY is called when entering the COLUMNPROPERTY production. + EnterCOLUMNPROPERTY(c *COLUMNPROPERTYContext) + + // EnterDATABASEPROPERTYEX is called when entering the DATABASEPROPERTYEX production. + EnterDATABASEPROPERTYEX(c *DATABASEPROPERTYEXContext) + + // EnterDB_ID is called when entering the DB_ID production. + EnterDB_ID(c *DB_IDContext) + + // EnterDB_NAME is called when entering the DB_NAME production. + EnterDB_NAME(c *DB_NAMEContext) + + // EnterFILE_ID is called when entering the FILE_ID production. + EnterFILE_ID(c *FILE_IDContext) + + // EnterFILE_IDEX is called when entering the FILE_IDEX production. + EnterFILE_IDEX(c *FILE_IDEXContext) + + // EnterFILE_NAME is called when entering the FILE_NAME production. + EnterFILE_NAME(c *FILE_NAMEContext) + + // EnterFILEGROUP_ID is called when entering the FILEGROUP_ID production. + EnterFILEGROUP_ID(c *FILEGROUP_IDContext) + + // EnterFILEGROUP_NAME is called when entering the FILEGROUP_NAME production. + EnterFILEGROUP_NAME(c *FILEGROUP_NAMEContext) + + // EnterFILEGROUPPROPERTY is called when entering the FILEGROUPPROPERTY production. + EnterFILEGROUPPROPERTY(c *FILEGROUPPROPERTYContext) + + // EnterFILEPROPERTY is called when entering the FILEPROPERTY production. + EnterFILEPROPERTY(c *FILEPROPERTYContext) + + // EnterFILEPROPERTYEX is called when entering the FILEPROPERTYEX production. + EnterFILEPROPERTYEX(c *FILEPROPERTYEXContext) + + // EnterFULLTEXTCATALOGPROPERTY is called when entering the FULLTEXTCATALOGPROPERTY production. + EnterFULLTEXTCATALOGPROPERTY(c *FULLTEXTCATALOGPROPERTYContext) + + // EnterFULLTEXTSERVICEPROPERTY is called when entering the FULLTEXTSERVICEPROPERTY production. + EnterFULLTEXTSERVICEPROPERTY(c *FULLTEXTSERVICEPROPERTYContext) + + // EnterINDEX_COL is called when entering the INDEX_COL production. + EnterINDEX_COL(c *INDEX_COLContext) + + // EnterINDEXKEY_PROPERTY is called when entering the INDEXKEY_PROPERTY production. + EnterINDEXKEY_PROPERTY(c *INDEXKEY_PROPERTYContext) + + // EnterINDEXPROPERTY is called when entering the INDEXPROPERTY production. + EnterINDEXPROPERTY(c *INDEXPROPERTYContext) + + // EnterNEXT_VALUE_FOR is called when entering the NEXT_VALUE_FOR production. + EnterNEXT_VALUE_FOR(c *NEXT_VALUE_FORContext) + + // EnterOBJECT_DEFINITION is called when entering the OBJECT_DEFINITION production. + EnterOBJECT_DEFINITION(c *OBJECT_DEFINITIONContext) + + // EnterOBJECT_ID is called when entering the OBJECT_ID production. + EnterOBJECT_ID(c *OBJECT_IDContext) + + // EnterOBJECT_NAME is called when entering the OBJECT_NAME production. + EnterOBJECT_NAME(c *OBJECT_NAMEContext) + + // EnterOBJECT_SCHEMA_NAME is called when entering the OBJECT_SCHEMA_NAME production. + EnterOBJECT_SCHEMA_NAME(c *OBJECT_SCHEMA_NAMEContext) + + // EnterOBJECTPROPERTY is called when entering the OBJECTPROPERTY production. + EnterOBJECTPROPERTY(c *OBJECTPROPERTYContext) + + // EnterOBJECTPROPERTYEX is called when entering the OBJECTPROPERTYEX production. + EnterOBJECTPROPERTYEX(c *OBJECTPROPERTYEXContext) + + // EnterORIGINAL_DB_NAME is called when entering the ORIGINAL_DB_NAME production. + EnterORIGINAL_DB_NAME(c *ORIGINAL_DB_NAMEContext) + + // EnterPARSENAME is called when entering the PARSENAME production. + EnterPARSENAME(c *PARSENAMEContext) + + // EnterSCHEMA_ID is called when entering the SCHEMA_ID production. + EnterSCHEMA_ID(c *SCHEMA_IDContext) + + // EnterSCHEMA_NAME is called when entering the SCHEMA_NAME production. + EnterSCHEMA_NAME(c *SCHEMA_NAMEContext) + + // EnterSCOPE_IDENTITY is called when entering the SCOPE_IDENTITY production. + EnterSCOPE_IDENTITY(c *SCOPE_IDENTITYContext) + + // EnterSERVERPROPERTY is called when entering the SERVERPROPERTY production. + EnterSERVERPROPERTY(c *SERVERPROPERTYContext) + + // EnterSTATS_DATE is called when entering the STATS_DATE production. + EnterSTATS_DATE(c *STATS_DATEContext) + + // EnterTYPE_ID is called when entering the TYPE_ID production. + EnterTYPE_ID(c *TYPE_IDContext) + + // EnterTYPE_NAME is called when entering the TYPE_NAME production. + EnterTYPE_NAME(c *TYPE_NAMEContext) + + // EnterTYPEPROPERTY is called when entering the TYPEPROPERTY production. + EnterTYPEPROPERTY(c *TYPEPROPERTYContext) + + // EnterASCII is called when entering the ASCII production. + EnterASCII(c *ASCIIContext) + + // EnterCHAR is called when entering the CHAR production. + EnterCHAR(c *CHARContext) + + // EnterCHARINDEX is called when entering the CHARINDEX production. + EnterCHARINDEX(c *CHARINDEXContext) + + // EnterCONCAT is called when entering the CONCAT production. + EnterCONCAT(c *CONCATContext) + + // EnterCONCAT_WS is called when entering the CONCAT_WS production. + EnterCONCAT_WS(c *CONCAT_WSContext) + + // EnterDIFFERENCE is called when entering the DIFFERENCE production. + EnterDIFFERENCE(c *DIFFERENCEContext) + + // EnterFORMAT is called when entering the FORMAT production. + EnterFORMAT(c *FORMATContext) + + // EnterLEFT is called when entering the LEFT production. + EnterLEFT(c *LEFTContext) + + // EnterLEN is called when entering the LEN production. + EnterLEN(c *LENContext) + + // EnterLOWER is called when entering the LOWER production. + EnterLOWER(c *LOWERContext) + + // EnterLTRIM is called when entering the LTRIM production. + EnterLTRIM(c *LTRIMContext) + + // EnterNCHAR is called when entering the NCHAR production. + EnterNCHAR(c *NCHARContext) + + // EnterPATINDEX is called when entering the PATINDEX production. + EnterPATINDEX(c *PATINDEXContext) + + // EnterQUOTENAME is called when entering the QUOTENAME production. + EnterQUOTENAME(c *QUOTENAMEContext) + + // EnterREPLACE is called when entering the REPLACE production. + EnterREPLACE(c *REPLACEContext) + + // EnterREPLICATE is called when entering the REPLICATE production. + EnterREPLICATE(c *REPLICATEContext) + + // EnterREVERSE is called when entering the REVERSE production. + EnterREVERSE(c *REVERSEContext) + + // EnterRIGHT is called when entering the RIGHT production. + EnterRIGHT(c *RIGHTContext) + + // EnterRTRIM is called when entering the RTRIM production. + EnterRTRIM(c *RTRIMContext) + + // EnterSOUNDEX is called when entering the SOUNDEX production. + EnterSOUNDEX(c *SOUNDEXContext) + + // EnterSPACE is called when entering the SPACE production. + EnterSPACE(c *SPACEContext) + + // EnterSTR is called when entering the STR production. + EnterSTR(c *STRContext) + + // EnterSTRINGAGG is called when entering the STRINGAGG production. + EnterSTRINGAGG(c *STRINGAGGContext) + + // EnterSTRING_ESCAPE is called when entering the STRING_ESCAPE production. + EnterSTRING_ESCAPE(c *STRING_ESCAPEContext) + + // EnterSTUFF is called when entering the STUFF production. + EnterSTUFF(c *STUFFContext) + + // EnterSUBSTRING is called when entering the SUBSTRING production. + EnterSUBSTRING(c *SUBSTRINGContext) + + // EnterTRANSLATE is called when entering the TRANSLATE production. + EnterTRANSLATE(c *TRANSLATEContext) + + // EnterTRIM is called when entering the TRIM production. + EnterTRIM(c *TRIMContext) + + // EnterUNICODE is called when entering the UNICODE production. + EnterUNICODE(c *UNICODEContext) + + // EnterUPPER is called when entering the UPPER production. + EnterUPPER(c *UPPERContext) + + // EnterBINARY_CHECKSUM is called when entering the BINARY_CHECKSUM production. + EnterBINARY_CHECKSUM(c *BINARY_CHECKSUMContext) + + // EnterCHECKSUM is called when entering the CHECKSUM production. + EnterCHECKSUM(c *CHECKSUMContext) + + // EnterCOMPRESS is called when entering the COMPRESS production. + EnterCOMPRESS(c *COMPRESSContext) + + // EnterCONNECTIONPROPERTY is called when entering the CONNECTIONPROPERTY production. + EnterCONNECTIONPROPERTY(c *CONNECTIONPROPERTYContext) + + // EnterCONTEXT_INFO is called when entering the CONTEXT_INFO production. + EnterCONTEXT_INFO(c *CONTEXT_INFOContext) + + // EnterCURRENT_REQUEST_ID is called when entering the CURRENT_REQUEST_ID production. + EnterCURRENT_REQUEST_ID(c *CURRENT_REQUEST_IDContext) + + // EnterCURRENT_TRANSACTION_ID is called when entering the CURRENT_TRANSACTION_ID production. + EnterCURRENT_TRANSACTION_ID(c *CURRENT_TRANSACTION_IDContext) + + // EnterDECOMPRESS is called when entering the DECOMPRESS production. + EnterDECOMPRESS(c *DECOMPRESSContext) + + // EnterERROR_LINE is called when entering the ERROR_LINE production. + EnterERROR_LINE(c *ERROR_LINEContext) + + // EnterERROR_MESSAGE is called when entering the ERROR_MESSAGE production. + EnterERROR_MESSAGE(c *ERROR_MESSAGEContext) + + // EnterERROR_NUMBER is called when entering the ERROR_NUMBER production. + EnterERROR_NUMBER(c *ERROR_NUMBERContext) + + // EnterERROR_PROCEDURE is called when entering the ERROR_PROCEDURE production. + EnterERROR_PROCEDURE(c *ERROR_PROCEDUREContext) + + // EnterERROR_SEVERITY is called when entering the ERROR_SEVERITY production. + EnterERROR_SEVERITY(c *ERROR_SEVERITYContext) + + // EnterERROR_STATE is called when entering the ERROR_STATE production. + EnterERROR_STATE(c *ERROR_STATEContext) + + // EnterFORMATMESSAGE is called when entering the FORMATMESSAGE production. + EnterFORMATMESSAGE(c *FORMATMESSAGEContext) + + // EnterGET_FILESTREAM_TRANSACTION_CONTEXT is called when entering the GET_FILESTREAM_TRANSACTION_CONTEXT production. + EnterGET_FILESTREAM_TRANSACTION_CONTEXT(c *GET_FILESTREAM_TRANSACTION_CONTEXTContext) + + // EnterGETANSINULL is called when entering the GETANSINULL production. + EnterGETANSINULL(c *GETANSINULLContext) + + // EnterHOST_ID is called when entering the HOST_ID production. + EnterHOST_ID(c *HOST_IDContext) + + // EnterHOST_NAME is called when entering the HOST_NAME production. + EnterHOST_NAME(c *HOST_NAMEContext) + + // EnterISNULL is called when entering the ISNULL production. + EnterISNULL(c *ISNULLContext) + + // EnterISNUMERIC is called when entering the ISNUMERIC production. + EnterISNUMERIC(c *ISNUMERICContext) + + // EnterMIN_ACTIVE_ROWVERSION is called when entering the MIN_ACTIVE_ROWVERSION production. + EnterMIN_ACTIVE_ROWVERSION(c *MIN_ACTIVE_ROWVERSIONContext) + + // EnterNEWID is called when entering the NEWID production. + EnterNEWID(c *NEWIDContext) + + // EnterNEWSEQUENTIALID is called when entering the NEWSEQUENTIALID production. + EnterNEWSEQUENTIALID(c *NEWSEQUENTIALIDContext) + + // EnterROWCOUNT_BIG is called when entering the ROWCOUNT_BIG production. + EnterROWCOUNT_BIG(c *ROWCOUNT_BIGContext) + + // EnterSESSION_CONTEXT is called when entering the SESSION_CONTEXT production. + EnterSESSION_CONTEXT(c *SESSION_CONTEXTContext) + + // EnterXACT_STATE is called when entering the XACT_STATE production. + EnterXACT_STATE(c *XACT_STATEContext) + + // EnterCAST is called when entering the CAST production. + EnterCAST(c *CASTContext) + + // EnterTRY_CAST is called when entering the TRY_CAST production. + EnterTRY_CAST(c *TRY_CASTContext) + + // EnterCONVERT is called when entering the CONVERT production. + EnterCONVERT(c *CONVERTContext) + + // EnterCOALESCE is called when entering the COALESCE production. + EnterCOALESCE(c *COALESCEContext) + + // EnterCURSOR_ROWS is called when entering the CURSOR_ROWS production. + EnterCURSOR_ROWS(c *CURSOR_ROWSContext) + + // EnterFETCH_STATUS is called when entering the FETCH_STATUS production. + EnterFETCH_STATUS(c *FETCH_STATUSContext) + + // EnterCURSOR_STATUS is called when entering the CURSOR_STATUS production. + EnterCURSOR_STATUS(c *CURSOR_STATUSContext) + + // EnterCERT_ID is called when entering the CERT_ID production. + EnterCERT_ID(c *CERT_IDContext) + + // EnterDATALENGTH is called when entering the DATALENGTH production. + EnterDATALENGTH(c *DATALENGTHContext) + + // EnterIDENT_CURRENT is called when entering the IDENT_CURRENT production. + EnterIDENT_CURRENT(c *IDENT_CURRENTContext) + + // EnterIDENT_INCR is called when entering the IDENT_INCR production. + EnterIDENT_INCR(c *IDENT_INCRContext) + + // EnterIDENT_SEED is called when entering the IDENT_SEED production. + EnterIDENT_SEED(c *IDENT_SEEDContext) + + // EnterIDENTITY is called when entering the IDENTITY production. + EnterIDENTITY(c *IDENTITYContext) + + // EnterSQL_VARIANT_PROPERTY is called when entering the SQL_VARIANT_PROPERTY production. + EnterSQL_VARIANT_PROPERTY(c *SQL_VARIANT_PROPERTYContext) + + // EnterCURRENT_DATE is called when entering the CURRENT_DATE production. + EnterCURRENT_DATE(c *CURRENT_DATEContext) + + // EnterCURRENT_TIMESTAMP is called when entering the CURRENT_TIMESTAMP production. + EnterCURRENT_TIMESTAMP(c *CURRENT_TIMESTAMPContext) + + // EnterCURRENT_TIMEZONE is called when entering the CURRENT_TIMEZONE production. + EnterCURRENT_TIMEZONE(c *CURRENT_TIMEZONEContext) + + // EnterCURRENT_TIMEZONE_ID is called when entering the CURRENT_TIMEZONE_ID production. + EnterCURRENT_TIMEZONE_ID(c *CURRENT_TIMEZONE_IDContext) + + // EnterDATE_BUCKET is called when entering the DATE_BUCKET production. + EnterDATE_BUCKET(c *DATE_BUCKETContext) + + // EnterDATEADD is called when entering the DATEADD production. + EnterDATEADD(c *DATEADDContext) + + // EnterDATEDIFF is called when entering the DATEDIFF production. + EnterDATEDIFF(c *DATEDIFFContext) + + // EnterDATEDIFF_BIG is called when entering the DATEDIFF_BIG production. + EnterDATEDIFF_BIG(c *DATEDIFF_BIGContext) + + // EnterDATEFROMPARTS is called when entering the DATEFROMPARTS production. + EnterDATEFROMPARTS(c *DATEFROMPARTSContext) + + // EnterDATENAME is called when entering the DATENAME production. + EnterDATENAME(c *DATENAMEContext) + + // EnterDATEPART is called when entering the DATEPART production. + EnterDATEPART(c *DATEPARTContext) + + // EnterDATETIME2FROMPARTS is called when entering the DATETIME2FROMPARTS production. + EnterDATETIME2FROMPARTS(c *DATETIME2FROMPARTSContext) + + // EnterDATETIMEFROMPARTS is called when entering the DATETIMEFROMPARTS production. + EnterDATETIMEFROMPARTS(c *DATETIMEFROMPARTSContext) + + // EnterDATETIMEOFFSETFROMPARTS is called when entering the DATETIMEOFFSETFROMPARTS production. + EnterDATETIMEOFFSETFROMPARTS(c *DATETIMEOFFSETFROMPARTSContext) + + // EnterDATETRUNC is called when entering the DATETRUNC production. + EnterDATETRUNC(c *DATETRUNCContext) + + // EnterDAY is called when entering the DAY production. + EnterDAY(c *DAYContext) + + // EnterEOMONTH is called when entering the EOMONTH production. + EnterEOMONTH(c *EOMONTHContext) + + // EnterGETDATE is called when entering the GETDATE production. + EnterGETDATE(c *GETDATEContext) + + // EnterGETUTCDATE is called when entering the GETUTCDATE production. + EnterGETUTCDATE(c *GETUTCDATEContext) + + // EnterISDATE is called when entering the ISDATE production. + EnterISDATE(c *ISDATEContext) + + // EnterMONTH is called when entering the MONTH production. + EnterMONTH(c *MONTHContext) + + // EnterSMALLDATETIMEFROMPARTS is called when entering the SMALLDATETIMEFROMPARTS production. + EnterSMALLDATETIMEFROMPARTS(c *SMALLDATETIMEFROMPARTSContext) + + // EnterSWITCHOFFSET is called when entering the SWITCHOFFSET production. + EnterSWITCHOFFSET(c *SWITCHOFFSETContext) + + // EnterSYSDATETIME is called when entering the SYSDATETIME production. + EnterSYSDATETIME(c *SYSDATETIMEContext) + + // EnterSYSDATETIMEOFFSET is called when entering the SYSDATETIMEOFFSET production. + EnterSYSDATETIMEOFFSET(c *SYSDATETIMEOFFSETContext) + + // EnterSYSUTCDATETIME is called when entering the SYSUTCDATETIME production. + EnterSYSUTCDATETIME(c *SYSUTCDATETIMEContext) + + // EnterTIMEFROMPARTS is called when entering the TIMEFROMPARTS production. + EnterTIMEFROMPARTS(c *TIMEFROMPARTSContext) + + // EnterTODATETIMEOFFSET is called when entering the TODATETIMEOFFSET production. + EnterTODATETIMEOFFSET(c *TODATETIMEOFFSETContext) + + // EnterYEAR is called when entering the YEAR production. + EnterYEAR(c *YEARContext) + + // EnterNULLIF is called when entering the NULLIF production. + EnterNULLIF(c *NULLIFContext) + + // EnterPARSE is called when entering the PARSE production. + EnterPARSE(c *PARSEContext) + + // EnterXML_DATA_TYPE_FUNC is called when entering the XML_DATA_TYPE_FUNC production. + EnterXML_DATA_TYPE_FUNC(c *XML_DATA_TYPE_FUNCContext) + + // EnterIIF is called when entering the IIF production. + EnterIIF(c *IIFContext) + + // EnterISJSON is called when entering the ISJSON production. + EnterISJSON(c *ISJSONContext) + + // EnterJSON_OBJECT is called when entering the JSON_OBJECT production. + EnterJSON_OBJECT(c *JSON_OBJECTContext) + + // EnterJSON_ARRAY is called when entering the JSON_ARRAY production. + EnterJSON_ARRAY(c *JSON_ARRAYContext) + + // EnterJSON_VALUE is called when entering the JSON_VALUE production. + EnterJSON_VALUE(c *JSON_VALUEContext) + + // EnterJSON_QUERY is called when entering the JSON_QUERY production. + EnterJSON_QUERY(c *JSON_QUERYContext) + + // EnterJSON_MODIFY is called when entering the JSON_MODIFY production. + EnterJSON_MODIFY(c *JSON_MODIFYContext) + + // EnterJSON_PATH_EXISTS is called when entering the JSON_PATH_EXISTS production. + EnterJSON_PATH_EXISTS(c *JSON_PATH_EXISTSContext) + + // EnterABS is called when entering the ABS production. + EnterABS(c *ABSContext) + + // EnterACOS is called when entering the ACOS production. + EnterACOS(c *ACOSContext) + + // EnterASIN is called when entering the ASIN production. + EnterASIN(c *ASINContext) + + // EnterATAN is called when entering the ATAN production. + EnterATAN(c *ATANContext) + + // EnterATN2 is called when entering the ATN2 production. + EnterATN2(c *ATN2Context) + + // EnterCEILING is called when entering the CEILING production. + EnterCEILING(c *CEILINGContext) + + // EnterCOS is called when entering the COS production. + EnterCOS(c *COSContext) + + // EnterCOT is called when entering the COT production. + EnterCOT(c *COTContext) + + // EnterDEGREES is called when entering the DEGREES production. + EnterDEGREES(c *DEGREESContext) + + // EnterEXP is called when entering the EXP production. + EnterEXP(c *EXPContext) + + // EnterFLOOR is called when entering the FLOOR production. + EnterFLOOR(c *FLOORContext) + + // EnterLOG is called when entering the LOG production. + EnterLOG(c *LOGContext) + + // EnterLOG10 is called when entering the LOG10 production. + EnterLOG10(c *LOG10Context) + + // EnterPI is called when entering the PI production. + EnterPI(c *PIContext) + + // EnterPOWER is called when entering the POWER production. + EnterPOWER(c *POWERContext) + + // EnterRADIANS is called when entering the RADIANS production. + EnterRADIANS(c *RADIANSContext) + + // EnterRAND is called when entering the RAND production. + EnterRAND(c *RANDContext) + + // EnterROUND is called when entering the ROUND production. + EnterROUND(c *ROUNDContext) + + // EnterMATH_SIGN is called when entering the MATH_SIGN production. + EnterMATH_SIGN(c *MATH_SIGNContext) + + // EnterSIN is called when entering the SIN production. + EnterSIN(c *SINContext) + + // EnterSQRT is called when entering the SQRT production. + EnterSQRT(c *SQRTContext) + + // EnterSQUARE is called when entering the SQUARE production. + EnterSQUARE(c *SQUAREContext) + + // EnterTAN is called when entering the TAN production. + EnterTAN(c *TANContext) + + // EnterGREATEST is called when entering the GREATEST production. + EnterGREATEST(c *GREATESTContext) + + // EnterLEAST is called when entering the LEAST production. + EnterLEAST(c *LEASTContext) + + // EnterCERTENCODED is called when entering the CERTENCODED production. + EnterCERTENCODED(c *CERTENCODEDContext) + + // EnterCERTPRIVATEKEY is called when entering the CERTPRIVATEKEY production. + EnterCERTPRIVATEKEY(c *CERTPRIVATEKEYContext) + + // EnterCURRENT_USER is called when entering the CURRENT_USER production. + EnterCURRENT_USER(c *CURRENT_USERContext) + + // EnterDATABASE_PRINCIPAL_ID is called when entering the DATABASE_PRINCIPAL_ID production. + EnterDATABASE_PRINCIPAL_ID(c *DATABASE_PRINCIPAL_IDContext) + + // EnterHAS_DBACCESS is called when entering the HAS_DBACCESS production. + EnterHAS_DBACCESS(c *HAS_DBACCESSContext) + + // EnterHAS_PERMS_BY_NAME is called when entering the HAS_PERMS_BY_NAME production. + EnterHAS_PERMS_BY_NAME(c *HAS_PERMS_BY_NAMEContext) + + // EnterIS_MEMBER is called when entering the IS_MEMBER production. + EnterIS_MEMBER(c *IS_MEMBERContext) + + // EnterIS_ROLEMEMBER is called when entering the IS_ROLEMEMBER production. + EnterIS_ROLEMEMBER(c *IS_ROLEMEMBERContext) + + // EnterIS_SRVROLEMEMBER is called when entering the IS_SRVROLEMEMBER production. + EnterIS_SRVROLEMEMBER(c *IS_SRVROLEMEMBERContext) + + // EnterLOGINPROPERTY is called when entering the LOGINPROPERTY production. + EnterLOGINPROPERTY(c *LOGINPROPERTYContext) + + // EnterORIGINAL_LOGIN is called when entering the ORIGINAL_LOGIN production. + EnterORIGINAL_LOGIN(c *ORIGINAL_LOGINContext) + + // EnterPERMISSIONS is called when entering the PERMISSIONS production. + EnterPERMISSIONS(c *PERMISSIONSContext) + + // EnterPWDENCRYPT is called when entering the PWDENCRYPT production. + EnterPWDENCRYPT(c *PWDENCRYPTContext) + + // EnterPWDCOMPARE is called when entering the PWDCOMPARE production. + EnterPWDCOMPARE(c *PWDCOMPAREContext) + + // EnterSESSION_USER is called when entering the SESSION_USER production. + EnterSESSION_USER(c *SESSION_USERContext) + + // EnterSESSIONPROPERTY is called when entering the SESSIONPROPERTY production. + EnterSESSIONPROPERTY(c *SESSIONPROPERTYContext) + + // EnterSUSER_ID is called when entering the SUSER_ID production. + EnterSUSER_ID(c *SUSER_IDContext) + + // EnterSUSER_SNAME is called when entering the SUSER_SNAME production. + EnterSUSER_SNAME(c *SUSER_SNAMEContext) + + // EnterSUSER_SID is called when entering the SUSER_SID production. + EnterSUSER_SID(c *SUSER_SIDContext) + + // EnterSYSTEM_USER is called when entering the SYSTEM_USER production. + EnterSYSTEM_USER(c *SYSTEM_USERContext) + + // EnterUSER is called when entering the USER production. + EnterUSER(c *USERContext) + + // EnterUSER_ID is called when entering the USER_ID production. + EnterUSER_ID(c *USER_IDContext) + + // EnterUSER_NAME is called when entering the USER_NAME production. + EnterUSER_NAME(c *USER_NAMEContext) + + // EnterXml_data_type_methods is called when entering the xml_data_type_methods production. + EnterXml_data_type_methods(c *Xml_data_type_methodsContext) + + // EnterDateparts_9 is called when entering the dateparts_9 production. + EnterDateparts_9(c *Dateparts_9Context) + + // EnterDateparts_12 is called when entering the dateparts_12 production. + EnterDateparts_12(c *Dateparts_12Context) + + // EnterDateparts_15 is called when entering the dateparts_15 production. + EnterDateparts_15(c *Dateparts_15Context) + + // EnterDateparts_datetrunc is called when entering the dateparts_datetrunc production. + EnterDateparts_datetrunc(c *Dateparts_datetruncContext) + + // EnterValue_method is called when entering the value_method production. + EnterValue_method(c *Value_methodContext) + + // EnterValue_call is called when entering the value_call production. + EnterValue_call(c *Value_callContext) + + // EnterQuery_method is called when entering the query_method production. + EnterQuery_method(c *Query_methodContext) + + // EnterQuery_call is called when entering the query_call production. + EnterQuery_call(c *Query_callContext) + + // EnterExist_method is called when entering the exist_method production. + EnterExist_method(c *Exist_methodContext) + + // EnterExist_call is called when entering the exist_call production. + EnterExist_call(c *Exist_callContext) + + // EnterModify_method is called when entering the modify_method production. + EnterModify_method(c *Modify_methodContext) + + // EnterModify_call is called when entering the modify_call production. + EnterModify_call(c *Modify_callContext) + + // EnterHierarchyid_call is called when entering the hierarchyid_call production. + EnterHierarchyid_call(c *Hierarchyid_callContext) + + // EnterHierarchyid_static_method is called when entering the hierarchyid_static_method production. + EnterHierarchyid_static_method(c *Hierarchyid_static_methodContext) + + // EnterNodes_method is called when entering the nodes_method production. + EnterNodes_method(c *Nodes_methodContext) + + // EnterSwitch_section is called when entering the switch_section production. + EnterSwitch_section(c *Switch_sectionContext) + + // EnterSwitch_search_condition_section is called when entering the switch_search_condition_section production. + EnterSwitch_search_condition_section(c *Switch_search_condition_sectionContext) + + // EnterAs_column_alias is called when entering the as_column_alias production. + EnterAs_column_alias(c *As_column_aliasContext) + + // EnterAs_table_alias is called when entering the as_table_alias production. + EnterAs_table_alias(c *As_table_aliasContext) + + // EnterTable_alias is called when entering the table_alias production. + EnterTable_alias(c *Table_aliasContext) + + // EnterWith_table_hints is called when entering the with_table_hints production. + EnterWith_table_hints(c *With_table_hintsContext) + + // EnterDeprecated_table_hint is called when entering the deprecated_table_hint production. + EnterDeprecated_table_hint(c *Deprecated_table_hintContext) + + // EnterSybase_legacy_hints is called when entering the sybase_legacy_hints production. + EnterSybase_legacy_hints(c *Sybase_legacy_hintsContext) + + // EnterSybase_legacy_hint is called when entering the sybase_legacy_hint production. + EnterSybase_legacy_hint(c *Sybase_legacy_hintContext) + + // EnterTable_hint is called when entering the table_hint production. + EnterTable_hint(c *Table_hintContext) + + // EnterIndex_value is called when entering the index_value production. + EnterIndex_value(c *Index_valueContext) + + // EnterColumn_alias_list is called when entering the column_alias_list production. + EnterColumn_alias_list(c *Column_alias_listContext) + + // EnterColumn_alias is called when entering the column_alias production. + EnterColumn_alias(c *Column_aliasContext) + + // EnterTable_value_constructor is called when entering the table_value_constructor production. + EnterTable_value_constructor(c *Table_value_constructorContext) + + // EnterExpression_list_ is called when entering the expression_list_ production. + EnterExpression_list_(c *Expression_list_Context) + + // EnterRanking_windowed_function is called when entering the ranking_windowed_function production. + EnterRanking_windowed_function(c *Ranking_windowed_functionContext) + + // EnterAggregate_windowed_function is called when entering the aggregate_windowed_function production. + EnterAggregate_windowed_function(c *Aggregate_windowed_functionContext) + + // EnterAnalytic_windowed_function is called when entering the analytic_windowed_function production. + EnterAnalytic_windowed_function(c *Analytic_windowed_functionContext) + + // EnterAll_distinct_expression is called when entering the all_distinct_expression production. + EnterAll_distinct_expression(c *All_distinct_expressionContext) + + // EnterOver_clause is called when entering the over_clause production. + EnterOver_clause(c *Over_clauseContext) + + // EnterRow_or_range_clause is called when entering the row_or_range_clause production. + EnterRow_or_range_clause(c *Row_or_range_clauseContext) + + // EnterWindow_frame_extent is called when entering the window_frame_extent production. + EnterWindow_frame_extent(c *Window_frame_extentContext) + + // EnterWindow_frame_bound is called when entering the window_frame_bound production. + EnterWindow_frame_bound(c *Window_frame_boundContext) + + // EnterWindow_frame_preceding is called when entering the window_frame_preceding production. + EnterWindow_frame_preceding(c *Window_frame_precedingContext) + + // EnterWindow_frame_following is called when entering the window_frame_following production. + EnterWindow_frame_following(c *Window_frame_followingContext) + + // EnterCreate_database_option is called when entering the create_database_option production. + EnterCreate_database_option(c *Create_database_optionContext) + + // EnterDatabase_filestream_option is called when entering the database_filestream_option production. + EnterDatabase_filestream_option(c *Database_filestream_optionContext) + + // EnterDatabase_file_spec is called when entering the database_file_spec production. + EnterDatabase_file_spec(c *Database_file_specContext) + + // EnterFile_group is called when entering the file_group production. + EnterFile_group(c *File_groupContext) + + // EnterFile_spec is called when entering the file_spec production. + EnterFile_spec(c *File_specContext) + + // EnterEntity_name is called when entering the entity_name production. + EnterEntity_name(c *Entity_nameContext) + + // EnterEntity_name_for_azure_dw is called when entering the entity_name_for_azure_dw production. + EnterEntity_name_for_azure_dw(c *Entity_name_for_azure_dwContext) + + // EnterEntity_name_for_parallel_dw is called when entering the entity_name_for_parallel_dw production. + EnterEntity_name_for_parallel_dw(c *Entity_name_for_parallel_dwContext) + + // EnterFull_table_name is called when entering the full_table_name production. + EnterFull_table_name(c *Full_table_nameContext) + + // EnterDotID is called when entering the dotID production. + EnterDotID(c *DotIDContext) + + // EnterDoubleDotID is called when entering the doubleDotID production. + EnterDoubleDotID(c *DoubleDotIDContext) + + // EnterTable_name is called when entering the table_name production. + EnterTable_name(c *Table_nameContext) + + // EnterSimple_name is called when entering the simple_name production. + EnterSimple_name(c *Simple_nameContext) + + // EnterFunc_proc_name_schema is called when entering the func_proc_name_schema production. + EnterFunc_proc_name_schema(c *Func_proc_name_schemaContext) + + // EnterFunc_proc_name_database_schema is called when entering the func_proc_name_database_schema production. + EnterFunc_proc_name_database_schema(c *Func_proc_name_database_schemaContext) + + // EnterFunc_proc_name_server_database_schema is called when entering the func_proc_name_server_database_schema production. + EnterFunc_proc_name_server_database_schema(c *Func_proc_name_server_database_schemaContext) + + // EnterDdl_object is called when entering the ddl_object production. + EnterDdl_object(c *Ddl_objectContext) + + // EnterFull_column_name is called when entering the full_column_name production. + EnterFull_column_name(c *Full_column_nameContext) + + // EnterColumn_name_list_with_order is called when entering the column_name_list_with_order production. + EnterColumn_name_list_with_order(c *Column_name_list_with_orderContext) + + // EnterColumn_name_with_order is called when entering the column_name_with_order production. + EnterColumn_name_with_order(c *Column_name_with_orderContext) + + // EnterInsert_column_name_list is called when entering the insert_column_name_list production. + EnterInsert_column_name_list(c *Insert_column_name_listContext) + + // EnterInsert_column_id is called when entering the insert_column_id production. + EnterInsert_column_id(c *Insert_column_idContext) + + // EnterColumn_name_list is called when entering the column_name_list production. + EnterColumn_name_list(c *Column_name_listContext) + + // EnterCursor_name is called when entering the cursor_name production. + EnterCursor_name(c *Cursor_nameContext) + + // EnterOn_off is called when entering the on_off production. + EnterOn_off(c *On_offContext) + + // EnterClustered is called when entering the clustered production. + EnterClustered(c *ClusteredContext) + + // EnterNull_notnull is called when entering the null_notnull production. + EnterNull_notnull(c *Null_notnullContext) + + // EnterScalar_function_name is called when entering the scalar_function_name production. + EnterScalar_function_name(c *Scalar_function_nameContext) + + // EnterBegin_conversation_timer is called when entering the begin_conversation_timer production. + EnterBegin_conversation_timer(c *Begin_conversation_timerContext) + + // EnterBegin_conversation_dialog is called when entering the begin_conversation_dialog production. + EnterBegin_conversation_dialog(c *Begin_conversation_dialogContext) + + // EnterContract_name is called when entering the contract_name production. + EnterContract_name(c *Contract_nameContext) + + // EnterService_name is called when entering the service_name production. + EnterService_name(c *Service_nameContext) + + // EnterEnd_conversation is called when entering the end_conversation production. + EnterEnd_conversation(c *End_conversationContext) + + // EnterWaitfor_conversation is called when entering the waitfor_conversation production. + EnterWaitfor_conversation(c *Waitfor_conversationContext) + + // EnterGet_conversation is called when entering the get_conversation production. + EnterGet_conversation(c *Get_conversationContext) + + // EnterQueue_id is called when entering the queue_id production. + EnterQueue_id(c *Queue_idContext) + + // EnterSend_conversation is called when entering the send_conversation production. + EnterSend_conversation(c *Send_conversationContext) + + // EnterData_type is called when entering the data_type production. + EnterData_type(c *Data_typeContext) + + // EnterConstant is called when entering the constant production. + EnterConstant(c *ConstantContext) + + // EnterPrimitive_constant is called when entering the primitive_constant production. + EnterPrimitive_constant(c *Primitive_constantContext) + + // EnterKeyword is called when entering the keyword production. + EnterKeyword(c *KeywordContext) + + // EnterId_ is called when entering the id_ production. + EnterId_(c *Id_Context) + + // EnterSimple_id is called when entering the simple_id production. + EnterSimple_id(c *Simple_idContext) + + // EnterId_or_string is called when entering the id_or_string production. + EnterId_or_string(c *Id_or_stringContext) + + // EnterComparison_operator is called when entering the comparison_operator production. + EnterComparison_operator(c *Comparison_operatorContext) + + // EnterAssignment_operator is called when entering the assignment_operator production. + EnterAssignment_operator(c *Assignment_operatorContext) + + // EnterFile_size is called when entering the file_size production. + EnterFile_size(c *File_sizeContext) + + // ExitTsql_file is called when exiting the tsql_file production. + ExitTsql_file(c *Tsql_fileContext) + + // ExitBatch_without_go is called when exiting the batch_without_go production. + ExitBatch_without_go(c *Batch_without_goContext) + + // ExitBatch_level_statement is called when exiting the batch_level_statement production. + ExitBatch_level_statement(c *Batch_level_statementContext) + + // ExitSql_clauses is called when exiting the sql_clauses production. + ExitSql_clauses(c *Sql_clausesContext) + + // ExitDml_clause is called when exiting the dml_clause production. + ExitDml_clause(c *Dml_clauseContext) + + // ExitDdl_clause is called when exiting the ddl_clause production. + ExitDdl_clause(c *Ddl_clauseContext) + + // ExitBackup_statement is called when exiting the backup_statement production. + ExitBackup_statement(c *Backup_statementContext) + + // ExitCfl_statement is called when exiting the cfl_statement production. + ExitCfl_statement(c *Cfl_statementContext) + + // ExitBlock_statement is called when exiting the block_statement production. + ExitBlock_statement(c *Block_statementContext) + + // ExitBreak_statement is called when exiting the break_statement production. + ExitBreak_statement(c *Break_statementContext) + + // ExitContinue_statement is called when exiting the continue_statement production. + ExitContinue_statement(c *Continue_statementContext) + + // ExitGoto_statement is called when exiting the goto_statement production. + ExitGoto_statement(c *Goto_statementContext) + + // ExitReturn_statement is called when exiting the return_statement production. + ExitReturn_statement(c *Return_statementContext) + + // ExitIf_statement is called when exiting the if_statement production. + ExitIf_statement(c *If_statementContext) + + // ExitThrow_statement is called when exiting the throw_statement production. + ExitThrow_statement(c *Throw_statementContext) + + // ExitThrow_error_number is called when exiting the throw_error_number production. + ExitThrow_error_number(c *Throw_error_numberContext) + + // ExitThrow_message is called when exiting the throw_message production. + ExitThrow_message(c *Throw_messageContext) + + // ExitThrow_state is called when exiting the throw_state production. + ExitThrow_state(c *Throw_stateContext) + + // ExitTry_catch_statement is called when exiting the try_catch_statement production. + ExitTry_catch_statement(c *Try_catch_statementContext) + + // ExitWaitfor_statement is called when exiting the waitfor_statement production. + ExitWaitfor_statement(c *Waitfor_statementContext) + + // ExitWhile_statement is called when exiting the while_statement production. + ExitWhile_statement(c *While_statementContext) + + // ExitPrint_statement is called when exiting the print_statement production. + ExitPrint_statement(c *Print_statementContext) + + // ExitRaiseerror_statement is called when exiting the raiseerror_statement production. + ExitRaiseerror_statement(c *Raiseerror_statementContext) + + // ExitEmpty_statement is called when exiting the empty_statement production. + ExitEmpty_statement(c *Empty_statementContext) + + // ExitAnother_statement is called when exiting the another_statement production. + ExitAnother_statement(c *Another_statementContext) + + // ExitAlter_application_role is called when exiting the alter_application_role production. + ExitAlter_application_role(c *Alter_application_roleContext) + + // ExitAlter_xml_schema_collection is called when exiting the alter_xml_schema_collection production. + ExitAlter_xml_schema_collection(c *Alter_xml_schema_collectionContext) + + // ExitCreate_application_role is called when exiting the create_application_role production. + ExitCreate_application_role(c *Create_application_roleContext) + + // ExitDrop_aggregate is called when exiting the drop_aggregate production. + ExitDrop_aggregate(c *Drop_aggregateContext) + + // ExitDrop_application_role is called when exiting the drop_application_role production. + ExitDrop_application_role(c *Drop_application_roleContext) + + // ExitAlter_assembly is called when exiting the alter_assembly production. + ExitAlter_assembly(c *Alter_assemblyContext) + + // ExitAlter_assembly_start is called when exiting the alter_assembly_start production. + ExitAlter_assembly_start(c *Alter_assembly_startContext) + + // ExitAlter_assembly_clause is called when exiting the alter_assembly_clause production. + ExitAlter_assembly_clause(c *Alter_assembly_clauseContext) + + // ExitAlter_assembly_from_clause is called when exiting the alter_assembly_from_clause production. + ExitAlter_assembly_from_clause(c *Alter_assembly_from_clauseContext) + + // ExitAlter_assembly_from_clause_start is called when exiting the alter_assembly_from_clause_start production. + ExitAlter_assembly_from_clause_start(c *Alter_assembly_from_clause_startContext) + + // ExitAlter_assembly_drop_clause is called when exiting the alter_assembly_drop_clause production. + ExitAlter_assembly_drop_clause(c *Alter_assembly_drop_clauseContext) + + // ExitAlter_assembly_drop_multiple_files is called when exiting the alter_assembly_drop_multiple_files production. + ExitAlter_assembly_drop_multiple_files(c *Alter_assembly_drop_multiple_filesContext) + + // ExitAlter_assembly_drop is called when exiting the alter_assembly_drop production. + ExitAlter_assembly_drop(c *Alter_assembly_dropContext) + + // ExitAlter_assembly_add_clause is called when exiting the alter_assembly_add_clause production. + ExitAlter_assembly_add_clause(c *Alter_assembly_add_clauseContext) + + // ExitAlter_asssembly_add_clause_start is called when exiting the alter_asssembly_add_clause_start production. + ExitAlter_asssembly_add_clause_start(c *Alter_asssembly_add_clause_startContext) + + // ExitAlter_assembly_client_file_clause is called when exiting the alter_assembly_client_file_clause production. + ExitAlter_assembly_client_file_clause(c *Alter_assembly_client_file_clauseContext) + + // ExitAlter_assembly_file_name is called when exiting the alter_assembly_file_name production. + ExitAlter_assembly_file_name(c *Alter_assembly_file_nameContext) + + // ExitAlter_assembly_file_bits is called when exiting the alter_assembly_file_bits production. + ExitAlter_assembly_file_bits(c *Alter_assembly_file_bitsContext) + + // ExitAlter_assembly_as is called when exiting the alter_assembly_as production. + ExitAlter_assembly_as(c *Alter_assembly_asContext) + + // ExitAlter_assembly_with_clause is called when exiting the alter_assembly_with_clause production. + ExitAlter_assembly_with_clause(c *Alter_assembly_with_clauseContext) + + // ExitAlter_assembly_with is called when exiting the alter_assembly_with production. + ExitAlter_assembly_with(c *Alter_assembly_withContext) + + // ExitClient_assembly_specifier is called when exiting the client_assembly_specifier production. + ExitClient_assembly_specifier(c *Client_assembly_specifierContext) + + // ExitAssembly_option is called when exiting the assembly_option production. + ExitAssembly_option(c *Assembly_optionContext) + + // ExitNetwork_file_share is called when exiting the network_file_share production. + ExitNetwork_file_share(c *Network_file_shareContext) + + // ExitNetwork_computer is called when exiting the network_computer production. + ExitNetwork_computer(c *Network_computerContext) + + // ExitNetwork_file_start is called when exiting the network_file_start production. + ExitNetwork_file_start(c *Network_file_startContext) + + // ExitFile_path is called when exiting the file_path production. + ExitFile_path(c *File_pathContext) + + // ExitFile_directory_path_separator is called when exiting the file_directory_path_separator production. + ExitFile_directory_path_separator(c *File_directory_path_separatorContext) + + // ExitLocal_file is called when exiting the local_file production. + ExitLocal_file(c *Local_fileContext) + + // ExitLocal_drive is called when exiting the local_drive production. + ExitLocal_drive(c *Local_driveContext) + + // ExitMultiple_local_files is called when exiting the multiple_local_files production. + ExitMultiple_local_files(c *Multiple_local_filesContext) + + // ExitMultiple_local_file_start is called when exiting the multiple_local_file_start production. + ExitMultiple_local_file_start(c *Multiple_local_file_startContext) + + // ExitCreate_assembly is called when exiting the create_assembly production. + ExitCreate_assembly(c *Create_assemblyContext) + + // ExitDrop_assembly is called when exiting the drop_assembly production. + ExitDrop_assembly(c *Drop_assemblyContext) + + // ExitAlter_asymmetric_key is called when exiting the alter_asymmetric_key production. + ExitAlter_asymmetric_key(c *Alter_asymmetric_keyContext) + + // ExitAlter_asymmetric_key_start is called when exiting the alter_asymmetric_key_start production. + ExitAlter_asymmetric_key_start(c *Alter_asymmetric_key_startContext) + + // ExitAsymmetric_key_option is called when exiting the asymmetric_key_option production. + ExitAsymmetric_key_option(c *Asymmetric_key_optionContext) + + // ExitAsymmetric_key_option_start is called when exiting the asymmetric_key_option_start production. + ExitAsymmetric_key_option_start(c *Asymmetric_key_option_startContext) + + // ExitAsymmetric_key_password_change_option is called when exiting the asymmetric_key_password_change_option production. + ExitAsymmetric_key_password_change_option(c *Asymmetric_key_password_change_optionContext) + + // ExitCreate_asymmetric_key is called when exiting the create_asymmetric_key production. + ExitCreate_asymmetric_key(c *Create_asymmetric_keyContext) + + // ExitDrop_asymmetric_key is called when exiting the drop_asymmetric_key production. + ExitDrop_asymmetric_key(c *Drop_asymmetric_keyContext) + + // ExitAlter_authorization is called when exiting the alter_authorization production. + ExitAlter_authorization(c *Alter_authorizationContext) + + // ExitAuthorization_grantee is called when exiting the authorization_grantee production. + ExitAuthorization_grantee(c *Authorization_granteeContext) + + // ExitEntity_to is called when exiting the entity_to production. + ExitEntity_to(c *Entity_toContext) + + // ExitColon_colon is called when exiting the colon_colon production. + ExitColon_colon(c *Colon_colonContext) + + // ExitAlter_authorization_start is called when exiting the alter_authorization_start production. + ExitAlter_authorization_start(c *Alter_authorization_startContext) + + // ExitAlter_authorization_for_sql_database is called when exiting the alter_authorization_for_sql_database production. + ExitAlter_authorization_for_sql_database(c *Alter_authorization_for_sql_databaseContext) + + // ExitAlter_authorization_for_azure_dw is called when exiting the alter_authorization_for_azure_dw production. + ExitAlter_authorization_for_azure_dw(c *Alter_authorization_for_azure_dwContext) + + // ExitAlter_authorization_for_parallel_dw is called when exiting the alter_authorization_for_parallel_dw production. + ExitAlter_authorization_for_parallel_dw(c *Alter_authorization_for_parallel_dwContext) + + // ExitClass_type is called when exiting the class_type production. + ExitClass_type(c *Class_typeContext) + + // ExitClass_type_for_sql_database is called when exiting the class_type_for_sql_database production. + ExitClass_type_for_sql_database(c *Class_type_for_sql_databaseContext) + + // ExitClass_type_for_azure_dw is called when exiting the class_type_for_azure_dw production. + ExitClass_type_for_azure_dw(c *Class_type_for_azure_dwContext) + + // ExitClass_type_for_parallel_dw is called when exiting the class_type_for_parallel_dw production. + ExitClass_type_for_parallel_dw(c *Class_type_for_parallel_dwContext) + + // ExitClass_type_for_grant is called when exiting the class_type_for_grant production. + ExitClass_type_for_grant(c *Class_type_for_grantContext) + + // ExitDrop_availability_group is called when exiting the drop_availability_group production. + ExitDrop_availability_group(c *Drop_availability_groupContext) + + // ExitAlter_availability_group is called when exiting the alter_availability_group production. + ExitAlter_availability_group(c *Alter_availability_groupContext) + + // ExitAlter_availability_group_start is called when exiting the alter_availability_group_start production. + ExitAlter_availability_group_start(c *Alter_availability_group_startContext) + + // ExitAlter_availability_group_options is called when exiting the alter_availability_group_options production. + ExitAlter_availability_group_options(c *Alter_availability_group_optionsContext) + + // ExitIp_v4_failover is called when exiting the ip_v4_failover production. + ExitIp_v4_failover(c *Ip_v4_failoverContext) + + // ExitIp_v6_failover is called when exiting the ip_v6_failover production. + ExitIp_v6_failover(c *Ip_v6_failoverContext) + + // ExitCreate_or_alter_broker_priority is called when exiting the create_or_alter_broker_priority production. + ExitCreate_or_alter_broker_priority(c *Create_or_alter_broker_priorityContext) + + // ExitDrop_broker_priority is called when exiting the drop_broker_priority production. + ExitDrop_broker_priority(c *Drop_broker_priorityContext) + + // ExitAlter_certificate is called when exiting the alter_certificate production. + ExitAlter_certificate(c *Alter_certificateContext) + + // ExitAlter_column_encryption_key is called when exiting the alter_column_encryption_key production. + ExitAlter_column_encryption_key(c *Alter_column_encryption_keyContext) + + // ExitCreate_column_encryption_key is called when exiting the create_column_encryption_key production. + ExitCreate_column_encryption_key(c *Create_column_encryption_keyContext) + + // ExitDrop_certificate is called when exiting the drop_certificate production. + ExitDrop_certificate(c *Drop_certificateContext) + + // ExitDrop_column_encryption_key is called when exiting the drop_column_encryption_key production. + ExitDrop_column_encryption_key(c *Drop_column_encryption_keyContext) + + // ExitDrop_column_master_key is called when exiting the drop_column_master_key production. + ExitDrop_column_master_key(c *Drop_column_master_keyContext) + + // ExitDrop_contract is called when exiting the drop_contract production. + ExitDrop_contract(c *Drop_contractContext) + + // ExitDrop_credential is called when exiting the drop_credential production. + ExitDrop_credential(c *Drop_credentialContext) + + // ExitDrop_cryptograhic_provider is called when exiting the drop_cryptograhic_provider production. + ExitDrop_cryptograhic_provider(c *Drop_cryptograhic_providerContext) + + // ExitDrop_database is called when exiting the drop_database production. + ExitDrop_database(c *Drop_databaseContext) + + // ExitDrop_database_audit_specification is called when exiting the drop_database_audit_specification production. + ExitDrop_database_audit_specification(c *Drop_database_audit_specificationContext) + + // ExitDrop_database_encryption_key is called when exiting the drop_database_encryption_key production. + ExitDrop_database_encryption_key(c *Drop_database_encryption_keyContext) + + // ExitDrop_database_scoped_credential is called when exiting the drop_database_scoped_credential production. + ExitDrop_database_scoped_credential(c *Drop_database_scoped_credentialContext) + + // ExitDrop_default is called when exiting the drop_default production. + ExitDrop_default(c *Drop_defaultContext) + + // ExitDrop_endpoint is called when exiting the drop_endpoint production. + ExitDrop_endpoint(c *Drop_endpointContext) + + // ExitDrop_external_data_source is called when exiting the drop_external_data_source production. + ExitDrop_external_data_source(c *Drop_external_data_sourceContext) + + // ExitDrop_external_file_format is called when exiting the drop_external_file_format production. + ExitDrop_external_file_format(c *Drop_external_file_formatContext) + + // ExitDrop_external_library is called when exiting the drop_external_library production. + ExitDrop_external_library(c *Drop_external_libraryContext) + + // ExitDrop_external_resource_pool is called when exiting the drop_external_resource_pool production. + ExitDrop_external_resource_pool(c *Drop_external_resource_poolContext) + + // ExitDrop_external_table is called when exiting the drop_external_table production. + ExitDrop_external_table(c *Drop_external_tableContext) + + // ExitDrop_event_notifications is called when exiting the drop_event_notifications production. + ExitDrop_event_notifications(c *Drop_event_notificationsContext) + + // ExitDrop_event_session is called when exiting the drop_event_session production. + ExitDrop_event_session(c *Drop_event_sessionContext) + + // ExitDrop_fulltext_catalog is called when exiting the drop_fulltext_catalog production. + ExitDrop_fulltext_catalog(c *Drop_fulltext_catalogContext) + + // ExitDrop_fulltext_index is called when exiting the drop_fulltext_index production. + ExitDrop_fulltext_index(c *Drop_fulltext_indexContext) + + // ExitDrop_fulltext_stoplist is called when exiting the drop_fulltext_stoplist production. + ExitDrop_fulltext_stoplist(c *Drop_fulltext_stoplistContext) + + // ExitDrop_login is called when exiting the drop_login production. + ExitDrop_login(c *Drop_loginContext) + + // ExitDrop_master_key is called when exiting the drop_master_key production. + ExitDrop_master_key(c *Drop_master_keyContext) + + // ExitDrop_message_type is called when exiting the drop_message_type production. + ExitDrop_message_type(c *Drop_message_typeContext) + + // ExitDrop_partition_function is called when exiting the drop_partition_function production. + ExitDrop_partition_function(c *Drop_partition_functionContext) + + // ExitDrop_partition_scheme is called when exiting the drop_partition_scheme production. + ExitDrop_partition_scheme(c *Drop_partition_schemeContext) + + // ExitDrop_queue is called when exiting the drop_queue production. + ExitDrop_queue(c *Drop_queueContext) + + // ExitDrop_remote_service_binding is called when exiting the drop_remote_service_binding production. + ExitDrop_remote_service_binding(c *Drop_remote_service_bindingContext) + + // ExitDrop_resource_pool is called when exiting the drop_resource_pool production. + ExitDrop_resource_pool(c *Drop_resource_poolContext) + + // ExitDrop_db_role is called when exiting the drop_db_role production. + ExitDrop_db_role(c *Drop_db_roleContext) + + // ExitDrop_route is called when exiting the drop_route production. + ExitDrop_route(c *Drop_routeContext) + + // ExitDrop_rule is called when exiting the drop_rule production. + ExitDrop_rule(c *Drop_ruleContext) + + // ExitDrop_schema is called when exiting the drop_schema production. + ExitDrop_schema(c *Drop_schemaContext) + + // ExitDrop_search_property_list is called when exiting the drop_search_property_list production. + ExitDrop_search_property_list(c *Drop_search_property_listContext) + + // ExitDrop_security_policy is called when exiting the drop_security_policy production. + ExitDrop_security_policy(c *Drop_security_policyContext) + + // ExitDrop_sequence is called when exiting the drop_sequence production. + ExitDrop_sequence(c *Drop_sequenceContext) + + // ExitDrop_server_audit is called when exiting the drop_server_audit production. + ExitDrop_server_audit(c *Drop_server_auditContext) + + // ExitDrop_server_audit_specification is called when exiting the drop_server_audit_specification production. + ExitDrop_server_audit_specification(c *Drop_server_audit_specificationContext) + + // ExitDrop_server_role is called when exiting the drop_server_role production. + ExitDrop_server_role(c *Drop_server_roleContext) + + // ExitDrop_service is called when exiting the drop_service production. + ExitDrop_service(c *Drop_serviceContext) + + // ExitDrop_signature is called when exiting the drop_signature production. + ExitDrop_signature(c *Drop_signatureContext) + + // ExitDrop_statistics_name_azure_dw_and_pdw is called when exiting the drop_statistics_name_azure_dw_and_pdw production. + ExitDrop_statistics_name_azure_dw_and_pdw(c *Drop_statistics_name_azure_dw_and_pdwContext) + + // ExitDrop_symmetric_key is called when exiting the drop_symmetric_key production. + ExitDrop_symmetric_key(c *Drop_symmetric_keyContext) + + // ExitDrop_synonym is called when exiting the drop_synonym production. + ExitDrop_synonym(c *Drop_synonymContext) + + // ExitDrop_user is called when exiting the drop_user production. + ExitDrop_user(c *Drop_userContext) + + // ExitDrop_workload_group is called when exiting the drop_workload_group production. + ExitDrop_workload_group(c *Drop_workload_groupContext) + + // ExitDrop_xml_schema_collection is called when exiting the drop_xml_schema_collection production. + ExitDrop_xml_schema_collection(c *Drop_xml_schema_collectionContext) + + // ExitDisable_trigger is called when exiting the disable_trigger production. + ExitDisable_trigger(c *Disable_triggerContext) + + // ExitEnable_trigger is called when exiting the enable_trigger production. + ExitEnable_trigger(c *Enable_triggerContext) + + // ExitLock_table is called when exiting the lock_table production. + ExitLock_table(c *Lock_tableContext) + + // ExitTruncate_table is called when exiting the truncate_table production. + ExitTruncate_table(c *Truncate_tableContext) + + // ExitCreate_column_master_key is called when exiting the create_column_master_key production. + ExitCreate_column_master_key(c *Create_column_master_keyContext) + + // ExitAlter_credential is called when exiting the alter_credential production. + ExitAlter_credential(c *Alter_credentialContext) + + // ExitCreate_credential is called when exiting the create_credential production. + ExitCreate_credential(c *Create_credentialContext) + + // ExitAlter_cryptographic_provider is called when exiting the alter_cryptographic_provider production. + ExitAlter_cryptographic_provider(c *Alter_cryptographic_providerContext) + + // ExitCreate_cryptographic_provider is called when exiting the create_cryptographic_provider production. + ExitCreate_cryptographic_provider(c *Create_cryptographic_providerContext) + + // ExitCreate_endpoint is called when exiting the create_endpoint production. + ExitCreate_endpoint(c *Create_endpointContext) + + // ExitEndpoint_encryption_alogorithm_clause is called when exiting the endpoint_encryption_alogorithm_clause production. + ExitEndpoint_encryption_alogorithm_clause(c *Endpoint_encryption_alogorithm_clauseContext) + + // ExitEndpoint_authentication_clause is called when exiting the endpoint_authentication_clause production. + ExitEndpoint_authentication_clause(c *Endpoint_authentication_clauseContext) + + // ExitEndpoint_listener_clause is called when exiting the endpoint_listener_clause production. + ExitEndpoint_listener_clause(c *Endpoint_listener_clauseContext) + + // ExitCreate_event_notification is called when exiting the create_event_notification production. + ExitCreate_event_notification(c *Create_event_notificationContext) + + // ExitCreate_or_alter_event_session is called when exiting the create_or_alter_event_session production. + ExitCreate_or_alter_event_session(c *Create_or_alter_event_sessionContext) + + // ExitEvent_session_predicate_expression is called when exiting the event_session_predicate_expression production. + ExitEvent_session_predicate_expression(c *Event_session_predicate_expressionContext) + + // ExitEvent_session_predicate_factor is called when exiting the event_session_predicate_factor production. + ExitEvent_session_predicate_factor(c *Event_session_predicate_factorContext) + + // ExitEvent_session_predicate_leaf is called when exiting the event_session_predicate_leaf production. + ExitEvent_session_predicate_leaf(c *Event_session_predicate_leafContext) + + // ExitAlter_external_data_source is called when exiting the alter_external_data_source production. + ExitAlter_external_data_source(c *Alter_external_data_sourceContext) + + // ExitAlter_external_library is called when exiting the alter_external_library production. + ExitAlter_external_library(c *Alter_external_libraryContext) + + // ExitCreate_external_library is called when exiting the create_external_library production. + ExitCreate_external_library(c *Create_external_libraryContext) + + // ExitAlter_external_resource_pool is called when exiting the alter_external_resource_pool production. + ExitAlter_external_resource_pool(c *Alter_external_resource_poolContext) + + // ExitCreate_external_resource_pool is called when exiting the create_external_resource_pool production. + ExitCreate_external_resource_pool(c *Create_external_resource_poolContext) + + // ExitAlter_fulltext_catalog is called when exiting the alter_fulltext_catalog production. + ExitAlter_fulltext_catalog(c *Alter_fulltext_catalogContext) + + // ExitCreate_fulltext_catalog is called when exiting the create_fulltext_catalog production. + ExitCreate_fulltext_catalog(c *Create_fulltext_catalogContext) + + // ExitAlter_fulltext_stoplist is called when exiting the alter_fulltext_stoplist production. + ExitAlter_fulltext_stoplist(c *Alter_fulltext_stoplistContext) + + // ExitCreate_fulltext_stoplist is called when exiting the create_fulltext_stoplist production. + ExitCreate_fulltext_stoplist(c *Create_fulltext_stoplistContext) + + // ExitAlter_login_sql_server is called when exiting the alter_login_sql_server production. + ExitAlter_login_sql_server(c *Alter_login_sql_serverContext) + + // ExitCreate_login_sql_server is called when exiting the create_login_sql_server production. + ExitCreate_login_sql_server(c *Create_login_sql_serverContext) + + // ExitAlter_login_azure_sql is called when exiting the alter_login_azure_sql production. + ExitAlter_login_azure_sql(c *Alter_login_azure_sqlContext) + + // ExitCreate_login_azure_sql is called when exiting the create_login_azure_sql production. + ExitCreate_login_azure_sql(c *Create_login_azure_sqlContext) + + // ExitAlter_login_azure_sql_dw_and_pdw is called when exiting the alter_login_azure_sql_dw_and_pdw production. + ExitAlter_login_azure_sql_dw_and_pdw(c *Alter_login_azure_sql_dw_and_pdwContext) + + // ExitCreate_login_pdw is called when exiting the create_login_pdw production. + ExitCreate_login_pdw(c *Create_login_pdwContext) + + // ExitAlter_master_key_sql_server is called when exiting the alter_master_key_sql_server production. + ExitAlter_master_key_sql_server(c *Alter_master_key_sql_serverContext) + + // ExitCreate_master_key_sql_server is called when exiting the create_master_key_sql_server production. + ExitCreate_master_key_sql_server(c *Create_master_key_sql_serverContext) + + // ExitAlter_master_key_azure_sql is called when exiting the alter_master_key_azure_sql production. + ExitAlter_master_key_azure_sql(c *Alter_master_key_azure_sqlContext) + + // ExitCreate_master_key_azure_sql is called when exiting the create_master_key_azure_sql production. + ExitCreate_master_key_azure_sql(c *Create_master_key_azure_sqlContext) + + // ExitAlter_message_type is called when exiting the alter_message_type production. + ExitAlter_message_type(c *Alter_message_typeContext) + + // ExitAlter_partition_function is called when exiting the alter_partition_function production. + ExitAlter_partition_function(c *Alter_partition_functionContext) + + // ExitAlter_partition_scheme is called when exiting the alter_partition_scheme production. + ExitAlter_partition_scheme(c *Alter_partition_schemeContext) + + // ExitAlter_remote_service_binding is called when exiting the alter_remote_service_binding production. + ExitAlter_remote_service_binding(c *Alter_remote_service_bindingContext) + + // ExitCreate_remote_service_binding is called when exiting the create_remote_service_binding production. + ExitCreate_remote_service_binding(c *Create_remote_service_bindingContext) + + // ExitCreate_resource_pool is called when exiting the create_resource_pool production. + ExitCreate_resource_pool(c *Create_resource_poolContext) + + // ExitAlter_resource_governor is called when exiting the alter_resource_governor production. + ExitAlter_resource_governor(c *Alter_resource_governorContext) + + // ExitAlter_database_audit_specification is called when exiting the alter_database_audit_specification production. + ExitAlter_database_audit_specification(c *Alter_database_audit_specificationContext) + + // ExitAudit_action_spec_group is called when exiting the audit_action_spec_group production. + ExitAudit_action_spec_group(c *Audit_action_spec_groupContext) + + // ExitAudit_action_specification is called when exiting the audit_action_specification production. + ExitAudit_action_specification(c *Audit_action_specificationContext) + + // ExitAction_specification is called when exiting the action_specification production. + ExitAction_specification(c *Action_specificationContext) + + // ExitAudit_class_name is called when exiting the audit_class_name production. + ExitAudit_class_name(c *Audit_class_nameContext) + + // ExitAudit_securable is called when exiting the audit_securable production. + ExitAudit_securable(c *Audit_securableContext) + + // ExitAlter_db_role is called when exiting the alter_db_role production. + ExitAlter_db_role(c *Alter_db_roleContext) + + // ExitCreate_database_audit_specification is called when exiting the create_database_audit_specification production. + ExitCreate_database_audit_specification(c *Create_database_audit_specificationContext) + + // ExitCreate_db_role is called when exiting the create_db_role production. + ExitCreate_db_role(c *Create_db_roleContext) + + // ExitCreate_route is called when exiting the create_route production. + ExitCreate_route(c *Create_routeContext) + + // ExitCreate_rule is called when exiting the create_rule production. + ExitCreate_rule(c *Create_ruleContext) + + // ExitAlter_schema_sql is called when exiting the alter_schema_sql production. + ExitAlter_schema_sql(c *Alter_schema_sqlContext) + + // ExitCreate_schema is called when exiting the create_schema production. + ExitCreate_schema(c *Create_schemaContext) + + // ExitCreate_schema_azure_sql_dw_and_pdw is called when exiting the create_schema_azure_sql_dw_and_pdw production. + ExitCreate_schema_azure_sql_dw_and_pdw(c *Create_schema_azure_sql_dw_and_pdwContext) + + // ExitAlter_schema_azure_sql_dw_and_pdw is called when exiting the alter_schema_azure_sql_dw_and_pdw production. + ExitAlter_schema_azure_sql_dw_and_pdw(c *Alter_schema_azure_sql_dw_and_pdwContext) + + // ExitCreate_search_property_list is called when exiting the create_search_property_list production. + ExitCreate_search_property_list(c *Create_search_property_listContext) + + // ExitCreate_security_policy is called when exiting the create_security_policy production. + ExitCreate_security_policy(c *Create_security_policyContext) + + // ExitAlter_sequence is called when exiting the alter_sequence production. + ExitAlter_sequence(c *Alter_sequenceContext) + + // ExitCreate_sequence is called when exiting the create_sequence production. + ExitCreate_sequence(c *Create_sequenceContext) + + // ExitAlter_server_audit is called when exiting the alter_server_audit production. + ExitAlter_server_audit(c *Alter_server_auditContext) + + // ExitCreate_server_audit is called when exiting the create_server_audit production. + ExitCreate_server_audit(c *Create_server_auditContext) + + // ExitAlter_server_audit_specification is called when exiting the alter_server_audit_specification production. + ExitAlter_server_audit_specification(c *Alter_server_audit_specificationContext) + + // ExitCreate_server_audit_specification is called when exiting the create_server_audit_specification production. + ExitCreate_server_audit_specification(c *Create_server_audit_specificationContext) + + // ExitAlter_server_configuration is called when exiting the alter_server_configuration production. + ExitAlter_server_configuration(c *Alter_server_configurationContext) + + // ExitAlter_server_role is called when exiting the alter_server_role production. + ExitAlter_server_role(c *Alter_server_roleContext) + + // ExitCreate_server_role is called when exiting the create_server_role production. + ExitCreate_server_role(c *Create_server_roleContext) + + // ExitAlter_server_role_pdw is called when exiting the alter_server_role_pdw production. + ExitAlter_server_role_pdw(c *Alter_server_role_pdwContext) + + // ExitAlter_service is called when exiting the alter_service production. + ExitAlter_service(c *Alter_serviceContext) + + // ExitOpt_arg_clause is called when exiting the opt_arg_clause production. + ExitOpt_arg_clause(c *Opt_arg_clauseContext) + + // ExitCreate_service is called when exiting the create_service production. + ExitCreate_service(c *Create_serviceContext) + + // ExitAlter_service_master_key is called when exiting the alter_service_master_key production. + ExitAlter_service_master_key(c *Alter_service_master_keyContext) + + // ExitAlter_symmetric_key is called when exiting the alter_symmetric_key production. + ExitAlter_symmetric_key(c *Alter_symmetric_keyContext) + + // ExitCreate_synonym is called when exiting the create_synonym production. + ExitCreate_synonym(c *Create_synonymContext) + + // ExitAlter_user is called when exiting the alter_user production. + ExitAlter_user(c *Alter_userContext) + + // ExitCreate_user is called when exiting the create_user production. + ExitCreate_user(c *Create_userContext) + + // ExitCreate_user_azure_sql_dw is called when exiting the create_user_azure_sql_dw production. + ExitCreate_user_azure_sql_dw(c *Create_user_azure_sql_dwContext) + + // ExitAlter_user_azure_sql is called when exiting the alter_user_azure_sql production. + ExitAlter_user_azure_sql(c *Alter_user_azure_sqlContext) + + // ExitAlter_workload_group is called when exiting the alter_workload_group production. + ExitAlter_workload_group(c *Alter_workload_groupContext) + + // ExitCreate_workload_group is called when exiting the create_workload_group production. + ExitCreate_workload_group(c *Create_workload_groupContext) + + // ExitCreate_xml_schema_collection is called when exiting the create_xml_schema_collection production. + ExitCreate_xml_schema_collection(c *Create_xml_schema_collectionContext) + + // ExitCreate_partition_function is called when exiting the create_partition_function production. + ExitCreate_partition_function(c *Create_partition_functionContext) + + // ExitCreate_partition_scheme is called when exiting the create_partition_scheme production. + ExitCreate_partition_scheme(c *Create_partition_schemeContext) + + // ExitCreate_queue is called when exiting the create_queue production. + ExitCreate_queue(c *Create_queueContext) + + // ExitQueue_settings is called when exiting the queue_settings production. + ExitQueue_settings(c *Queue_settingsContext) + + // ExitAlter_queue is called when exiting the alter_queue production. + ExitAlter_queue(c *Alter_queueContext) + + // ExitQueue_action is called when exiting the queue_action production. + ExitQueue_action(c *Queue_actionContext) + + // ExitQueue_rebuild_options is called when exiting the queue_rebuild_options production. + ExitQueue_rebuild_options(c *Queue_rebuild_optionsContext) + + // ExitCreate_contract is called when exiting the create_contract production. + ExitCreate_contract(c *Create_contractContext) + + // ExitConversation_statement is called when exiting the conversation_statement production. + ExitConversation_statement(c *Conversation_statementContext) + + // ExitMessage_statement is called when exiting the message_statement production. + ExitMessage_statement(c *Message_statementContext) + + // ExitMerge_statement is called when exiting the merge_statement production. + ExitMerge_statement(c *Merge_statementContext) + + // ExitWhen_matches is called when exiting the when_matches production. + ExitWhen_matches(c *When_matchesContext) + + // ExitMerge_matched is called when exiting the merge_matched production. + ExitMerge_matched(c *Merge_matchedContext) + + // ExitMerge_not_matched is called when exiting the merge_not_matched production. + ExitMerge_not_matched(c *Merge_not_matchedContext) + + // ExitDelete_statement is called when exiting the delete_statement production. + ExitDelete_statement(c *Delete_statementContext) + + // ExitDelete_statement_from is called when exiting the delete_statement_from production. + ExitDelete_statement_from(c *Delete_statement_fromContext) + + // ExitInsert_statement is called when exiting the insert_statement production. + ExitInsert_statement(c *Insert_statementContext) + + // ExitInsert_statement_value is called when exiting the insert_statement_value production. + ExitInsert_statement_value(c *Insert_statement_valueContext) + + // ExitReceive_statement is called when exiting the receive_statement production. + ExitReceive_statement(c *Receive_statementContext) + + // ExitSelect_statement_standalone is called when exiting the select_statement_standalone production. + ExitSelect_statement_standalone(c *Select_statement_standaloneContext) + + // ExitSelect_statement is called when exiting the select_statement production. + ExitSelect_statement(c *Select_statementContext) + + // ExitTime is called when exiting the time production. + ExitTime(c *TimeContext) + + // ExitUpdate_statement is called when exiting the update_statement production. + ExitUpdate_statement(c *Update_statementContext) + + // ExitOutput_clause is called when exiting the output_clause production. + ExitOutput_clause(c *Output_clauseContext) + + // ExitOutput_dml_list_elem is called when exiting the output_dml_list_elem production. + ExitOutput_dml_list_elem(c *Output_dml_list_elemContext) + + // ExitCreate_database is called when exiting the create_database production. + ExitCreate_database(c *Create_databaseContext) + + // ExitCreate_index is called when exiting the create_index production. + ExitCreate_index(c *Create_indexContext) + + // ExitCreate_spatial_index is called when exiting the create_spatial_index production. + ExitCreate_spatial_index(c *Create_spatial_indexContext) + + // ExitSpatial_tessellation_scheme is called when exiting the spatial_tessellation_scheme production. + ExitSpatial_tessellation_scheme(c *Spatial_tessellation_schemeContext) + + // ExitSpatial_index_options is called when exiting the spatial_index_options production. + ExitSpatial_index_options(c *Spatial_index_optionsContext) + + // ExitSpatial_index_option is called when exiting the spatial_index_option production. + ExitSpatial_index_option(c *Spatial_index_optionContext) + + // ExitSigned_decimal is called when exiting the signed_decimal production. + ExitSigned_decimal(c *Signed_decimalContext) + + // ExitSpatial_grid_level is called when exiting the spatial_grid_level production. + ExitSpatial_grid_level(c *Spatial_grid_levelContext) + + // ExitSpatial_grid_density is called when exiting the spatial_grid_density production. + ExitSpatial_grid_density(c *Spatial_grid_densityContext) + + // ExitCreate_index_options is called when exiting the create_index_options production. + ExitCreate_index_options(c *Create_index_optionsContext) + + // ExitRelational_index_option is called when exiting the relational_index_option production. + ExitRelational_index_option(c *Relational_index_optionContext) + + // ExitAlter_index is called when exiting the alter_index production. + ExitAlter_index(c *Alter_indexContext) + + // ExitResumable_index_options is called when exiting the resumable_index_options production. + ExitResumable_index_options(c *Resumable_index_optionsContext) + + // ExitResumable_index_option is called when exiting the resumable_index_option production. + ExitResumable_index_option(c *Resumable_index_optionContext) + + // ExitReorganize_partition is called when exiting the reorganize_partition production. + ExitReorganize_partition(c *Reorganize_partitionContext) + + // ExitReorganize_options is called when exiting the reorganize_options production. + ExitReorganize_options(c *Reorganize_optionsContext) + + // ExitReorganize_option is called when exiting the reorganize_option production. + ExitReorganize_option(c *Reorganize_optionContext) + + // ExitSet_index_options is called when exiting the set_index_options production. + ExitSet_index_options(c *Set_index_optionsContext) + + // ExitSet_index_option is called when exiting the set_index_option production. + ExitSet_index_option(c *Set_index_optionContext) + + // ExitRebuild_partition is called when exiting the rebuild_partition production. + ExitRebuild_partition(c *Rebuild_partitionContext) + + // ExitRebuild_index_options is called when exiting the rebuild_index_options production. + ExitRebuild_index_options(c *Rebuild_index_optionsContext) + + // ExitRebuild_index_option is called when exiting the rebuild_index_option production. + ExitRebuild_index_option(c *Rebuild_index_optionContext) + + // ExitSingle_partition_rebuild_index_options is called when exiting the single_partition_rebuild_index_options production. + ExitSingle_partition_rebuild_index_options(c *Single_partition_rebuild_index_optionsContext) + + // ExitSingle_partition_rebuild_index_option is called when exiting the single_partition_rebuild_index_option production. + ExitSingle_partition_rebuild_index_option(c *Single_partition_rebuild_index_optionContext) + + // ExitOn_partitions is called when exiting the on_partitions production. + ExitOn_partitions(c *On_partitionsContext) + + // ExitCreate_columnstore_index is called when exiting the create_columnstore_index production. + ExitCreate_columnstore_index(c *Create_columnstore_indexContext) + + // ExitCreate_columnstore_index_options is called when exiting the create_columnstore_index_options production. + ExitCreate_columnstore_index_options(c *Create_columnstore_index_optionsContext) + + // ExitColumnstore_index_option is called when exiting the columnstore_index_option production. + ExitColumnstore_index_option(c *Columnstore_index_optionContext) + + // ExitCreate_nonclustered_columnstore_index is called when exiting the create_nonclustered_columnstore_index production. + ExitCreate_nonclustered_columnstore_index(c *Create_nonclustered_columnstore_indexContext) + + // ExitCreate_xml_index is called when exiting the create_xml_index production. + ExitCreate_xml_index(c *Create_xml_indexContext) + + // ExitXml_index_options is called when exiting the xml_index_options production. + ExitXml_index_options(c *Xml_index_optionsContext) + + // ExitXml_index_option is called when exiting the xml_index_option production. + ExitXml_index_option(c *Xml_index_optionContext) + + // ExitCreate_or_alter_procedure is called when exiting the create_or_alter_procedure production. + ExitCreate_or_alter_procedure(c *Create_or_alter_procedureContext) + + // ExitAs_external_name is called when exiting the as_external_name production. + ExitAs_external_name(c *As_external_nameContext) + + // ExitCreate_or_alter_trigger is called when exiting the create_or_alter_trigger production. + ExitCreate_or_alter_trigger(c *Create_or_alter_triggerContext) + + // ExitCreate_or_alter_dml_trigger is called when exiting the create_or_alter_dml_trigger production. + ExitCreate_or_alter_dml_trigger(c *Create_or_alter_dml_triggerContext) + + // ExitDml_trigger_option is called when exiting the dml_trigger_option production. + ExitDml_trigger_option(c *Dml_trigger_optionContext) + + // ExitDml_trigger_operation is called when exiting the dml_trigger_operation production. + ExitDml_trigger_operation(c *Dml_trigger_operationContext) + + // ExitCreate_or_alter_ddl_trigger is called when exiting the create_or_alter_ddl_trigger production. + ExitCreate_or_alter_ddl_trigger(c *Create_or_alter_ddl_triggerContext) + + // ExitDdl_trigger_operation is called when exiting the ddl_trigger_operation production. + ExitDdl_trigger_operation(c *Ddl_trigger_operationContext) + + // ExitCreate_or_alter_function is called when exiting the create_or_alter_function production. + ExitCreate_or_alter_function(c *Create_or_alter_functionContext) + + // ExitFunc_body_returns_select is called when exiting the func_body_returns_select production. + ExitFunc_body_returns_select(c *Func_body_returns_selectContext) + + // ExitFunc_body_returns_table is called when exiting the func_body_returns_table production. + ExitFunc_body_returns_table(c *Func_body_returns_tableContext) + + // ExitFunc_body_returns_scalar is called when exiting the func_body_returns_scalar production. + ExitFunc_body_returns_scalar(c *Func_body_returns_scalarContext) + + // ExitProcedure_param_default_value is called when exiting the procedure_param_default_value production. + ExitProcedure_param_default_value(c *Procedure_param_default_valueContext) + + // ExitProcedure_param is called when exiting the procedure_param production. + ExitProcedure_param(c *Procedure_paramContext) + + // ExitProcedure_option is called when exiting the procedure_option production. + ExitProcedure_option(c *Procedure_optionContext) + + // ExitFunction_option is called when exiting the function_option production. + ExitFunction_option(c *Function_optionContext) + + // ExitCreate_statistics is called when exiting the create_statistics production. + ExitCreate_statistics(c *Create_statisticsContext) + + // ExitUpdate_statistics is called when exiting the update_statistics production. + ExitUpdate_statistics(c *Update_statisticsContext) + + // ExitUpdate_statistics_options is called when exiting the update_statistics_options production. + ExitUpdate_statistics_options(c *Update_statistics_optionsContext) + + // ExitUpdate_statistics_option is called when exiting the update_statistics_option production. + ExitUpdate_statistics_option(c *Update_statistics_optionContext) + + // ExitCreate_table is called when exiting the create_table production. + ExitCreate_table(c *Create_tableContext) + + // ExitTable_indices is called when exiting the table_indices production. + ExitTable_indices(c *Table_indicesContext) + + // ExitTable_options is called when exiting the table_options production. + ExitTable_options(c *Table_optionsContext) + + // ExitTable_option is called when exiting the table_option production. + ExitTable_option(c *Table_optionContext) + + // ExitCreate_table_index_options is called when exiting the create_table_index_options production. + ExitCreate_table_index_options(c *Create_table_index_optionsContext) + + // ExitCreate_table_index_option is called when exiting the create_table_index_option production. + ExitCreate_table_index_option(c *Create_table_index_optionContext) + + // ExitCreate_view is called when exiting the create_view production. + ExitCreate_view(c *Create_viewContext) + + // ExitView_attribute is called when exiting the view_attribute production. + ExitView_attribute(c *View_attributeContext) + + // ExitAlter_table is called when exiting the alter_table production. + ExitAlter_table(c *Alter_tableContext) + + // ExitSwitch_partition is called when exiting the switch_partition production. + ExitSwitch_partition(c *Switch_partitionContext) + + // ExitLow_priority_lock_wait is called when exiting the low_priority_lock_wait production. + ExitLow_priority_lock_wait(c *Low_priority_lock_waitContext) + + // ExitAlter_database is called when exiting the alter_database production. + ExitAlter_database(c *Alter_databaseContext) + + // ExitAdd_or_modify_files is called when exiting the add_or_modify_files production. + ExitAdd_or_modify_files(c *Add_or_modify_filesContext) + + // ExitFilespec is called when exiting the filespec production. + ExitFilespec(c *FilespecContext) + + // ExitAdd_or_modify_filegroups is called when exiting the add_or_modify_filegroups production. + ExitAdd_or_modify_filegroups(c *Add_or_modify_filegroupsContext) + + // ExitFilegroup_updatability_option is called when exiting the filegroup_updatability_option production. + ExitFilegroup_updatability_option(c *Filegroup_updatability_optionContext) + + // ExitDatabase_optionspec is called when exiting the database_optionspec production. + ExitDatabase_optionspec(c *Database_optionspecContext) + + // ExitAuto_option is called when exiting the auto_option production. + ExitAuto_option(c *Auto_optionContext) + + // ExitChange_tracking_option is called when exiting the change_tracking_option production. + ExitChange_tracking_option(c *Change_tracking_optionContext) + + // ExitChange_tracking_option_list is called when exiting the change_tracking_option_list production. + ExitChange_tracking_option_list(c *Change_tracking_option_listContext) + + // ExitContainment_option is called when exiting the containment_option production. + ExitContainment_option(c *Containment_optionContext) + + // ExitCursor_option is called when exiting the cursor_option production. + ExitCursor_option(c *Cursor_optionContext) + + // ExitAlter_endpoint is called when exiting the alter_endpoint production. + ExitAlter_endpoint(c *Alter_endpointContext) + + // ExitDatabase_mirroring_option is called when exiting the database_mirroring_option production. + ExitDatabase_mirroring_option(c *Database_mirroring_optionContext) + + // ExitMirroring_set_option is called when exiting the mirroring_set_option production. + ExitMirroring_set_option(c *Mirroring_set_optionContext) + + // ExitMirroring_partner is called when exiting the mirroring_partner production. + ExitMirroring_partner(c *Mirroring_partnerContext) + + // ExitMirroring_witness is called when exiting the mirroring_witness production. + ExitMirroring_witness(c *Mirroring_witnessContext) + + // ExitWitness_partner_equal is called when exiting the witness_partner_equal production. + ExitWitness_partner_equal(c *Witness_partner_equalContext) + + // ExitPartner_option is called when exiting the partner_option production. + ExitPartner_option(c *Partner_optionContext) + + // ExitWitness_option is called when exiting the witness_option production. + ExitWitness_option(c *Witness_optionContext) + + // ExitWitness_server is called when exiting the witness_server production. + ExitWitness_server(c *Witness_serverContext) + + // ExitPartner_server is called when exiting the partner_server production. + ExitPartner_server(c *Partner_serverContext) + + // ExitMirroring_host_port_seperator is called when exiting the mirroring_host_port_seperator production. + ExitMirroring_host_port_seperator(c *Mirroring_host_port_seperatorContext) + + // ExitPartner_server_tcp_prefix is called when exiting the partner_server_tcp_prefix production. + ExitPartner_server_tcp_prefix(c *Partner_server_tcp_prefixContext) + + // ExitPort_number is called when exiting the port_number production. + ExitPort_number(c *Port_numberContext) + + // ExitHost is called when exiting the host production. + ExitHost(c *HostContext) + + // ExitDate_correlation_optimization_option is called when exiting the date_correlation_optimization_option production. + ExitDate_correlation_optimization_option(c *Date_correlation_optimization_optionContext) + + // ExitDb_encryption_option is called when exiting the db_encryption_option production. + ExitDb_encryption_option(c *Db_encryption_optionContext) + + // ExitDb_state_option is called when exiting the db_state_option production. + ExitDb_state_option(c *Db_state_optionContext) + + // ExitDb_update_option is called when exiting the db_update_option production. + ExitDb_update_option(c *Db_update_optionContext) + + // ExitDb_user_access_option is called when exiting the db_user_access_option production. + ExitDb_user_access_option(c *Db_user_access_optionContext) + + // ExitDelayed_durability_option is called when exiting the delayed_durability_option production. + ExitDelayed_durability_option(c *Delayed_durability_optionContext) + + // ExitExternal_access_option is called when exiting the external_access_option production. + ExitExternal_access_option(c *External_access_optionContext) + + // ExitHadr_options is called when exiting the hadr_options production. + ExitHadr_options(c *Hadr_optionsContext) + + // ExitMixed_page_allocation_option is called when exiting the mixed_page_allocation_option production. + ExitMixed_page_allocation_option(c *Mixed_page_allocation_optionContext) + + // ExitParameterization_option is called when exiting the parameterization_option production. + ExitParameterization_option(c *Parameterization_optionContext) + + // ExitRecovery_option is called when exiting the recovery_option production. + ExitRecovery_option(c *Recovery_optionContext) + + // ExitService_broker_option is called when exiting the service_broker_option production. + ExitService_broker_option(c *Service_broker_optionContext) + + // ExitSnapshot_option is called when exiting the snapshot_option production. + ExitSnapshot_option(c *Snapshot_optionContext) + + // ExitSql_option is called when exiting the sql_option production. + ExitSql_option(c *Sql_optionContext) + + // ExitTarget_recovery_time_option is called when exiting the target_recovery_time_option production. + ExitTarget_recovery_time_option(c *Target_recovery_time_optionContext) + + // ExitTermination is called when exiting the termination production. + ExitTermination(c *TerminationContext) + + // ExitDrop_index is called when exiting the drop_index production. + ExitDrop_index(c *Drop_indexContext) + + // ExitDrop_relational_or_xml_or_spatial_index is called when exiting the drop_relational_or_xml_or_spatial_index production. + ExitDrop_relational_or_xml_or_spatial_index(c *Drop_relational_or_xml_or_spatial_indexContext) + + // ExitDrop_backward_compatible_index is called when exiting the drop_backward_compatible_index production. + ExitDrop_backward_compatible_index(c *Drop_backward_compatible_indexContext) + + // ExitDrop_procedure is called when exiting the drop_procedure production. + ExitDrop_procedure(c *Drop_procedureContext) + + // ExitDrop_trigger is called when exiting the drop_trigger production. + ExitDrop_trigger(c *Drop_triggerContext) + + // ExitDrop_dml_trigger is called when exiting the drop_dml_trigger production. + ExitDrop_dml_trigger(c *Drop_dml_triggerContext) + + // ExitDrop_ddl_trigger is called when exiting the drop_ddl_trigger production. + ExitDrop_ddl_trigger(c *Drop_ddl_triggerContext) + + // ExitDrop_function is called when exiting the drop_function production. + ExitDrop_function(c *Drop_functionContext) + + // ExitDrop_statistics is called when exiting the drop_statistics production. + ExitDrop_statistics(c *Drop_statisticsContext) + + // ExitDrop_table is called when exiting the drop_table production. + ExitDrop_table(c *Drop_tableContext) + + // ExitDrop_view is called when exiting the drop_view production. + ExitDrop_view(c *Drop_viewContext) + + // ExitCreate_type is called when exiting the create_type production. + ExitCreate_type(c *Create_typeContext) + + // ExitDrop_type is called when exiting the drop_type production. + ExitDrop_type(c *Drop_typeContext) + + // ExitRowset_function_limited is called when exiting the rowset_function_limited production. + ExitRowset_function_limited(c *Rowset_function_limitedContext) + + // ExitOpenquery is called when exiting the openquery production. + ExitOpenquery(c *OpenqueryContext) + + // ExitOpendatasource is called when exiting the opendatasource production. + ExitOpendatasource(c *OpendatasourceContext) + + // ExitDeclare_statement is called when exiting the declare_statement production. + ExitDeclare_statement(c *Declare_statementContext) + + // ExitXml_declaration is called when exiting the xml_declaration production. + ExitXml_declaration(c *Xml_declarationContext) + + // ExitCursor_statement is called when exiting the cursor_statement production. + ExitCursor_statement(c *Cursor_statementContext) + + // ExitBackup_database is called when exiting the backup_database production. + ExitBackup_database(c *Backup_databaseContext) + + // ExitBackup_log is called when exiting the backup_log production. + ExitBackup_log(c *Backup_logContext) + + // ExitBackup_certificate is called when exiting the backup_certificate production. + ExitBackup_certificate(c *Backup_certificateContext) + + // ExitBackup_master_key is called when exiting the backup_master_key production. + ExitBackup_master_key(c *Backup_master_keyContext) + + // ExitBackup_service_master_key is called when exiting the backup_service_master_key production. + ExitBackup_service_master_key(c *Backup_service_master_keyContext) + + // ExitKill_statement is called when exiting the kill_statement production. + ExitKill_statement(c *Kill_statementContext) + + // ExitKill_process is called when exiting the kill_process production. + ExitKill_process(c *Kill_processContext) + + // ExitKill_query_notification is called when exiting the kill_query_notification production. + ExitKill_query_notification(c *Kill_query_notificationContext) + + // ExitKill_stats_job is called when exiting the kill_stats_job production. + ExitKill_stats_job(c *Kill_stats_jobContext) + + // ExitExecute_statement is called when exiting the execute_statement production. + ExitExecute_statement(c *Execute_statementContext) + + // ExitExecute_body_batch is called when exiting the execute_body_batch production. + ExitExecute_body_batch(c *Execute_body_batchContext) + + // ExitExecute_body is called when exiting the execute_body production. + ExitExecute_body(c *Execute_bodyContext) + + // ExitExecute_statement_arg is called when exiting the execute_statement_arg production. + ExitExecute_statement_arg(c *Execute_statement_argContext) + + // ExitExecute_statement_arg_named is called when exiting the execute_statement_arg_named production. + ExitExecute_statement_arg_named(c *Execute_statement_arg_namedContext) + + // ExitExecute_statement_arg_unnamed is called when exiting the execute_statement_arg_unnamed production. + ExitExecute_statement_arg_unnamed(c *Execute_statement_arg_unnamedContext) + + // ExitExecute_parameter is called when exiting the execute_parameter production. + ExitExecute_parameter(c *Execute_parameterContext) + + // ExitExecute_var_string is called when exiting the execute_var_string production. + ExitExecute_var_string(c *Execute_var_stringContext) + + // ExitSecurity_statement is called when exiting the security_statement production. + ExitSecurity_statement(c *Security_statementContext) + + // ExitPrincipal_id is called when exiting the principal_id production. + ExitPrincipal_id(c *Principal_idContext) + + // ExitCreate_certificate is called when exiting the create_certificate production. + ExitCreate_certificate(c *Create_certificateContext) + + // ExitExisting_keys is called when exiting the existing_keys production. + ExitExisting_keys(c *Existing_keysContext) + + // ExitPrivate_key_options is called when exiting the private_key_options production. + ExitPrivate_key_options(c *Private_key_optionsContext) + + // ExitGenerate_new_keys is called when exiting the generate_new_keys production. + ExitGenerate_new_keys(c *Generate_new_keysContext) + + // ExitDate_options is called when exiting the date_options production. + ExitDate_options(c *Date_optionsContext) + + // ExitOpen_key is called when exiting the open_key production. + ExitOpen_key(c *Open_keyContext) + + // ExitClose_key is called when exiting the close_key production. + ExitClose_key(c *Close_keyContext) + + // ExitCreate_key is called when exiting the create_key production. + ExitCreate_key(c *Create_keyContext) + + // ExitKey_options is called when exiting the key_options production. + ExitKey_options(c *Key_optionsContext) + + // ExitAlgorithm is called when exiting the algorithm production. + ExitAlgorithm(c *AlgorithmContext) + + // ExitEncryption_mechanism is called when exiting the encryption_mechanism production. + ExitEncryption_mechanism(c *Encryption_mechanismContext) + + // ExitDecryption_mechanism is called when exiting the decryption_mechanism production. + ExitDecryption_mechanism(c *Decryption_mechanismContext) + + // ExitGrant_permission is called when exiting the grant_permission production. + ExitGrant_permission(c *Grant_permissionContext) + + // ExitSet_statement is called when exiting the set_statement production. + ExitSet_statement(c *Set_statementContext) + + // ExitTransaction_statement is called when exiting the transaction_statement production. + ExitTransaction_statement(c *Transaction_statementContext) + + // ExitGo_statement is called when exiting the go_statement production. + ExitGo_statement(c *Go_statementContext) + + // ExitUse_statement is called when exiting the use_statement production. + ExitUse_statement(c *Use_statementContext) + + // ExitSetuser_statement is called when exiting the setuser_statement production. + ExitSetuser_statement(c *Setuser_statementContext) + + // ExitReconfigure_statement is called when exiting the reconfigure_statement production. + ExitReconfigure_statement(c *Reconfigure_statementContext) + + // ExitShutdown_statement is called when exiting the shutdown_statement production. + ExitShutdown_statement(c *Shutdown_statementContext) + + // ExitCheckpoint_statement is called when exiting the checkpoint_statement production. + ExitCheckpoint_statement(c *Checkpoint_statementContext) + + // ExitDbcc_checkalloc_option is called when exiting the dbcc_checkalloc_option production. + ExitDbcc_checkalloc_option(c *Dbcc_checkalloc_optionContext) + + // ExitDbcc_checkalloc is called when exiting the dbcc_checkalloc production. + ExitDbcc_checkalloc(c *Dbcc_checkallocContext) + + // ExitDbcc_checkcatalog is called when exiting the dbcc_checkcatalog production. + ExitDbcc_checkcatalog(c *Dbcc_checkcatalogContext) + + // ExitDbcc_checkconstraints_option is called when exiting the dbcc_checkconstraints_option production. + ExitDbcc_checkconstraints_option(c *Dbcc_checkconstraints_optionContext) + + // ExitDbcc_checkconstraints is called when exiting the dbcc_checkconstraints production. + ExitDbcc_checkconstraints(c *Dbcc_checkconstraintsContext) + + // ExitDbcc_checkdb_table_option is called when exiting the dbcc_checkdb_table_option production. + ExitDbcc_checkdb_table_option(c *Dbcc_checkdb_table_optionContext) + + // ExitDbcc_checkdb is called when exiting the dbcc_checkdb production. + ExitDbcc_checkdb(c *Dbcc_checkdbContext) + + // ExitDbcc_checkfilegroup_option is called when exiting the dbcc_checkfilegroup_option production. + ExitDbcc_checkfilegroup_option(c *Dbcc_checkfilegroup_optionContext) + + // ExitDbcc_checkfilegroup is called when exiting the dbcc_checkfilegroup production. + ExitDbcc_checkfilegroup(c *Dbcc_checkfilegroupContext) + + // ExitDbcc_checktable is called when exiting the dbcc_checktable production. + ExitDbcc_checktable(c *Dbcc_checktableContext) + + // ExitDbcc_cleantable is called when exiting the dbcc_cleantable production. + ExitDbcc_cleantable(c *Dbcc_cleantableContext) + + // ExitDbcc_clonedatabase_option is called when exiting the dbcc_clonedatabase_option production. + ExitDbcc_clonedatabase_option(c *Dbcc_clonedatabase_optionContext) + + // ExitDbcc_clonedatabase is called when exiting the dbcc_clonedatabase production. + ExitDbcc_clonedatabase(c *Dbcc_clonedatabaseContext) + + // ExitDbcc_pdw_showspaceused is called when exiting the dbcc_pdw_showspaceused production. + ExitDbcc_pdw_showspaceused(c *Dbcc_pdw_showspaceusedContext) + + // ExitDbcc_proccache is called when exiting the dbcc_proccache production. + ExitDbcc_proccache(c *Dbcc_proccacheContext) + + // ExitDbcc_showcontig_option is called when exiting the dbcc_showcontig_option production. + ExitDbcc_showcontig_option(c *Dbcc_showcontig_optionContext) + + // ExitDbcc_showcontig is called when exiting the dbcc_showcontig production. + ExitDbcc_showcontig(c *Dbcc_showcontigContext) + + // ExitDbcc_shrinklog is called when exiting the dbcc_shrinklog production. + ExitDbcc_shrinklog(c *Dbcc_shrinklogContext) + + // ExitDbcc_dbreindex is called when exiting the dbcc_dbreindex production. + ExitDbcc_dbreindex(c *Dbcc_dbreindexContext) + + // ExitDbcc_dll_free is called when exiting the dbcc_dll_free production. + ExitDbcc_dll_free(c *Dbcc_dll_freeContext) + + // ExitDbcc_dropcleanbuffers is called when exiting the dbcc_dropcleanbuffers production. + ExitDbcc_dropcleanbuffers(c *Dbcc_dropcleanbuffersContext) + + // ExitDbcc_clause is called when exiting the dbcc_clause production. + ExitDbcc_clause(c *Dbcc_clauseContext) + + // ExitExecute_clause is called when exiting the execute_clause production. + ExitExecute_clause(c *Execute_clauseContext) + + // ExitDeclare_local is called when exiting the declare_local production. + ExitDeclare_local(c *Declare_localContext) + + // ExitTable_type_definition is called when exiting the table_type_definition production. + ExitTable_type_definition(c *Table_type_definitionContext) + + // ExitTable_type_indices is called when exiting the table_type_indices production. + ExitTable_type_indices(c *Table_type_indicesContext) + + // ExitXml_type_definition is called when exiting the xml_type_definition production. + ExitXml_type_definition(c *Xml_type_definitionContext) + + // ExitXml_schema_collection is called when exiting the xml_schema_collection production. + ExitXml_schema_collection(c *Xml_schema_collectionContext) + + // ExitColumn_def_table_constraints is called when exiting the column_def_table_constraints production. + ExitColumn_def_table_constraints(c *Column_def_table_constraintsContext) + + // ExitColumn_def_table_constraint is called when exiting the column_def_table_constraint production. + ExitColumn_def_table_constraint(c *Column_def_table_constraintContext) + + // ExitColumn_definition is called when exiting the column_definition production. + ExitColumn_definition(c *Column_definitionContext) + + // ExitColumn_definition_element is called when exiting the column_definition_element production. + ExitColumn_definition_element(c *Column_definition_elementContext) + + // ExitColumn_modifier is called when exiting the column_modifier production. + ExitColumn_modifier(c *Column_modifierContext) + + // ExitMaterialized_column_definition is called when exiting the materialized_column_definition production. + ExitMaterialized_column_definition(c *Materialized_column_definitionContext) + + // ExitColumn_constraint is called when exiting the column_constraint production. + ExitColumn_constraint(c *Column_constraintContext) + + // ExitColumn_index is called when exiting the column_index production. + ExitColumn_index(c *Column_indexContext) + + // ExitOn_partition_or_filegroup is called when exiting the on_partition_or_filegroup production. + ExitOn_partition_or_filegroup(c *On_partition_or_filegroupContext) + + // ExitTable_constraint is called when exiting the table_constraint production. + ExitTable_constraint(c *Table_constraintContext) + + // ExitConnection_node is called when exiting the connection_node production. + ExitConnection_node(c *Connection_nodeContext) + + // ExitPrimary_key_options is called when exiting the primary_key_options production. + ExitPrimary_key_options(c *Primary_key_optionsContext) + + // ExitForeign_key_options is called when exiting the foreign_key_options production. + ExitForeign_key_options(c *Foreign_key_optionsContext) + + // ExitCheck_constraint is called when exiting the check_constraint production. + ExitCheck_constraint(c *Check_constraintContext) + + // ExitOn_delete is called when exiting the on_delete production. + ExitOn_delete(c *On_deleteContext) + + // ExitOn_update is called when exiting the on_update production. + ExitOn_update(c *On_updateContext) + + // ExitAlter_table_index_options is called when exiting the alter_table_index_options production. + ExitAlter_table_index_options(c *Alter_table_index_optionsContext) + + // ExitAlter_table_index_option is called when exiting the alter_table_index_option production. + ExitAlter_table_index_option(c *Alter_table_index_optionContext) + + // ExitDeclare_cursor is called when exiting the declare_cursor production. + ExitDeclare_cursor(c *Declare_cursorContext) + + // ExitDeclare_set_cursor_common is called when exiting the declare_set_cursor_common production. + ExitDeclare_set_cursor_common(c *Declare_set_cursor_commonContext) + + // ExitDeclare_set_cursor_common_partial is called when exiting the declare_set_cursor_common_partial production. + ExitDeclare_set_cursor_common_partial(c *Declare_set_cursor_common_partialContext) + + // ExitFetch_cursor is called when exiting the fetch_cursor production. + ExitFetch_cursor(c *Fetch_cursorContext) + + // ExitSet_special is called when exiting the set_special production. + ExitSet_special(c *Set_specialContext) + + // ExitSpecial_list is called when exiting the special_list production. + ExitSpecial_list(c *Special_listContext) + + // ExitConstant_LOCAL_ID is called when exiting the constant_LOCAL_ID production. + ExitConstant_LOCAL_ID(c *Constant_LOCAL_IDContext) + + // ExitExpression is called when exiting the expression production. + ExitExpression(c *ExpressionContext) + + // ExitParameter is called when exiting the parameter production. + ExitParameter(c *ParameterContext) + + // ExitTime_zone is called when exiting the time_zone production. + ExitTime_zone(c *Time_zoneContext) + + // ExitPrimitive_expression is called when exiting the primitive_expression production. + ExitPrimitive_expression(c *Primitive_expressionContext) + + // ExitCase_expression is called when exiting the case_expression production. + ExitCase_expression(c *Case_expressionContext) + + // ExitUnary_operator_expression is called when exiting the unary_operator_expression production. + ExitUnary_operator_expression(c *Unary_operator_expressionContext) + + // ExitBracket_expression is called when exiting the bracket_expression production. + ExitBracket_expression(c *Bracket_expressionContext) + + // ExitSubquery is called when exiting the subquery production. + ExitSubquery(c *SubqueryContext) + + // ExitWith_expression is called when exiting the with_expression production. + ExitWith_expression(c *With_expressionContext) + + // ExitCommon_table_expression is called when exiting the common_table_expression production. + ExitCommon_table_expression(c *Common_table_expressionContext) + + // ExitUpdate_elem is called when exiting the update_elem production. + ExitUpdate_elem(c *Update_elemContext) + + // ExitUpdate_elem_merge is called when exiting the update_elem_merge production. + ExitUpdate_elem_merge(c *Update_elem_mergeContext) + + // ExitSearch_condition is called when exiting the search_condition production. + ExitSearch_condition(c *Search_conditionContext) + + // ExitPredicate is called when exiting the predicate production. + ExitPredicate(c *PredicateContext) + + // ExitQuery_expression is called when exiting the query_expression production. + ExitQuery_expression(c *Query_expressionContext) + + // ExitSql_union is called when exiting the sql_union production. + ExitSql_union(c *Sql_unionContext) + + // ExitQuery_specification is called when exiting the query_specification production. + ExitQuery_specification(c *Query_specificationContext) + + // ExitGroup_by_clause is called when exiting the group_by_clause production. + ExitGroup_by_clause(c *Group_by_clauseContext) + + // ExitHaving_clause is called when exiting the having_clause production. + ExitHaving_clause(c *Having_clauseContext) + + // ExitFrom_table_sources is called when exiting the from_table_sources production. + ExitFrom_table_sources(c *From_table_sourcesContext) + + // ExitTop_clause is called when exiting the top_clause production. + ExitTop_clause(c *Top_clauseContext) + + // ExitTop_percent is called when exiting the top_percent production. + ExitTop_percent(c *Top_percentContext) + + // ExitTop_count is called when exiting the top_count production. + ExitTop_count(c *Top_countContext) + + // ExitOrder_by_clause is called when exiting the order_by_clause production. + ExitOrder_by_clause(c *Order_by_clauseContext) + + // ExitSelect_order_by_clause is called when exiting the select_order_by_clause production. + ExitSelect_order_by_clause(c *Select_order_by_clauseContext) + + // ExitFor_clause is called when exiting the for_clause production. + ExitFor_clause(c *For_clauseContext) + + // ExitXml_common_directives is called when exiting the xml_common_directives production. + ExitXml_common_directives(c *Xml_common_directivesContext) + + // ExitOrder_by_expression is called when exiting the order_by_expression production. + ExitOrder_by_expression(c *Order_by_expressionContext) + + // ExitGrouping_sets_item is called when exiting the grouping_sets_item production. + ExitGrouping_sets_item(c *Grouping_sets_itemContext) + + // ExitGroup_by_item is called when exiting the group_by_item production. + ExitGroup_by_item(c *Group_by_itemContext) + + // ExitOption_clause is called when exiting the option_clause production. + ExitOption_clause(c *Option_clauseContext) + + // ExitOption is called when exiting the option production. + ExitOption(c *OptionContext) + + // ExitOptimize_for_arg is called when exiting the optimize_for_arg production. + ExitOptimize_for_arg(c *Optimize_for_argContext) + + // ExitSelect_list is called when exiting the select_list production. + ExitSelect_list(c *Select_listContext) + + // ExitUdt_method_arguments is called when exiting the udt_method_arguments production. + ExitUdt_method_arguments(c *Udt_method_argumentsContext) + + // ExitAsterisk is called when exiting the asterisk production. + ExitAsterisk(c *AsteriskContext) + + // ExitUdt_elem is called when exiting the udt_elem production. + ExitUdt_elem(c *Udt_elemContext) + + // ExitExpression_elem is called when exiting the expression_elem production. + ExitExpression_elem(c *Expression_elemContext) + + // ExitSelect_list_elem is called when exiting the select_list_elem production. + ExitSelect_list_elem(c *Select_list_elemContext) + + // ExitTable_sources is called when exiting the table_sources production. + ExitTable_sources(c *Table_sourcesContext) + + // ExitTable_source is called when exiting the table_source production. + ExitTable_source(c *Table_sourceContext) + + // ExitTable_source_item is called when exiting the table_source_item production. + ExitTable_source_item(c *Table_source_itemContext) + + // ExitOpen_xml is called when exiting the open_xml production. + ExitOpen_xml(c *Open_xmlContext) + + // ExitOpen_json is called when exiting the open_json production. + ExitOpen_json(c *Open_jsonContext) + + // ExitJson_declaration is called when exiting the json_declaration production. + ExitJson_declaration(c *Json_declarationContext) + + // ExitJson_column_declaration is called when exiting the json_column_declaration production. + ExitJson_column_declaration(c *Json_column_declarationContext) + + // ExitSchema_declaration is called when exiting the schema_declaration production. + ExitSchema_declaration(c *Schema_declarationContext) + + // ExitColumn_declaration is called when exiting the column_declaration production. + ExitColumn_declaration(c *Column_declarationContext) + + // ExitChange_table is called when exiting the change_table production. + ExitChange_table(c *Change_tableContext) + + // ExitChange_table_changes is called when exiting the change_table_changes production. + ExitChange_table_changes(c *Change_table_changesContext) + + // ExitChange_table_version is called when exiting the change_table_version production. + ExitChange_table_version(c *Change_table_versionContext) + + // ExitJoin_part is called when exiting the join_part production. + ExitJoin_part(c *Join_partContext) + + // ExitJoin_on is called when exiting the join_on production. + ExitJoin_on(c *Join_onContext) + + // ExitCross_join is called when exiting the cross_join production. + ExitCross_join(c *Cross_joinContext) + + // ExitApply_ is called when exiting the apply_ production. + ExitApply_(c *Apply_Context) + + // ExitPivot is called when exiting the pivot production. + ExitPivot(c *PivotContext) + + // ExitUnpivot is called when exiting the unpivot production. + ExitUnpivot(c *UnpivotContext) + + // ExitPivot_clause is called when exiting the pivot_clause production. + ExitPivot_clause(c *Pivot_clauseContext) + + // ExitUnpivot_clause is called when exiting the unpivot_clause production. + ExitUnpivot_clause(c *Unpivot_clauseContext) + + // ExitFull_column_name_list is called when exiting the full_column_name_list production. + ExitFull_column_name_list(c *Full_column_name_listContext) + + // ExitRowset_function is called when exiting the rowset_function production. + ExitRowset_function(c *Rowset_functionContext) + + // ExitBulk_option is called when exiting the bulk_option production. + ExitBulk_option(c *Bulk_optionContext) + + // ExitDerived_table is called when exiting the derived_table production. + ExitDerived_table(c *Derived_tableContext) + + // ExitRANKING_WINDOWED_FUNC is called when exiting the RANKING_WINDOWED_FUNC production. + ExitRANKING_WINDOWED_FUNC(c *RANKING_WINDOWED_FUNCContext) + + // ExitAGGREGATE_WINDOWED_FUNC is called when exiting the AGGREGATE_WINDOWED_FUNC production. + ExitAGGREGATE_WINDOWED_FUNC(c *AGGREGATE_WINDOWED_FUNCContext) + + // ExitANALYTIC_WINDOWED_FUNC is called when exiting the ANALYTIC_WINDOWED_FUNC production. + ExitANALYTIC_WINDOWED_FUNC(c *ANALYTIC_WINDOWED_FUNCContext) + + // ExitBUILT_IN_FUNC is called when exiting the BUILT_IN_FUNC production. + ExitBUILT_IN_FUNC(c *BUILT_IN_FUNCContext) + + // ExitSCALAR_FUNCTION is called when exiting the SCALAR_FUNCTION production. + ExitSCALAR_FUNCTION(c *SCALAR_FUNCTIONContext) + + // ExitFREE_TEXT is called when exiting the FREE_TEXT production. + ExitFREE_TEXT(c *FREE_TEXTContext) + + // ExitPARTITION_FUNC is called when exiting the PARTITION_FUNC production. + ExitPARTITION_FUNC(c *PARTITION_FUNCContext) + + // ExitHIERARCHYID_METHOD is called when exiting the HIERARCHYID_METHOD production. + ExitHIERARCHYID_METHOD(c *HIERARCHYID_METHODContext) + + // ExitPartition_function is called when exiting the partition_function production. + ExitPartition_function(c *Partition_functionContext) + + // ExitFreetext_function is called when exiting the freetext_function production. + ExitFreetext_function(c *Freetext_functionContext) + + // ExitFreetext_predicate is called when exiting the freetext_predicate production. + ExitFreetext_predicate(c *Freetext_predicateContext) + + // ExitJson_key_value is called when exiting the json_key_value production. + ExitJson_key_value(c *Json_key_valueContext) + + // ExitJson_null_clause is called when exiting the json_null_clause production. + ExitJson_null_clause(c *Json_null_clauseContext) + + // ExitAPP_NAME is called when exiting the APP_NAME production. + ExitAPP_NAME(c *APP_NAMEContext) + + // ExitAPPLOCK_MODE is called when exiting the APPLOCK_MODE production. + ExitAPPLOCK_MODE(c *APPLOCK_MODEContext) + + // ExitAPPLOCK_TEST is called when exiting the APPLOCK_TEST production. + ExitAPPLOCK_TEST(c *APPLOCK_TESTContext) + + // ExitASSEMBLYPROPERTY is called when exiting the ASSEMBLYPROPERTY production. + ExitASSEMBLYPROPERTY(c *ASSEMBLYPROPERTYContext) + + // ExitCOL_LENGTH is called when exiting the COL_LENGTH production. + ExitCOL_LENGTH(c *COL_LENGTHContext) + + // ExitCOL_NAME is called when exiting the COL_NAME production. + ExitCOL_NAME(c *COL_NAMEContext) + + // ExitCOLUMNPROPERTY is called when exiting the COLUMNPROPERTY production. + ExitCOLUMNPROPERTY(c *COLUMNPROPERTYContext) + + // ExitDATABASEPROPERTYEX is called when exiting the DATABASEPROPERTYEX production. + ExitDATABASEPROPERTYEX(c *DATABASEPROPERTYEXContext) + + // ExitDB_ID is called when exiting the DB_ID production. + ExitDB_ID(c *DB_IDContext) + + // ExitDB_NAME is called when exiting the DB_NAME production. + ExitDB_NAME(c *DB_NAMEContext) + + // ExitFILE_ID is called when exiting the FILE_ID production. + ExitFILE_ID(c *FILE_IDContext) + + // ExitFILE_IDEX is called when exiting the FILE_IDEX production. + ExitFILE_IDEX(c *FILE_IDEXContext) + + // ExitFILE_NAME is called when exiting the FILE_NAME production. + ExitFILE_NAME(c *FILE_NAMEContext) + + // ExitFILEGROUP_ID is called when exiting the FILEGROUP_ID production. + ExitFILEGROUP_ID(c *FILEGROUP_IDContext) + + // ExitFILEGROUP_NAME is called when exiting the FILEGROUP_NAME production. + ExitFILEGROUP_NAME(c *FILEGROUP_NAMEContext) + + // ExitFILEGROUPPROPERTY is called when exiting the FILEGROUPPROPERTY production. + ExitFILEGROUPPROPERTY(c *FILEGROUPPROPERTYContext) + + // ExitFILEPROPERTY is called when exiting the FILEPROPERTY production. + ExitFILEPROPERTY(c *FILEPROPERTYContext) + + // ExitFILEPROPERTYEX is called when exiting the FILEPROPERTYEX production. + ExitFILEPROPERTYEX(c *FILEPROPERTYEXContext) + + // ExitFULLTEXTCATALOGPROPERTY is called when exiting the FULLTEXTCATALOGPROPERTY production. + ExitFULLTEXTCATALOGPROPERTY(c *FULLTEXTCATALOGPROPERTYContext) + + // ExitFULLTEXTSERVICEPROPERTY is called when exiting the FULLTEXTSERVICEPROPERTY production. + ExitFULLTEXTSERVICEPROPERTY(c *FULLTEXTSERVICEPROPERTYContext) + + // ExitINDEX_COL is called when exiting the INDEX_COL production. + ExitINDEX_COL(c *INDEX_COLContext) + + // ExitINDEXKEY_PROPERTY is called when exiting the INDEXKEY_PROPERTY production. + ExitINDEXKEY_PROPERTY(c *INDEXKEY_PROPERTYContext) + + // ExitINDEXPROPERTY is called when exiting the INDEXPROPERTY production. + ExitINDEXPROPERTY(c *INDEXPROPERTYContext) + + // ExitNEXT_VALUE_FOR is called when exiting the NEXT_VALUE_FOR production. + ExitNEXT_VALUE_FOR(c *NEXT_VALUE_FORContext) + + // ExitOBJECT_DEFINITION is called when exiting the OBJECT_DEFINITION production. + ExitOBJECT_DEFINITION(c *OBJECT_DEFINITIONContext) + + // ExitOBJECT_ID is called when exiting the OBJECT_ID production. + ExitOBJECT_ID(c *OBJECT_IDContext) + + // ExitOBJECT_NAME is called when exiting the OBJECT_NAME production. + ExitOBJECT_NAME(c *OBJECT_NAMEContext) + + // ExitOBJECT_SCHEMA_NAME is called when exiting the OBJECT_SCHEMA_NAME production. + ExitOBJECT_SCHEMA_NAME(c *OBJECT_SCHEMA_NAMEContext) + + // ExitOBJECTPROPERTY is called when exiting the OBJECTPROPERTY production. + ExitOBJECTPROPERTY(c *OBJECTPROPERTYContext) + + // ExitOBJECTPROPERTYEX is called when exiting the OBJECTPROPERTYEX production. + ExitOBJECTPROPERTYEX(c *OBJECTPROPERTYEXContext) + + // ExitORIGINAL_DB_NAME is called when exiting the ORIGINAL_DB_NAME production. + ExitORIGINAL_DB_NAME(c *ORIGINAL_DB_NAMEContext) + + // ExitPARSENAME is called when exiting the PARSENAME production. + ExitPARSENAME(c *PARSENAMEContext) + + // ExitSCHEMA_ID is called when exiting the SCHEMA_ID production. + ExitSCHEMA_ID(c *SCHEMA_IDContext) + + // ExitSCHEMA_NAME is called when exiting the SCHEMA_NAME production. + ExitSCHEMA_NAME(c *SCHEMA_NAMEContext) + + // ExitSCOPE_IDENTITY is called when exiting the SCOPE_IDENTITY production. + ExitSCOPE_IDENTITY(c *SCOPE_IDENTITYContext) + + // ExitSERVERPROPERTY is called when exiting the SERVERPROPERTY production. + ExitSERVERPROPERTY(c *SERVERPROPERTYContext) + + // ExitSTATS_DATE is called when exiting the STATS_DATE production. + ExitSTATS_DATE(c *STATS_DATEContext) + + // ExitTYPE_ID is called when exiting the TYPE_ID production. + ExitTYPE_ID(c *TYPE_IDContext) + + // ExitTYPE_NAME is called when exiting the TYPE_NAME production. + ExitTYPE_NAME(c *TYPE_NAMEContext) + + // ExitTYPEPROPERTY is called when exiting the TYPEPROPERTY production. + ExitTYPEPROPERTY(c *TYPEPROPERTYContext) + + // ExitASCII is called when exiting the ASCII production. + ExitASCII(c *ASCIIContext) + + // ExitCHAR is called when exiting the CHAR production. + ExitCHAR(c *CHARContext) + + // ExitCHARINDEX is called when exiting the CHARINDEX production. + ExitCHARINDEX(c *CHARINDEXContext) + + // ExitCONCAT is called when exiting the CONCAT production. + ExitCONCAT(c *CONCATContext) + + // ExitCONCAT_WS is called when exiting the CONCAT_WS production. + ExitCONCAT_WS(c *CONCAT_WSContext) + + // ExitDIFFERENCE is called when exiting the DIFFERENCE production. + ExitDIFFERENCE(c *DIFFERENCEContext) + + // ExitFORMAT is called when exiting the FORMAT production. + ExitFORMAT(c *FORMATContext) + + // ExitLEFT is called when exiting the LEFT production. + ExitLEFT(c *LEFTContext) + + // ExitLEN is called when exiting the LEN production. + ExitLEN(c *LENContext) + + // ExitLOWER is called when exiting the LOWER production. + ExitLOWER(c *LOWERContext) + + // ExitLTRIM is called when exiting the LTRIM production. + ExitLTRIM(c *LTRIMContext) + + // ExitNCHAR is called when exiting the NCHAR production. + ExitNCHAR(c *NCHARContext) + + // ExitPATINDEX is called when exiting the PATINDEX production. + ExitPATINDEX(c *PATINDEXContext) + + // ExitQUOTENAME is called when exiting the QUOTENAME production. + ExitQUOTENAME(c *QUOTENAMEContext) + + // ExitREPLACE is called when exiting the REPLACE production. + ExitREPLACE(c *REPLACEContext) + + // ExitREPLICATE is called when exiting the REPLICATE production. + ExitREPLICATE(c *REPLICATEContext) + + // ExitREVERSE is called when exiting the REVERSE production. + ExitREVERSE(c *REVERSEContext) + + // ExitRIGHT is called when exiting the RIGHT production. + ExitRIGHT(c *RIGHTContext) + + // ExitRTRIM is called when exiting the RTRIM production. + ExitRTRIM(c *RTRIMContext) + + // ExitSOUNDEX is called when exiting the SOUNDEX production. + ExitSOUNDEX(c *SOUNDEXContext) + + // ExitSPACE is called when exiting the SPACE production. + ExitSPACE(c *SPACEContext) + + // ExitSTR is called when exiting the STR production. + ExitSTR(c *STRContext) + + // ExitSTRINGAGG is called when exiting the STRINGAGG production. + ExitSTRINGAGG(c *STRINGAGGContext) + + // ExitSTRING_ESCAPE is called when exiting the STRING_ESCAPE production. + ExitSTRING_ESCAPE(c *STRING_ESCAPEContext) + + // ExitSTUFF is called when exiting the STUFF production. + ExitSTUFF(c *STUFFContext) + + // ExitSUBSTRING is called when exiting the SUBSTRING production. + ExitSUBSTRING(c *SUBSTRINGContext) + + // ExitTRANSLATE is called when exiting the TRANSLATE production. + ExitTRANSLATE(c *TRANSLATEContext) + + // ExitTRIM is called when exiting the TRIM production. + ExitTRIM(c *TRIMContext) + + // ExitUNICODE is called when exiting the UNICODE production. + ExitUNICODE(c *UNICODEContext) + + // ExitUPPER is called when exiting the UPPER production. + ExitUPPER(c *UPPERContext) + + // ExitBINARY_CHECKSUM is called when exiting the BINARY_CHECKSUM production. + ExitBINARY_CHECKSUM(c *BINARY_CHECKSUMContext) + + // ExitCHECKSUM is called when exiting the CHECKSUM production. + ExitCHECKSUM(c *CHECKSUMContext) + + // ExitCOMPRESS is called when exiting the COMPRESS production. + ExitCOMPRESS(c *COMPRESSContext) + + // ExitCONNECTIONPROPERTY is called when exiting the CONNECTIONPROPERTY production. + ExitCONNECTIONPROPERTY(c *CONNECTIONPROPERTYContext) + + // ExitCONTEXT_INFO is called when exiting the CONTEXT_INFO production. + ExitCONTEXT_INFO(c *CONTEXT_INFOContext) + + // ExitCURRENT_REQUEST_ID is called when exiting the CURRENT_REQUEST_ID production. + ExitCURRENT_REQUEST_ID(c *CURRENT_REQUEST_IDContext) + + // ExitCURRENT_TRANSACTION_ID is called when exiting the CURRENT_TRANSACTION_ID production. + ExitCURRENT_TRANSACTION_ID(c *CURRENT_TRANSACTION_IDContext) + + // ExitDECOMPRESS is called when exiting the DECOMPRESS production. + ExitDECOMPRESS(c *DECOMPRESSContext) + + // ExitERROR_LINE is called when exiting the ERROR_LINE production. + ExitERROR_LINE(c *ERROR_LINEContext) + + // ExitERROR_MESSAGE is called when exiting the ERROR_MESSAGE production. + ExitERROR_MESSAGE(c *ERROR_MESSAGEContext) + + // ExitERROR_NUMBER is called when exiting the ERROR_NUMBER production. + ExitERROR_NUMBER(c *ERROR_NUMBERContext) + + // ExitERROR_PROCEDURE is called when exiting the ERROR_PROCEDURE production. + ExitERROR_PROCEDURE(c *ERROR_PROCEDUREContext) + + // ExitERROR_SEVERITY is called when exiting the ERROR_SEVERITY production. + ExitERROR_SEVERITY(c *ERROR_SEVERITYContext) + + // ExitERROR_STATE is called when exiting the ERROR_STATE production. + ExitERROR_STATE(c *ERROR_STATEContext) + + // ExitFORMATMESSAGE is called when exiting the FORMATMESSAGE production. + ExitFORMATMESSAGE(c *FORMATMESSAGEContext) + + // ExitGET_FILESTREAM_TRANSACTION_CONTEXT is called when exiting the GET_FILESTREAM_TRANSACTION_CONTEXT production. + ExitGET_FILESTREAM_TRANSACTION_CONTEXT(c *GET_FILESTREAM_TRANSACTION_CONTEXTContext) + + // ExitGETANSINULL is called when exiting the GETANSINULL production. + ExitGETANSINULL(c *GETANSINULLContext) + + // ExitHOST_ID is called when exiting the HOST_ID production. + ExitHOST_ID(c *HOST_IDContext) + + // ExitHOST_NAME is called when exiting the HOST_NAME production. + ExitHOST_NAME(c *HOST_NAMEContext) + + // ExitISNULL is called when exiting the ISNULL production. + ExitISNULL(c *ISNULLContext) + + // ExitISNUMERIC is called when exiting the ISNUMERIC production. + ExitISNUMERIC(c *ISNUMERICContext) + + // ExitMIN_ACTIVE_ROWVERSION is called when exiting the MIN_ACTIVE_ROWVERSION production. + ExitMIN_ACTIVE_ROWVERSION(c *MIN_ACTIVE_ROWVERSIONContext) + + // ExitNEWID is called when exiting the NEWID production. + ExitNEWID(c *NEWIDContext) + + // ExitNEWSEQUENTIALID is called when exiting the NEWSEQUENTIALID production. + ExitNEWSEQUENTIALID(c *NEWSEQUENTIALIDContext) + + // ExitROWCOUNT_BIG is called when exiting the ROWCOUNT_BIG production. + ExitROWCOUNT_BIG(c *ROWCOUNT_BIGContext) + + // ExitSESSION_CONTEXT is called when exiting the SESSION_CONTEXT production. + ExitSESSION_CONTEXT(c *SESSION_CONTEXTContext) + + // ExitXACT_STATE is called when exiting the XACT_STATE production. + ExitXACT_STATE(c *XACT_STATEContext) + + // ExitCAST is called when exiting the CAST production. + ExitCAST(c *CASTContext) + + // ExitTRY_CAST is called when exiting the TRY_CAST production. + ExitTRY_CAST(c *TRY_CASTContext) + + // ExitCONVERT is called when exiting the CONVERT production. + ExitCONVERT(c *CONVERTContext) + + // ExitCOALESCE is called when exiting the COALESCE production. + ExitCOALESCE(c *COALESCEContext) + + // ExitCURSOR_ROWS is called when exiting the CURSOR_ROWS production. + ExitCURSOR_ROWS(c *CURSOR_ROWSContext) + + // ExitFETCH_STATUS is called when exiting the FETCH_STATUS production. + ExitFETCH_STATUS(c *FETCH_STATUSContext) + + // ExitCURSOR_STATUS is called when exiting the CURSOR_STATUS production. + ExitCURSOR_STATUS(c *CURSOR_STATUSContext) + + // ExitCERT_ID is called when exiting the CERT_ID production. + ExitCERT_ID(c *CERT_IDContext) + + // ExitDATALENGTH is called when exiting the DATALENGTH production. + ExitDATALENGTH(c *DATALENGTHContext) + + // ExitIDENT_CURRENT is called when exiting the IDENT_CURRENT production. + ExitIDENT_CURRENT(c *IDENT_CURRENTContext) + + // ExitIDENT_INCR is called when exiting the IDENT_INCR production. + ExitIDENT_INCR(c *IDENT_INCRContext) + + // ExitIDENT_SEED is called when exiting the IDENT_SEED production. + ExitIDENT_SEED(c *IDENT_SEEDContext) + + // ExitIDENTITY is called when exiting the IDENTITY production. + ExitIDENTITY(c *IDENTITYContext) + + // ExitSQL_VARIANT_PROPERTY is called when exiting the SQL_VARIANT_PROPERTY production. + ExitSQL_VARIANT_PROPERTY(c *SQL_VARIANT_PROPERTYContext) + + // ExitCURRENT_DATE is called when exiting the CURRENT_DATE production. + ExitCURRENT_DATE(c *CURRENT_DATEContext) + + // ExitCURRENT_TIMESTAMP is called when exiting the CURRENT_TIMESTAMP production. + ExitCURRENT_TIMESTAMP(c *CURRENT_TIMESTAMPContext) + + // ExitCURRENT_TIMEZONE is called when exiting the CURRENT_TIMEZONE production. + ExitCURRENT_TIMEZONE(c *CURRENT_TIMEZONEContext) + + // ExitCURRENT_TIMEZONE_ID is called when exiting the CURRENT_TIMEZONE_ID production. + ExitCURRENT_TIMEZONE_ID(c *CURRENT_TIMEZONE_IDContext) + + // ExitDATE_BUCKET is called when exiting the DATE_BUCKET production. + ExitDATE_BUCKET(c *DATE_BUCKETContext) + + // ExitDATEADD is called when exiting the DATEADD production. + ExitDATEADD(c *DATEADDContext) + + // ExitDATEDIFF is called when exiting the DATEDIFF production. + ExitDATEDIFF(c *DATEDIFFContext) + + // ExitDATEDIFF_BIG is called when exiting the DATEDIFF_BIG production. + ExitDATEDIFF_BIG(c *DATEDIFF_BIGContext) + + // ExitDATEFROMPARTS is called when exiting the DATEFROMPARTS production. + ExitDATEFROMPARTS(c *DATEFROMPARTSContext) + + // ExitDATENAME is called when exiting the DATENAME production. + ExitDATENAME(c *DATENAMEContext) + + // ExitDATEPART is called when exiting the DATEPART production. + ExitDATEPART(c *DATEPARTContext) + + // ExitDATETIME2FROMPARTS is called when exiting the DATETIME2FROMPARTS production. + ExitDATETIME2FROMPARTS(c *DATETIME2FROMPARTSContext) + + // ExitDATETIMEFROMPARTS is called when exiting the DATETIMEFROMPARTS production. + ExitDATETIMEFROMPARTS(c *DATETIMEFROMPARTSContext) + + // ExitDATETIMEOFFSETFROMPARTS is called when exiting the DATETIMEOFFSETFROMPARTS production. + ExitDATETIMEOFFSETFROMPARTS(c *DATETIMEOFFSETFROMPARTSContext) + + // ExitDATETRUNC is called when exiting the DATETRUNC production. + ExitDATETRUNC(c *DATETRUNCContext) + + // ExitDAY is called when exiting the DAY production. + ExitDAY(c *DAYContext) + + // ExitEOMONTH is called when exiting the EOMONTH production. + ExitEOMONTH(c *EOMONTHContext) + + // ExitGETDATE is called when exiting the GETDATE production. + ExitGETDATE(c *GETDATEContext) + + // ExitGETUTCDATE is called when exiting the GETUTCDATE production. + ExitGETUTCDATE(c *GETUTCDATEContext) + + // ExitISDATE is called when exiting the ISDATE production. + ExitISDATE(c *ISDATEContext) + + // ExitMONTH is called when exiting the MONTH production. + ExitMONTH(c *MONTHContext) + + // ExitSMALLDATETIMEFROMPARTS is called when exiting the SMALLDATETIMEFROMPARTS production. + ExitSMALLDATETIMEFROMPARTS(c *SMALLDATETIMEFROMPARTSContext) + + // ExitSWITCHOFFSET is called when exiting the SWITCHOFFSET production. + ExitSWITCHOFFSET(c *SWITCHOFFSETContext) + + // ExitSYSDATETIME is called when exiting the SYSDATETIME production. + ExitSYSDATETIME(c *SYSDATETIMEContext) + + // ExitSYSDATETIMEOFFSET is called when exiting the SYSDATETIMEOFFSET production. + ExitSYSDATETIMEOFFSET(c *SYSDATETIMEOFFSETContext) + + // ExitSYSUTCDATETIME is called when exiting the SYSUTCDATETIME production. + ExitSYSUTCDATETIME(c *SYSUTCDATETIMEContext) + + // ExitTIMEFROMPARTS is called when exiting the TIMEFROMPARTS production. + ExitTIMEFROMPARTS(c *TIMEFROMPARTSContext) + + // ExitTODATETIMEOFFSET is called when exiting the TODATETIMEOFFSET production. + ExitTODATETIMEOFFSET(c *TODATETIMEOFFSETContext) + + // ExitYEAR is called when exiting the YEAR production. + ExitYEAR(c *YEARContext) + + // ExitNULLIF is called when exiting the NULLIF production. + ExitNULLIF(c *NULLIFContext) + + // ExitPARSE is called when exiting the PARSE production. + ExitPARSE(c *PARSEContext) + + // ExitXML_DATA_TYPE_FUNC is called when exiting the XML_DATA_TYPE_FUNC production. + ExitXML_DATA_TYPE_FUNC(c *XML_DATA_TYPE_FUNCContext) + + // ExitIIF is called when exiting the IIF production. + ExitIIF(c *IIFContext) + + // ExitISJSON is called when exiting the ISJSON production. + ExitISJSON(c *ISJSONContext) + + // ExitJSON_OBJECT is called when exiting the JSON_OBJECT production. + ExitJSON_OBJECT(c *JSON_OBJECTContext) + + // ExitJSON_ARRAY is called when exiting the JSON_ARRAY production. + ExitJSON_ARRAY(c *JSON_ARRAYContext) + + // ExitJSON_VALUE is called when exiting the JSON_VALUE production. + ExitJSON_VALUE(c *JSON_VALUEContext) + + // ExitJSON_QUERY is called when exiting the JSON_QUERY production. + ExitJSON_QUERY(c *JSON_QUERYContext) + + // ExitJSON_MODIFY is called when exiting the JSON_MODIFY production. + ExitJSON_MODIFY(c *JSON_MODIFYContext) + + // ExitJSON_PATH_EXISTS is called when exiting the JSON_PATH_EXISTS production. + ExitJSON_PATH_EXISTS(c *JSON_PATH_EXISTSContext) + + // ExitABS is called when exiting the ABS production. + ExitABS(c *ABSContext) + + // ExitACOS is called when exiting the ACOS production. + ExitACOS(c *ACOSContext) + + // ExitASIN is called when exiting the ASIN production. + ExitASIN(c *ASINContext) + + // ExitATAN is called when exiting the ATAN production. + ExitATAN(c *ATANContext) + + // ExitATN2 is called when exiting the ATN2 production. + ExitATN2(c *ATN2Context) + + // ExitCEILING is called when exiting the CEILING production. + ExitCEILING(c *CEILINGContext) + + // ExitCOS is called when exiting the COS production. + ExitCOS(c *COSContext) + + // ExitCOT is called when exiting the COT production. + ExitCOT(c *COTContext) + + // ExitDEGREES is called when exiting the DEGREES production. + ExitDEGREES(c *DEGREESContext) + + // ExitEXP is called when exiting the EXP production. + ExitEXP(c *EXPContext) + + // ExitFLOOR is called when exiting the FLOOR production. + ExitFLOOR(c *FLOORContext) + + // ExitLOG is called when exiting the LOG production. + ExitLOG(c *LOGContext) + + // ExitLOG10 is called when exiting the LOG10 production. + ExitLOG10(c *LOG10Context) + + // ExitPI is called when exiting the PI production. + ExitPI(c *PIContext) + + // ExitPOWER is called when exiting the POWER production. + ExitPOWER(c *POWERContext) + + // ExitRADIANS is called when exiting the RADIANS production. + ExitRADIANS(c *RADIANSContext) + + // ExitRAND is called when exiting the RAND production. + ExitRAND(c *RANDContext) + + // ExitROUND is called when exiting the ROUND production. + ExitROUND(c *ROUNDContext) + + // ExitMATH_SIGN is called when exiting the MATH_SIGN production. + ExitMATH_SIGN(c *MATH_SIGNContext) + + // ExitSIN is called when exiting the SIN production. + ExitSIN(c *SINContext) + + // ExitSQRT is called when exiting the SQRT production. + ExitSQRT(c *SQRTContext) + + // ExitSQUARE is called when exiting the SQUARE production. + ExitSQUARE(c *SQUAREContext) + + // ExitTAN is called when exiting the TAN production. + ExitTAN(c *TANContext) + + // ExitGREATEST is called when exiting the GREATEST production. + ExitGREATEST(c *GREATESTContext) + + // ExitLEAST is called when exiting the LEAST production. + ExitLEAST(c *LEASTContext) + + // ExitCERTENCODED is called when exiting the CERTENCODED production. + ExitCERTENCODED(c *CERTENCODEDContext) + + // ExitCERTPRIVATEKEY is called when exiting the CERTPRIVATEKEY production. + ExitCERTPRIVATEKEY(c *CERTPRIVATEKEYContext) + + // ExitCURRENT_USER is called when exiting the CURRENT_USER production. + ExitCURRENT_USER(c *CURRENT_USERContext) + + // ExitDATABASE_PRINCIPAL_ID is called when exiting the DATABASE_PRINCIPAL_ID production. + ExitDATABASE_PRINCIPAL_ID(c *DATABASE_PRINCIPAL_IDContext) + + // ExitHAS_DBACCESS is called when exiting the HAS_DBACCESS production. + ExitHAS_DBACCESS(c *HAS_DBACCESSContext) + + // ExitHAS_PERMS_BY_NAME is called when exiting the HAS_PERMS_BY_NAME production. + ExitHAS_PERMS_BY_NAME(c *HAS_PERMS_BY_NAMEContext) + + // ExitIS_MEMBER is called when exiting the IS_MEMBER production. + ExitIS_MEMBER(c *IS_MEMBERContext) + + // ExitIS_ROLEMEMBER is called when exiting the IS_ROLEMEMBER production. + ExitIS_ROLEMEMBER(c *IS_ROLEMEMBERContext) + + // ExitIS_SRVROLEMEMBER is called when exiting the IS_SRVROLEMEMBER production. + ExitIS_SRVROLEMEMBER(c *IS_SRVROLEMEMBERContext) + + // ExitLOGINPROPERTY is called when exiting the LOGINPROPERTY production. + ExitLOGINPROPERTY(c *LOGINPROPERTYContext) + + // ExitORIGINAL_LOGIN is called when exiting the ORIGINAL_LOGIN production. + ExitORIGINAL_LOGIN(c *ORIGINAL_LOGINContext) + + // ExitPERMISSIONS is called when exiting the PERMISSIONS production. + ExitPERMISSIONS(c *PERMISSIONSContext) + + // ExitPWDENCRYPT is called when exiting the PWDENCRYPT production. + ExitPWDENCRYPT(c *PWDENCRYPTContext) + + // ExitPWDCOMPARE is called when exiting the PWDCOMPARE production. + ExitPWDCOMPARE(c *PWDCOMPAREContext) + + // ExitSESSION_USER is called when exiting the SESSION_USER production. + ExitSESSION_USER(c *SESSION_USERContext) + + // ExitSESSIONPROPERTY is called when exiting the SESSIONPROPERTY production. + ExitSESSIONPROPERTY(c *SESSIONPROPERTYContext) + + // ExitSUSER_ID is called when exiting the SUSER_ID production. + ExitSUSER_ID(c *SUSER_IDContext) + + // ExitSUSER_SNAME is called when exiting the SUSER_SNAME production. + ExitSUSER_SNAME(c *SUSER_SNAMEContext) + + // ExitSUSER_SID is called when exiting the SUSER_SID production. + ExitSUSER_SID(c *SUSER_SIDContext) + + // ExitSYSTEM_USER is called when exiting the SYSTEM_USER production. + ExitSYSTEM_USER(c *SYSTEM_USERContext) + + // ExitUSER is called when exiting the USER production. + ExitUSER(c *USERContext) + + // ExitUSER_ID is called when exiting the USER_ID production. + ExitUSER_ID(c *USER_IDContext) + + // ExitUSER_NAME is called when exiting the USER_NAME production. + ExitUSER_NAME(c *USER_NAMEContext) + + // ExitXml_data_type_methods is called when exiting the xml_data_type_methods production. + ExitXml_data_type_methods(c *Xml_data_type_methodsContext) + + // ExitDateparts_9 is called when exiting the dateparts_9 production. + ExitDateparts_9(c *Dateparts_9Context) + + // ExitDateparts_12 is called when exiting the dateparts_12 production. + ExitDateparts_12(c *Dateparts_12Context) + + // ExitDateparts_15 is called when exiting the dateparts_15 production. + ExitDateparts_15(c *Dateparts_15Context) + + // ExitDateparts_datetrunc is called when exiting the dateparts_datetrunc production. + ExitDateparts_datetrunc(c *Dateparts_datetruncContext) + + // ExitValue_method is called when exiting the value_method production. + ExitValue_method(c *Value_methodContext) + + // ExitValue_call is called when exiting the value_call production. + ExitValue_call(c *Value_callContext) + + // ExitQuery_method is called when exiting the query_method production. + ExitQuery_method(c *Query_methodContext) + + // ExitQuery_call is called when exiting the query_call production. + ExitQuery_call(c *Query_callContext) + + // ExitExist_method is called when exiting the exist_method production. + ExitExist_method(c *Exist_methodContext) + + // ExitExist_call is called when exiting the exist_call production. + ExitExist_call(c *Exist_callContext) + + // ExitModify_method is called when exiting the modify_method production. + ExitModify_method(c *Modify_methodContext) + + // ExitModify_call is called when exiting the modify_call production. + ExitModify_call(c *Modify_callContext) + + // ExitHierarchyid_call is called when exiting the hierarchyid_call production. + ExitHierarchyid_call(c *Hierarchyid_callContext) + + // ExitHierarchyid_static_method is called when exiting the hierarchyid_static_method production. + ExitHierarchyid_static_method(c *Hierarchyid_static_methodContext) + + // ExitNodes_method is called when exiting the nodes_method production. + ExitNodes_method(c *Nodes_methodContext) + + // ExitSwitch_section is called when exiting the switch_section production. + ExitSwitch_section(c *Switch_sectionContext) + + // ExitSwitch_search_condition_section is called when exiting the switch_search_condition_section production. + ExitSwitch_search_condition_section(c *Switch_search_condition_sectionContext) + + // ExitAs_column_alias is called when exiting the as_column_alias production. + ExitAs_column_alias(c *As_column_aliasContext) + + // ExitAs_table_alias is called when exiting the as_table_alias production. + ExitAs_table_alias(c *As_table_aliasContext) + + // ExitTable_alias is called when exiting the table_alias production. + ExitTable_alias(c *Table_aliasContext) + + // ExitWith_table_hints is called when exiting the with_table_hints production. + ExitWith_table_hints(c *With_table_hintsContext) + + // ExitDeprecated_table_hint is called when exiting the deprecated_table_hint production. + ExitDeprecated_table_hint(c *Deprecated_table_hintContext) + + // ExitSybase_legacy_hints is called when exiting the sybase_legacy_hints production. + ExitSybase_legacy_hints(c *Sybase_legacy_hintsContext) + + // ExitSybase_legacy_hint is called when exiting the sybase_legacy_hint production. + ExitSybase_legacy_hint(c *Sybase_legacy_hintContext) + + // ExitTable_hint is called when exiting the table_hint production. + ExitTable_hint(c *Table_hintContext) + + // ExitIndex_value is called when exiting the index_value production. + ExitIndex_value(c *Index_valueContext) + + // ExitColumn_alias_list is called when exiting the column_alias_list production. + ExitColumn_alias_list(c *Column_alias_listContext) + + // ExitColumn_alias is called when exiting the column_alias production. + ExitColumn_alias(c *Column_aliasContext) + + // ExitTable_value_constructor is called when exiting the table_value_constructor production. + ExitTable_value_constructor(c *Table_value_constructorContext) + + // ExitExpression_list_ is called when exiting the expression_list_ production. + ExitExpression_list_(c *Expression_list_Context) + + // ExitRanking_windowed_function is called when exiting the ranking_windowed_function production. + ExitRanking_windowed_function(c *Ranking_windowed_functionContext) + + // ExitAggregate_windowed_function is called when exiting the aggregate_windowed_function production. + ExitAggregate_windowed_function(c *Aggregate_windowed_functionContext) + + // ExitAnalytic_windowed_function is called when exiting the analytic_windowed_function production. + ExitAnalytic_windowed_function(c *Analytic_windowed_functionContext) + + // ExitAll_distinct_expression is called when exiting the all_distinct_expression production. + ExitAll_distinct_expression(c *All_distinct_expressionContext) + + // ExitOver_clause is called when exiting the over_clause production. + ExitOver_clause(c *Over_clauseContext) + + // ExitRow_or_range_clause is called when exiting the row_or_range_clause production. + ExitRow_or_range_clause(c *Row_or_range_clauseContext) + + // ExitWindow_frame_extent is called when exiting the window_frame_extent production. + ExitWindow_frame_extent(c *Window_frame_extentContext) + + // ExitWindow_frame_bound is called when exiting the window_frame_bound production. + ExitWindow_frame_bound(c *Window_frame_boundContext) + + // ExitWindow_frame_preceding is called when exiting the window_frame_preceding production. + ExitWindow_frame_preceding(c *Window_frame_precedingContext) + + // ExitWindow_frame_following is called when exiting the window_frame_following production. + ExitWindow_frame_following(c *Window_frame_followingContext) + + // ExitCreate_database_option is called when exiting the create_database_option production. + ExitCreate_database_option(c *Create_database_optionContext) + + // ExitDatabase_filestream_option is called when exiting the database_filestream_option production. + ExitDatabase_filestream_option(c *Database_filestream_optionContext) + + // ExitDatabase_file_spec is called when exiting the database_file_spec production. + ExitDatabase_file_spec(c *Database_file_specContext) + + // ExitFile_group is called when exiting the file_group production. + ExitFile_group(c *File_groupContext) + + // ExitFile_spec is called when exiting the file_spec production. + ExitFile_spec(c *File_specContext) + + // ExitEntity_name is called when exiting the entity_name production. + ExitEntity_name(c *Entity_nameContext) + + // ExitEntity_name_for_azure_dw is called when exiting the entity_name_for_azure_dw production. + ExitEntity_name_for_azure_dw(c *Entity_name_for_azure_dwContext) + + // ExitEntity_name_for_parallel_dw is called when exiting the entity_name_for_parallel_dw production. + ExitEntity_name_for_parallel_dw(c *Entity_name_for_parallel_dwContext) + + // ExitFull_table_name is called when exiting the full_table_name production. + ExitFull_table_name(c *Full_table_nameContext) + + // ExitDotID is called when exiting the dotID production. + ExitDotID(c *DotIDContext) + + // ExitDoubleDotID is called when exiting the doubleDotID production. + ExitDoubleDotID(c *DoubleDotIDContext) + + // ExitTable_name is called when exiting the table_name production. + ExitTable_name(c *Table_nameContext) + + // ExitSimple_name is called when exiting the simple_name production. + ExitSimple_name(c *Simple_nameContext) + + // ExitFunc_proc_name_schema is called when exiting the func_proc_name_schema production. + ExitFunc_proc_name_schema(c *Func_proc_name_schemaContext) + + // ExitFunc_proc_name_database_schema is called when exiting the func_proc_name_database_schema production. + ExitFunc_proc_name_database_schema(c *Func_proc_name_database_schemaContext) + + // ExitFunc_proc_name_server_database_schema is called when exiting the func_proc_name_server_database_schema production. + ExitFunc_proc_name_server_database_schema(c *Func_proc_name_server_database_schemaContext) + + // ExitDdl_object is called when exiting the ddl_object production. + ExitDdl_object(c *Ddl_objectContext) + + // ExitFull_column_name is called when exiting the full_column_name production. + ExitFull_column_name(c *Full_column_nameContext) + + // ExitColumn_name_list_with_order is called when exiting the column_name_list_with_order production. + ExitColumn_name_list_with_order(c *Column_name_list_with_orderContext) + + // ExitColumn_name_with_order is called when exiting the column_name_with_order production. + ExitColumn_name_with_order(c *Column_name_with_orderContext) + + // ExitInsert_column_name_list is called when exiting the insert_column_name_list production. + ExitInsert_column_name_list(c *Insert_column_name_listContext) + + // ExitInsert_column_id is called when exiting the insert_column_id production. + ExitInsert_column_id(c *Insert_column_idContext) + + // ExitColumn_name_list is called when exiting the column_name_list production. + ExitColumn_name_list(c *Column_name_listContext) + + // ExitCursor_name is called when exiting the cursor_name production. + ExitCursor_name(c *Cursor_nameContext) + + // ExitOn_off is called when exiting the on_off production. + ExitOn_off(c *On_offContext) + + // ExitClustered is called when exiting the clustered production. + ExitClustered(c *ClusteredContext) + + // ExitNull_notnull is called when exiting the null_notnull production. + ExitNull_notnull(c *Null_notnullContext) + + // ExitScalar_function_name is called when exiting the scalar_function_name production. + ExitScalar_function_name(c *Scalar_function_nameContext) + + // ExitBegin_conversation_timer is called when exiting the begin_conversation_timer production. + ExitBegin_conversation_timer(c *Begin_conversation_timerContext) + + // ExitBegin_conversation_dialog is called when exiting the begin_conversation_dialog production. + ExitBegin_conversation_dialog(c *Begin_conversation_dialogContext) + + // ExitContract_name is called when exiting the contract_name production. + ExitContract_name(c *Contract_nameContext) + + // ExitService_name is called when exiting the service_name production. + ExitService_name(c *Service_nameContext) + + // ExitEnd_conversation is called when exiting the end_conversation production. + ExitEnd_conversation(c *End_conversationContext) + + // ExitWaitfor_conversation is called when exiting the waitfor_conversation production. + ExitWaitfor_conversation(c *Waitfor_conversationContext) + + // ExitGet_conversation is called when exiting the get_conversation production. + ExitGet_conversation(c *Get_conversationContext) + + // ExitQueue_id is called when exiting the queue_id production. + ExitQueue_id(c *Queue_idContext) + + // ExitSend_conversation is called when exiting the send_conversation production. + ExitSend_conversation(c *Send_conversationContext) + + // ExitData_type is called when exiting the data_type production. + ExitData_type(c *Data_typeContext) + + // ExitConstant is called when exiting the constant production. + ExitConstant(c *ConstantContext) + + // ExitPrimitive_constant is called when exiting the primitive_constant production. + ExitPrimitive_constant(c *Primitive_constantContext) + + // ExitKeyword is called when exiting the keyword production. + ExitKeyword(c *KeywordContext) + + // ExitId_ is called when exiting the id_ production. + ExitId_(c *Id_Context) + + // ExitSimple_id is called when exiting the simple_id production. + ExitSimple_id(c *Simple_idContext) + + // ExitId_or_string is called when exiting the id_or_string production. + ExitId_or_string(c *Id_or_stringContext) + + // ExitComparison_operator is called when exiting the comparison_operator production. + ExitComparison_operator(c *Comparison_operatorContext) + + // ExitAssignment_operator is called when exiting the assignment_operator production. + ExitAssignment_operator(c *Assignment_operatorContext) + + // ExitFile_size is called when exiting the file_size production. + ExitFile_size(c *File_sizeContext) +} diff --git a/tsql/tsqlparser_visitor.go b/tsql/tsqlparser_visitor.go new file mode 100644 index 0000000..cd2f0e7 --- /dev/null +++ b/tsql/tsqlparser_visitor.go @@ -0,0 +1,2487 @@ +// Code generated from TSqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package tsql // TSqlParser +import "github.com/antlr4-go/antlr/v4" + +// A complete Visitor for a parse tree produced by TSqlParser. +type TSqlParserVisitor interface { + antlr.ParseTreeVisitor + + // Visit a parse tree produced by TSqlParser#tsql_file. + VisitTsql_file(ctx *Tsql_fileContext) interface{} + + // Visit a parse tree produced by TSqlParser#batch_without_go. + VisitBatch_without_go(ctx *Batch_without_goContext) interface{} + + // Visit a parse tree produced by TSqlParser#batch_level_statement. + VisitBatch_level_statement(ctx *Batch_level_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#sql_clauses. + VisitSql_clauses(ctx *Sql_clausesContext) interface{} + + // Visit a parse tree produced by TSqlParser#dml_clause. + VisitDml_clause(ctx *Dml_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#ddl_clause. + VisitDdl_clause(ctx *Ddl_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#backup_statement. + VisitBackup_statement(ctx *Backup_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#cfl_statement. + VisitCfl_statement(ctx *Cfl_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#block_statement. + VisitBlock_statement(ctx *Block_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#break_statement. + VisitBreak_statement(ctx *Break_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#continue_statement. + VisitContinue_statement(ctx *Continue_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#goto_statement. + VisitGoto_statement(ctx *Goto_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#return_statement. + VisitReturn_statement(ctx *Return_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#if_statement. + VisitIf_statement(ctx *If_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#throw_statement. + VisitThrow_statement(ctx *Throw_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#throw_error_number. + VisitThrow_error_number(ctx *Throw_error_numberContext) interface{} + + // Visit a parse tree produced by TSqlParser#throw_message. + VisitThrow_message(ctx *Throw_messageContext) interface{} + + // Visit a parse tree produced by TSqlParser#throw_state. + VisitThrow_state(ctx *Throw_stateContext) interface{} + + // Visit a parse tree produced by TSqlParser#try_catch_statement. + VisitTry_catch_statement(ctx *Try_catch_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#waitfor_statement. + VisitWaitfor_statement(ctx *Waitfor_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#while_statement. + VisitWhile_statement(ctx *While_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#print_statement. + VisitPrint_statement(ctx *Print_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#raiseerror_statement. + VisitRaiseerror_statement(ctx *Raiseerror_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#empty_statement. + VisitEmpty_statement(ctx *Empty_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#another_statement. + VisitAnother_statement(ctx *Another_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_application_role. + VisitAlter_application_role(ctx *Alter_application_roleContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_xml_schema_collection. + VisitAlter_xml_schema_collection(ctx *Alter_xml_schema_collectionContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_application_role. + VisitCreate_application_role(ctx *Create_application_roleContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_aggregate. + VisitDrop_aggregate(ctx *Drop_aggregateContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_application_role. + VisitDrop_application_role(ctx *Drop_application_roleContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly. + VisitAlter_assembly(ctx *Alter_assemblyContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_start. + VisitAlter_assembly_start(ctx *Alter_assembly_startContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_clause. + VisitAlter_assembly_clause(ctx *Alter_assembly_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_from_clause. + VisitAlter_assembly_from_clause(ctx *Alter_assembly_from_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_from_clause_start. + VisitAlter_assembly_from_clause_start(ctx *Alter_assembly_from_clause_startContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_drop_clause. + VisitAlter_assembly_drop_clause(ctx *Alter_assembly_drop_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_drop_multiple_files. + VisitAlter_assembly_drop_multiple_files(ctx *Alter_assembly_drop_multiple_filesContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_drop. + VisitAlter_assembly_drop(ctx *Alter_assembly_dropContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_add_clause. + VisitAlter_assembly_add_clause(ctx *Alter_assembly_add_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_asssembly_add_clause_start. + VisitAlter_asssembly_add_clause_start(ctx *Alter_asssembly_add_clause_startContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_client_file_clause. + VisitAlter_assembly_client_file_clause(ctx *Alter_assembly_client_file_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_file_name. + VisitAlter_assembly_file_name(ctx *Alter_assembly_file_nameContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_file_bits. + VisitAlter_assembly_file_bits(ctx *Alter_assembly_file_bitsContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_as. + VisitAlter_assembly_as(ctx *Alter_assembly_asContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_with_clause. + VisitAlter_assembly_with_clause(ctx *Alter_assembly_with_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_assembly_with. + VisitAlter_assembly_with(ctx *Alter_assembly_withContext) interface{} + + // Visit a parse tree produced by TSqlParser#client_assembly_specifier. + VisitClient_assembly_specifier(ctx *Client_assembly_specifierContext) interface{} + + // Visit a parse tree produced by TSqlParser#assembly_option. + VisitAssembly_option(ctx *Assembly_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#network_file_share. + VisitNetwork_file_share(ctx *Network_file_shareContext) interface{} + + // Visit a parse tree produced by TSqlParser#network_computer. + VisitNetwork_computer(ctx *Network_computerContext) interface{} + + // Visit a parse tree produced by TSqlParser#network_file_start. + VisitNetwork_file_start(ctx *Network_file_startContext) interface{} + + // Visit a parse tree produced by TSqlParser#file_path. + VisitFile_path(ctx *File_pathContext) interface{} + + // Visit a parse tree produced by TSqlParser#file_directory_path_separator. + VisitFile_directory_path_separator(ctx *File_directory_path_separatorContext) interface{} + + // Visit a parse tree produced by TSqlParser#local_file. + VisitLocal_file(ctx *Local_fileContext) interface{} + + // Visit a parse tree produced by TSqlParser#local_drive. + VisitLocal_drive(ctx *Local_driveContext) interface{} + + // Visit a parse tree produced by TSqlParser#multiple_local_files. + VisitMultiple_local_files(ctx *Multiple_local_filesContext) interface{} + + // Visit a parse tree produced by TSqlParser#multiple_local_file_start. + VisitMultiple_local_file_start(ctx *Multiple_local_file_startContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_assembly. + VisitCreate_assembly(ctx *Create_assemblyContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_assembly. + VisitDrop_assembly(ctx *Drop_assemblyContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_asymmetric_key. + VisitAlter_asymmetric_key(ctx *Alter_asymmetric_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_asymmetric_key_start. + VisitAlter_asymmetric_key_start(ctx *Alter_asymmetric_key_startContext) interface{} + + // Visit a parse tree produced by TSqlParser#asymmetric_key_option. + VisitAsymmetric_key_option(ctx *Asymmetric_key_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#asymmetric_key_option_start. + VisitAsymmetric_key_option_start(ctx *Asymmetric_key_option_startContext) interface{} + + // Visit a parse tree produced by TSqlParser#asymmetric_key_password_change_option. + VisitAsymmetric_key_password_change_option(ctx *Asymmetric_key_password_change_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_asymmetric_key. + VisitCreate_asymmetric_key(ctx *Create_asymmetric_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_asymmetric_key. + VisitDrop_asymmetric_key(ctx *Drop_asymmetric_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_authorization. + VisitAlter_authorization(ctx *Alter_authorizationContext) interface{} + + // Visit a parse tree produced by TSqlParser#authorization_grantee. + VisitAuthorization_grantee(ctx *Authorization_granteeContext) interface{} + + // Visit a parse tree produced by TSqlParser#entity_to. + VisitEntity_to(ctx *Entity_toContext) interface{} + + // Visit a parse tree produced by TSqlParser#colon_colon. + VisitColon_colon(ctx *Colon_colonContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_authorization_start. + VisitAlter_authorization_start(ctx *Alter_authorization_startContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_authorization_for_sql_database. + VisitAlter_authorization_for_sql_database(ctx *Alter_authorization_for_sql_databaseContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_authorization_for_azure_dw. + VisitAlter_authorization_for_azure_dw(ctx *Alter_authorization_for_azure_dwContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_authorization_for_parallel_dw. + VisitAlter_authorization_for_parallel_dw(ctx *Alter_authorization_for_parallel_dwContext) interface{} + + // Visit a parse tree produced by TSqlParser#class_type. + VisitClass_type(ctx *Class_typeContext) interface{} + + // Visit a parse tree produced by TSqlParser#class_type_for_sql_database. + VisitClass_type_for_sql_database(ctx *Class_type_for_sql_databaseContext) interface{} + + // Visit a parse tree produced by TSqlParser#class_type_for_azure_dw. + VisitClass_type_for_azure_dw(ctx *Class_type_for_azure_dwContext) interface{} + + // Visit a parse tree produced by TSqlParser#class_type_for_parallel_dw. + VisitClass_type_for_parallel_dw(ctx *Class_type_for_parallel_dwContext) interface{} + + // Visit a parse tree produced by TSqlParser#class_type_for_grant. + VisitClass_type_for_grant(ctx *Class_type_for_grantContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_availability_group. + VisitDrop_availability_group(ctx *Drop_availability_groupContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_availability_group. + VisitAlter_availability_group(ctx *Alter_availability_groupContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_availability_group_start. + VisitAlter_availability_group_start(ctx *Alter_availability_group_startContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_availability_group_options. + VisitAlter_availability_group_options(ctx *Alter_availability_group_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#ip_v4_failover. + VisitIp_v4_failover(ctx *Ip_v4_failoverContext) interface{} + + // Visit a parse tree produced by TSqlParser#ip_v6_failover. + VisitIp_v6_failover(ctx *Ip_v6_failoverContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_or_alter_broker_priority. + VisitCreate_or_alter_broker_priority(ctx *Create_or_alter_broker_priorityContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_broker_priority. + VisitDrop_broker_priority(ctx *Drop_broker_priorityContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_certificate. + VisitAlter_certificate(ctx *Alter_certificateContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_column_encryption_key. + VisitAlter_column_encryption_key(ctx *Alter_column_encryption_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_column_encryption_key. + VisitCreate_column_encryption_key(ctx *Create_column_encryption_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_certificate. + VisitDrop_certificate(ctx *Drop_certificateContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_column_encryption_key. + VisitDrop_column_encryption_key(ctx *Drop_column_encryption_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_column_master_key. + VisitDrop_column_master_key(ctx *Drop_column_master_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_contract. + VisitDrop_contract(ctx *Drop_contractContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_credential. + VisitDrop_credential(ctx *Drop_credentialContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_cryptograhic_provider. + VisitDrop_cryptograhic_provider(ctx *Drop_cryptograhic_providerContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_database. + VisitDrop_database(ctx *Drop_databaseContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_database_audit_specification. + VisitDrop_database_audit_specification(ctx *Drop_database_audit_specificationContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_database_encryption_key. + VisitDrop_database_encryption_key(ctx *Drop_database_encryption_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_database_scoped_credential. + VisitDrop_database_scoped_credential(ctx *Drop_database_scoped_credentialContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_default. + VisitDrop_default(ctx *Drop_defaultContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_endpoint. + VisitDrop_endpoint(ctx *Drop_endpointContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_external_data_source. + VisitDrop_external_data_source(ctx *Drop_external_data_sourceContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_external_file_format. + VisitDrop_external_file_format(ctx *Drop_external_file_formatContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_external_library. + VisitDrop_external_library(ctx *Drop_external_libraryContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_external_resource_pool. + VisitDrop_external_resource_pool(ctx *Drop_external_resource_poolContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_external_table. + VisitDrop_external_table(ctx *Drop_external_tableContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_event_notifications. + VisitDrop_event_notifications(ctx *Drop_event_notificationsContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_event_session. + VisitDrop_event_session(ctx *Drop_event_sessionContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_fulltext_catalog. + VisitDrop_fulltext_catalog(ctx *Drop_fulltext_catalogContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_fulltext_index. + VisitDrop_fulltext_index(ctx *Drop_fulltext_indexContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_fulltext_stoplist. + VisitDrop_fulltext_stoplist(ctx *Drop_fulltext_stoplistContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_login. + VisitDrop_login(ctx *Drop_loginContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_master_key. + VisitDrop_master_key(ctx *Drop_master_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_message_type. + VisitDrop_message_type(ctx *Drop_message_typeContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_partition_function. + VisitDrop_partition_function(ctx *Drop_partition_functionContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_partition_scheme. + VisitDrop_partition_scheme(ctx *Drop_partition_schemeContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_queue. + VisitDrop_queue(ctx *Drop_queueContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_remote_service_binding. + VisitDrop_remote_service_binding(ctx *Drop_remote_service_bindingContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_resource_pool. + VisitDrop_resource_pool(ctx *Drop_resource_poolContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_db_role. + VisitDrop_db_role(ctx *Drop_db_roleContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_route. + VisitDrop_route(ctx *Drop_routeContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_rule. + VisitDrop_rule(ctx *Drop_ruleContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_schema. + VisitDrop_schema(ctx *Drop_schemaContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_search_property_list. + VisitDrop_search_property_list(ctx *Drop_search_property_listContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_security_policy. + VisitDrop_security_policy(ctx *Drop_security_policyContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_sequence. + VisitDrop_sequence(ctx *Drop_sequenceContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_server_audit. + VisitDrop_server_audit(ctx *Drop_server_auditContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_server_audit_specification. + VisitDrop_server_audit_specification(ctx *Drop_server_audit_specificationContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_server_role. + VisitDrop_server_role(ctx *Drop_server_roleContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_service. + VisitDrop_service(ctx *Drop_serviceContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_signature. + VisitDrop_signature(ctx *Drop_signatureContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_statistics_name_azure_dw_and_pdw. + VisitDrop_statistics_name_azure_dw_and_pdw(ctx *Drop_statistics_name_azure_dw_and_pdwContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_symmetric_key. + VisitDrop_symmetric_key(ctx *Drop_symmetric_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_synonym. + VisitDrop_synonym(ctx *Drop_synonymContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_user. + VisitDrop_user(ctx *Drop_userContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_workload_group. + VisitDrop_workload_group(ctx *Drop_workload_groupContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_xml_schema_collection. + VisitDrop_xml_schema_collection(ctx *Drop_xml_schema_collectionContext) interface{} + + // Visit a parse tree produced by TSqlParser#disable_trigger. + VisitDisable_trigger(ctx *Disable_triggerContext) interface{} + + // Visit a parse tree produced by TSqlParser#enable_trigger. + VisitEnable_trigger(ctx *Enable_triggerContext) interface{} + + // Visit a parse tree produced by TSqlParser#lock_table. + VisitLock_table(ctx *Lock_tableContext) interface{} + + // Visit a parse tree produced by TSqlParser#truncate_table. + VisitTruncate_table(ctx *Truncate_tableContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_column_master_key. + VisitCreate_column_master_key(ctx *Create_column_master_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_credential. + VisitAlter_credential(ctx *Alter_credentialContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_credential. + VisitCreate_credential(ctx *Create_credentialContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_cryptographic_provider. + VisitAlter_cryptographic_provider(ctx *Alter_cryptographic_providerContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_cryptographic_provider. + VisitCreate_cryptographic_provider(ctx *Create_cryptographic_providerContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_endpoint. + VisitCreate_endpoint(ctx *Create_endpointContext) interface{} + + // Visit a parse tree produced by TSqlParser#endpoint_encryption_alogorithm_clause. + VisitEndpoint_encryption_alogorithm_clause(ctx *Endpoint_encryption_alogorithm_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#endpoint_authentication_clause. + VisitEndpoint_authentication_clause(ctx *Endpoint_authentication_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#endpoint_listener_clause. + VisitEndpoint_listener_clause(ctx *Endpoint_listener_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_event_notification. + VisitCreate_event_notification(ctx *Create_event_notificationContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_or_alter_event_session. + VisitCreate_or_alter_event_session(ctx *Create_or_alter_event_sessionContext) interface{} + + // Visit a parse tree produced by TSqlParser#event_session_predicate_expression. + VisitEvent_session_predicate_expression(ctx *Event_session_predicate_expressionContext) interface{} + + // Visit a parse tree produced by TSqlParser#event_session_predicate_factor. + VisitEvent_session_predicate_factor(ctx *Event_session_predicate_factorContext) interface{} + + // Visit a parse tree produced by TSqlParser#event_session_predicate_leaf. + VisitEvent_session_predicate_leaf(ctx *Event_session_predicate_leafContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_external_data_source. + VisitAlter_external_data_source(ctx *Alter_external_data_sourceContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_external_library. + VisitAlter_external_library(ctx *Alter_external_libraryContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_external_library. + VisitCreate_external_library(ctx *Create_external_libraryContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_external_resource_pool. + VisitAlter_external_resource_pool(ctx *Alter_external_resource_poolContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_external_resource_pool. + VisitCreate_external_resource_pool(ctx *Create_external_resource_poolContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_fulltext_catalog. + VisitAlter_fulltext_catalog(ctx *Alter_fulltext_catalogContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_fulltext_catalog. + VisitCreate_fulltext_catalog(ctx *Create_fulltext_catalogContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_fulltext_stoplist. + VisitAlter_fulltext_stoplist(ctx *Alter_fulltext_stoplistContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_fulltext_stoplist. + VisitCreate_fulltext_stoplist(ctx *Create_fulltext_stoplistContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_login_sql_server. + VisitAlter_login_sql_server(ctx *Alter_login_sql_serverContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_login_sql_server. + VisitCreate_login_sql_server(ctx *Create_login_sql_serverContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_login_azure_sql. + VisitAlter_login_azure_sql(ctx *Alter_login_azure_sqlContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_login_azure_sql. + VisitCreate_login_azure_sql(ctx *Create_login_azure_sqlContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_login_azure_sql_dw_and_pdw. + VisitAlter_login_azure_sql_dw_and_pdw(ctx *Alter_login_azure_sql_dw_and_pdwContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_login_pdw. + VisitCreate_login_pdw(ctx *Create_login_pdwContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_master_key_sql_server. + VisitAlter_master_key_sql_server(ctx *Alter_master_key_sql_serverContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_master_key_sql_server. + VisitCreate_master_key_sql_server(ctx *Create_master_key_sql_serverContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_master_key_azure_sql. + VisitAlter_master_key_azure_sql(ctx *Alter_master_key_azure_sqlContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_master_key_azure_sql. + VisitCreate_master_key_azure_sql(ctx *Create_master_key_azure_sqlContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_message_type. + VisitAlter_message_type(ctx *Alter_message_typeContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_partition_function. + VisitAlter_partition_function(ctx *Alter_partition_functionContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_partition_scheme. + VisitAlter_partition_scheme(ctx *Alter_partition_schemeContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_remote_service_binding. + VisitAlter_remote_service_binding(ctx *Alter_remote_service_bindingContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_remote_service_binding. + VisitCreate_remote_service_binding(ctx *Create_remote_service_bindingContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_resource_pool. + VisitCreate_resource_pool(ctx *Create_resource_poolContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_resource_governor. + VisitAlter_resource_governor(ctx *Alter_resource_governorContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_database_audit_specification. + VisitAlter_database_audit_specification(ctx *Alter_database_audit_specificationContext) interface{} + + // Visit a parse tree produced by TSqlParser#audit_action_spec_group. + VisitAudit_action_spec_group(ctx *Audit_action_spec_groupContext) interface{} + + // Visit a parse tree produced by TSqlParser#audit_action_specification. + VisitAudit_action_specification(ctx *Audit_action_specificationContext) interface{} + + // Visit a parse tree produced by TSqlParser#action_specification. + VisitAction_specification(ctx *Action_specificationContext) interface{} + + // Visit a parse tree produced by TSqlParser#audit_class_name. + VisitAudit_class_name(ctx *Audit_class_nameContext) interface{} + + // Visit a parse tree produced by TSqlParser#audit_securable. + VisitAudit_securable(ctx *Audit_securableContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_db_role. + VisitAlter_db_role(ctx *Alter_db_roleContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_database_audit_specification. + VisitCreate_database_audit_specification(ctx *Create_database_audit_specificationContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_db_role. + VisitCreate_db_role(ctx *Create_db_roleContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_route. + VisitCreate_route(ctx *Create_routeContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_rule. + VisitCreate_rule(ctx *Create_ruleContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_schema_sql. + VisitAlter_schema_sql(ctx *Alter_schema_sqlContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_schema. + VisitCreate_schema(ctx *Create_schemaContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_schema_azure_sql_dw_and_pdw. + VisitCreate_schema_azure_sql_dw_and_pdw(ctx *Create_schema_azure_sql_dw_and_pdwContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_schema_azure_sql_dw_and_pdw. + VisitAlter_schema_azure_sql_dw_and_pdw(ctx *Alter_schema_azure_sql_dw_and_pdwContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_search_property_list. + VisitCreate_search_property_list(ctx *Create_search_property_listContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_security_policy. + VisitCreate_security_policy(ctx *Create_security_policyContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_sequence. + VisitAlter_sequence(ctx *Alter_sequenceContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_sequence. + VisitCreate_sequence(ctx *Create_sequenceContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_server_audit. + VisitAlter_server_audit(ctx *Alter_server_auditContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_server_audit. + VisitCreate_server_audit(ctx *Create_server_auditContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_server_audit_specification. + VisitAlter_server_audit_specification(ctx *Alter_server_audit_specificationContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_server_audit_specification. + VisitCreate_server_audit_specification(ctx *Create_server_audit_specificationContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_server_configuration. + VisitAlter_server_configuration(ctx *Alter_server_configurationContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_server_role. + VisitAlter_server_role(ctx *Alter_server_roleContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_server_role. + VisitCreate_server_role(ctx *Create_server_roleContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_server_role_pdw. + VisitAlter_server_role_pdw(ctx *Alter_server_role_pdwContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_service. + VisitAlter_service(ctx *Alter_serviceContext) interface{} + + // Visit a parse tree produced by TSqlParser#opt_arg_clause. + VisitOpt_arg_clause(ctx *Opt_arg_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_service. + VisitCreate_service(ctx *Create_serviceContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_service_master_key. + VisitAlter_service_master_key(ctx *Alter_service_master_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_symmetric_key. + VisitAlter_symmetric_key(ctx *Alter_symmetric_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_synonym. + VisitCreate_synonym(ctx *Create_synonymContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_user. + VisitAlter_user(ctx *Alter_userContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_user. + VisitCreate_user(ctx *Create_userContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_user_azure_sql_dw. + VisitCreate_user_azure_sql_dw(ctx *Create_user_azure_sql_dwContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_user_azure_sql. + VisitAlter_user_azure_sql(ctx *Alter_user_azure_sqlContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_workload_group. + VisitAlter_workload_group(ctx *Alter_workload_groupContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_workload_group. + VisitCreate_workload_group(ctx *Create_workload_groupContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_xml_schema_collection. + VisitCreate_xml_schema_collection(ctx *Create_xml_schema_collectionContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_partition_function. + VisitCreate_partition_function(ctx *Create_partition_functionContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_partition_scheme. + VisitCreate_partition_scheme(ctx *Create_partition_schemeContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_queue. + VisitCreate_queue(ctx *Create_queueContext) interface{} + + // Visit a parse tree produced by TSqlParser#queue_settings. + VisitQueue_settings(ctx *Queue_settingsContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_queue. + VisitAlter_queue(ctx *Alter_queueContext) interface{} + + // Visit a parse tree produced by TSqlParser#queue_action. + VisitQueue_action(ctx *Queue_actionContext) interface{} + + // Visit a parse tree produced by TSqlParser#queue_rebuild_options. + VisitQueue_rebuild_options(ctx *Queue_rebuild_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_contract. + VisitCreate_contract(ctx *Create_contractContext) interface{} + + // Visit a parse tree produced by TSqlParser#conversation_statement. + VisitConversation_statement(ctx *Conversation_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#message_statement. + VisitMessage_statement(ctx *Message_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#merge_statement. + VisitMerge_statement(ctx *Merge_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#when_matches. + VisitWhen_matches(ctx *When_matchesContext) interface{} + + // Visit a parse tree produced by TSqlParser#merge_matched. + VisitMerge_matched(ctx *Merge_matchedContext) interface{} + + // Visit a parse tree produced by TSqlParser#merge_not_matched. + VisitMerge_not_matched(ctx *Merge_not_matchedContext) interface{} + + // Visit a parse tree produced by TSqlParser#delete_statement. + VisitDelete_statement(ctx *Delete_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#delete_statement_from. + VisitDelete_statement_from(ctx *Delete_statement_fromContext) interface{} + + // Visit a parse tree produced by TSqlParser#insert_statement. + VisitInsert_statement(ctx *Insert_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#insert_statement_value. + VisitInsert_statement_value(ctx *Insert_statement_valueContext) interface{} + + // Visit a parse tree produced by TSqlParser#receive_statement. + VisitReceive_statement(ctx *Receive_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#select_statement_standalone. + VisitSelect_statement_standalone(ctx *Select_statement_standaloneContext) interface{} + + // Visit a parse tree produced by TSqlParser#select_statement. + VisitSelect_statement(ctx *Select_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#time. + VisitTime(ctx *TimeContext) interface{} + + // Visit a parse tree produced by TSqlParser#update_statement. + VisitUpdate_statement(ctx *Update_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#output_clause. + VisitOutput_clause(ctx *Output_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#output_dml_list_elem. + VisitOutput_dml_list_elem(ctx *Output_dml_list_elemContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_database. + VisitCreate_database(ctx *Create_databaseContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_index. + VisitCreate_index(ctx *Create_indexContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_spatial_index. + VisitCreate_spatial_index(ctx *Create_spatial_indexContext) interface{} + + // Visit a parse tree produced by TSqlParser#spatial_tessellation_scheme. + VisitSpatial_tessellation_scheme(ctx *Spatial_tessellation_schemeContext) interface{} + + // Visit a parse tree produced by TSqlParser#spatial_index_options. + VisitSpatial_index_options(ctx *Spatial_index_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#spatial_index_option. + VisitSpatial_index_option(ctx *Spatial_index_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#signed_decimal. + VisitSigned_decimal(ctx *Signed_decimalContext) interface{} + + // Visit a parse tree produced by TSqlParser#spatial_grid_level. + VisitSpatial_grid_level(ctx *Spatial_grid_levelContext) interface{} + + // Visit a parse tree produced by TSqlParser#spatial_grid_density. + VisitSpatial_grid_density(ctx *Spatial_grid_densityContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_index_options. + VisitCreate_index_options(ctx *Create_index_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#relational_index_option. + VisitRelational_index_option(ctx *Relational_index_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_index. + VisitAlter_index(ctx *Alter_indexContext) interface{} + + // Visit a parse tree produced by TSqlParser#resumable_index_options. + VisitResumable_index_options(ctx *Resumable_index_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#resumable_index_option. + VisitResumable_index_option(ctx *Resumable_index_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#reorganize_partition. + VisitReorganize_partition(ctx *Reorganize_partitionContext) interface{} + + // Visit a parse tree produced by TSqlParser#reorganize_options. + VisitReorganize_options(ctx *Reorganize_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#reorganize_option. + VisitReorganize_option(ctx *Reorganize_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#set_index_options. + VisitSet_index_options(ctx *Set_index_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#set_index_option. + VisitSet_index_option(ctx *Set_index_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#rebuild_partition. + VisitRebuild_partition(ctx *Rebuild_partitionContext) interface{} + + // Visit a parse tree produced by TSqlParser#rebuild_index_options. + VisitRebuild_index_options(ctx *Rebuild_index_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#rebuild_index_option. + VisitRebuild_index_option(ctx *Rebuild_index_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#single_partition_rebuild_index_options. + VisitSingle_partition_rebuild_index_options(ctx *Single_partition_rebuild_index_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#single_partition_rebuild_index_option. + VisitSingle_partition_rebuild_index_option(ctx *Single_partition_rebuild_index_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#on_partitions. + VisitOn_partitions(ctx *On_partitionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_columnstore_index. + VisitCreate_columnstore_index(ctx *Create_columnstore_indexContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_columnstore_index_options. + VisitCreate_columnstore_index_options(ctx *Create_columnstore_index_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#columnstore_index_option. + VisitColumnstore_index_option(ctx *Columnstore_index_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_nonclustered_columnstore_index. + VisitCreate_nonclustered_columnstore_index(ctx *Create_nonclustered_columnstore_indexContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_xml_index. + VisitCreate_xml_index(ctx *Create_xml_indexContext) interface{} + + // Visit a parse tree produced by TSqlParser#xml_index_options. + VisitXml_index_options(ctx *Xml_index_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#xml_index_option. + VisitXml_index_option(ctx *Xml_index_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_or_alter_procedure. + VisitCreate_or_alter_procedure(ctx *Create_or_alter_procedureContext) interface{} + + // Visit a parse tree produced by TSqlParser#as_external_name. + VisitAs_external_name(ctx *As_external_nameContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_or_alter_trigger. + VisitCreate_or_alter_trigger(ctx *Create_or_alter_triggerContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_or_alter_dml_trigger. + VisitCreate_or_alter_dml_trigger(ctx *Create_or_alter_dml_triggerContext) interface{} + + // Visit a parse tree produced by TSqlParser#dml_trigger_option. + VisitDml_trigger_option(ctx *Dml_trigger_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#dml_trigger_operation. + VisitDml_trigger_operation(ctx *Dml_trigger_operationContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_or_alter_ddl_trigger. + VisitCreate_or_alter_ddl_trigger(ctx *Create_or_alter_ddl_triggerContext) interface{} + + // Visit a parse tree produced by TSqlParser#ddl_trigger_operation. + VisitDdl_trigger_operation(ctx *Ddl_trigger_operationContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_or_alter_function. + VisitCreate_or_alter_function(ctx *Create_or_alter_functionContext) interface{} + + // Visit a parse tree produced by TSqlParser#func_body_returns_select. + VisitFunc_body_returns_select(ctx *Func_body_returns_selectContext) interface{} + + // Visit a parse tree produced by TSqlParser#func_body_returns_table. + VisitFunc_body_returns_table(ctx *Func_body_returns_tableContext) interface{} + + // Visit a parse tree produced by TSqlParser#func_body_returns_scalar. + VisitFunc_body_returns_scalar(ctx *Func_body_returns_scalarContext) interface{} + + // Visit a parse tree produced by TSqlParser#procedure_param_default_value. + VisitProcedure_param_default_value(ctx *Procedure_param_default_valueContext) interface{} + + // Visit a parse tree produced by TSqlParser#procedure_param. + VisitProcedure_param(ctx *Procedure_paramContext) interface{} + + // Visit a parse tree produced by TSqlParser#procedure_option. + VisitProcedure_option(ctx *Procedure_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#function_option. + VisitFunction_option(ctx *Function_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_statistics. + VisitCreate_statistics(ctx *Create_statisticsContext) interface{} + + // Visit a parse tree produced by TSqlParser#update_statistics. + VisitUpdate_statistics(ctx *Update_statisticsContext) interface{} + + // Visit a parse tree produced by TSqlParser#update_statistics_options. + VisitUpdate_statistics_options(ctx *Update_statistics_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#update_statistics_option. + VisitUpdate_statistics_option(ctx *Update_statistics_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_table. + VisitCreate_table(ctx *Create_tableContext) interface{} + + // Visit a parse tree produced by TSqlParser#table_indices. + VisitTable_indices(ctx *Table_indicesContext) interface{} + + // Visit a parse tree produced by TSqlParser#table_options. + VisitTable_options(ctx *Table_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#table_option. + VisitTable_option(ctx *Table_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_table_index_options. + VisitCreate_table_index_options(ctx *Create_table_index_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_table_index_option. + VisitCreate_table_index_option(ctx *Create_table_index_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_view. + VisitCreate_view(ctx *Create_viewContext) interface{} + + // Visit a parse tree produced by TSqlParser#view_attribute. + VisitView_attribute(ctx *View_attributeContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_table. + VisitAlter_table(ctx *Alter_tableContext) interface{} + + // Visit a parse tree produced by TSqlParser#switch_partition. + VisitSwitch_partition(ctx *Switch_partitionContext) interface{} + + // Visit a parse tree produced by TSqlParser#low_priority_lock_wait. + VisitLow_priority_lock_wait(ctx *Low_priority_lock_waitContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_database. + VisitAlter_database(ctx *Alter_databaseContext) interface{} + + // Visit a parse tree produced by TSqlParser#add_or_modify_files. + VisitAdd_or_modify_files(ctx *Add_or_modify_filesContext) interface{} + + // Visit a parse tree produced by TSqlParser#filespec. + VisitFilespec(ctx *FilespecContext) interface{} + + // Visit a parse tree produced by TSqlParser#add_or_modify_filegroups. + VisitAdd_or_modify_filegroups(ctx *Add_or_modify_filegroupsContext) interface{} + + // Visit a parse tree produced by TSqlParser#filegroup_updatability_option. + VisitFilegroup_updatability_option(ctx *Filegroup_updatability_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#database_optionspec. + VisitDatabase_optionspec(ctx *Database_optionspecContext) interface{} + + // Visit a parse tree produced by TSqlParser#auto_option. + VisitAuto_option(ctx *Auto_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#change_tracking_option. + VisitChange_tracking_option(ctx *Change_tracking_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#change_tracking_option_list. + VisitChange_tracking_option_list(ctx *Change_tracking_option_listContext) interface{} + + // Visit a parse tree produced by TSqlParser#containment_option. + VisitContainment_option(ctx *Containment_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#cursor_option. + VisitCursor_option(ctx *Cursor_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_endpoint. + VisitAlter_endpoint(ctx *Alter_endpointContext) interface{} + + // Visit a parse tree produced by TSqlParser#database_mirroring_option. + VisitDatabase_mirroring_option(ctx *Database_mirroring_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#mirroring_set_option. + VisitMirroring_set_option(ctx *Mirroring_set_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#mirroring_partner. + VisitMirroring_partner(ctx *Mirroring_partnerContext) interface{} + + // Visit a parse tree produced by TSqlParser#mirroring_witness. + VisitMirroring_witness(ctx *Mirroring_witnessContext) interface{} + + // Visit a parse tree produced by TSqlParser#witness_partner_equal. + VisitWitness_partner_equal(ctx *Witness_partner_equalContext) interface{} + + // Visit a parse tree produced by TSqlParser#partner_option. + VisitPartner_option(ctx *Partner_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#witness_option. + VisitWitness_option(ctx *Witness_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#witness_server. + VisitWitness_server(ctx *Witness_serverContext) interface{} + + // Visit a parse tree produced by TSqlParser#partner_server. + VisitPartner_server(ctx *Partner_serverContext) interface{} + + // Visit a parse tree produced by TSqlParser#mirroring_host_port_seperator. + VisitMirroring_host_port_seperator(ctx *Mirroring_host_port_seperatorContext) interface{} + + // Visit a parse tree produced by TSqlParser#partner_server_tcp_prefix. + VisitPartner_server_tcp_prefix(ctx *Partner_server_tcp_prefixContext) interface{} + + // Visit a parse tree produced by TSqlParser#port_number. + VisitPort_number(ctx *Port_numberContext) interface{} + + // Visit a parse tree produced by TSqlParser#host. + VisitHost(ctx *HostContext) interface{} + + // Visit a parse tree produced by TSqlParser#date_correlation_optimization_option. + VisitDate_correlation_optimization_option(ctx *Date_correlation_optimization_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#db_encryption_option. + VisitDb_encryption_option(ctx *Db_encryption_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#db_state_option. + VisitDb_state_option(ctx *Db_state_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#db_update_option. + VisitDb_update_option(ctx *Db_update_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#db_user_access_option. + VisitDb_user_access_option(ctx *Db_user_access_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#delayed_durability_option. + VisitDelayed_durability_option(ctx *Delayed_durability_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#external_access_option. + VisitExternal_access_option(ctx *External_access_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#hadr_options. + VisitHadr_options(ctx *Hadr_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#mixed_page_allocation_option. + VisitMixed_page_allocation_option(ctx *Mixed_page_allocation_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#parameterization_option. + VisitParameterization_option(ctx *Parameterization_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#recovery_option. + VisitRecovery_option(ctx *Recovery_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#service_broker_option. + VisitService_broker_option(ctx *Service_broker_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#snapshot_option. + VisitSnapshot_option(ctx *Snapshot_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#sql_option. + VisitSql_option(ctx *Sql_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#target_recovery_time_option. + VisitTarget_recovery_time_option(ctx *Target_recovery_time_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#termination. + VisitTermination(ctx *TerminationContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_index. + VisitDrop_index(ctx *Drop_indexContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_relational_or_xml_or_spatial_index. + VisitDrop_relational_or_xml_or_spatial_index(ctx *Drop_relational_or_xml_or_spatial_indexContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_backward_compatible_index. + VisitDrop_backward_compatible_index(ctx *Drop_backward_compatible_indexContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_procedure. + VisitDrop_procedure(ctx *Drop_procedureContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_trigger. + VisitDrop_trigger(ctx *Drop_triggerContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_dml_trigger. + VisitDrop_dml_trigger(ctx *Drop_dml_triggerContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_ddl_trigger. + VisitDrop_ddl_trigger(ctx *Drop_ddl_triggerContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_function. + VisitDrop_function(ctx *Drop_functionContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_statistics. + VisitDrop_statistics(ctx *Drop_statisticsContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_table. + VisitDrop_table(ctx *Drop_tableContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_view. + VisitDrop_view(ctx *Drop_viewContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_type. + VisitCreate_type(ctx *Create_typeContext) interface{} + + // Visit a parse tree produced by TSqlParser#drop_type. + VisitDrop_type(ctx *Drop_typeContext) interface{} + + // Visit a parse tree produced by TSqlParser#rowset_function_limited. + VisitRowset_function_limited(ctx *Rowset_function_limitedContext) interface{} + + // Visit a parse tree produced by TSqlParser#openquery. + VisitOpenquery(ctx *OpenqueryContext) interface{} + + // Visit a parse tree produced by TSqlParser#opendatasource. + VisitOpendatasource(ctx *OpendatasourceContext) interface{} + + // Visit a parse tree produced by TSqlParser#declare_statement. + VisitDeclare_statement(ctx *Declare_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#xml_declaration. + VisitXml_declaration(ctx *Xml_declarationContext) interface{} + + // Visit a parse tree produced by TSqlParser#cursor_statement. + VisitCursor_statement(ctx *Cursor_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#backup_database. + VisitBackup_database(ctx *Backup_databaseContext) interface{} + + // Visit a parse tree produced by TSqlParser#backup_log. + VisitBackup_log(ctx *Backup_logContext) interface{} + + // Visit a parse tree produced by TSqlParser#backup_certificate. + VisitBackup_certificate(ctx *Backup_certificateContext) interface{} + + // Visit a parse tree produced by TSqlParser#backup_master_key. + VisitBackup_master_key(ctx *Backup_master_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#backup_service_master_key. + VisitBackup_service_master_key(ctx *Backup_service_master_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#kill_statement. + VisitKill_statement(ctx *Kill_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#kill_process. + VisitKill_process(ctx *Kill_processContext) interface{} + + // Visit a parse tree produced by TSqlParser#kill_query_notification. + VisitKill_query_notification(ctx *Kill_query_notificationContext) interface{} + + // Visit a parse tree produced by TSqlParser#kill_stats_job. + VisitKill_stats_job(ctx *Kill_stats_jobContext) interface{} + + // Visit a parse tree produced by TSqlParser#execute_statement. + VisitExecute_statement(ctx *Execute_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#execute_body_batch. + VisitExecute_body_batch(ctx *Execute_body_batchContext) interface{} + + // Visit a parse tree produced by TSqlParser#execute_body. + VisitExecute_body(ctx *Execute_bodyContext) interface{} + + // Visit a parse tree produced by TSqlParser#execute_statement_arg. + VisitExecute_statement_arg(ctx *Execute_statement_argContext) interface{} + + // Visit a parse tree produced by TSqlParser#execute_statement_arg_named. + VisitExecute_statement_arg_named(ctx *Execute_statement_arg_namedContext) interface{} + + // Visit a parse tree produced by TSqlParser#execute_statement_arg_unnamed. + VisitExecute_statement_arg_unnamed(ctx *Execute_statement_arg_unnamedContext) interface{} + + // Visit a parse tree produced by TSqlParser#execute_parameter. + VisitExecute_parameter(ctx *Execute_parameterContext) interface{} + + // Visit a parse tree produced by TSqlParser#execute_var_string. + VisitExecute_var_string(ctx *Execute_var_stringContext) interface{} + + // Visit a parse tree produced by TSqlParser#security_statement. + VisitSecurity_statement(ctx *Security_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#principal_id. + VisitPrincipal_id(ctx *Principal_idContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_certificate. + VisitCreate_certificate(ctx *Create_certificateContext) interface{} + + // Visit a parse tree produced by TSqlParser#existing_keys. + VisitExisting_keys(ctx *Existing_keysContext) interface{} + + // Visit a parse tree produced by TSqlParser#private_key_options. + VisitPrivate_key_options(ctx *Private_key_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#generate_new_keys. + VisitGenerate_new_keys(ctx *Generate_new_keysContext) interface{} + + // Visit a parse tree produced by TSqlParser#date_options. + VisitDate_options(ctx *Date_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#open_key. + VisitOpen_key(ctx *Open_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#close_key. + VisitClose_key(ctx *Close_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_key. + VisitCreate_key(ctx *Create_keyContext) interface{} + + // Visit a parse tree produced by TSqlParser#key_options. + VisitKey_options(ctx *Key_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#algorithm. + VisitAlgorithm(ctx *AlgorithmContext) interface{} + + // Visit a parse tree produced by TSqlParser#encryption_mechanism. + VisitEncryption_mechanism(ctx *Encryption_mechanismContext) interface{} + + // Visit a parse tree produced by TSqlParser#decryption_mechanism. + VisitDecryption_mechanism(ctx *Decryption_mechanismContext) interface{} + + // Visit a parse tree produced by TSqlParser#grant_permission. + VisitGrant_permission(ctx *Grant_permissionContext) interface{} + + // Visit a parse tree produced by TSqlParser#set_statement. + VisitSet_statement(ctx *Set_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#transaction_statement. + VisitTransaction_statement(ctx *Transaction_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#go_statement. + VisitGo_statement(ctx *Go_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#use_statement. + VisitUse_statement(ctx *Use_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#setuser_statement. + VisitSetuser_statement(ctx *Setuser_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#reconfigure_statement. + VisitReconfigure_statement(ctx *Reconfigure_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#shutdown_statement. + VisitShutdown_statement(ctx *Shutdown_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#checkpoint_statement. + VisitCheckpoint_statement(ctx *Checkpoint_statementContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_checkalloc_option. + VisitDbcc_checkalloc_option(ctx *Dbcc_checkalloc_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_checkalloc. + VisitDbcc_checkalloc(ctx *Dbcc_checkallocContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_checkcatalog. + VisitDbcc_checkcatalog(ctx *Dbcc_checkcatalogContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_checkconstraints_option. + VisitDbcc_checkconstraints_option(ctx *Dbcc_checkconstraints_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_checkconstraints. + VisitDbcc_checkconstraints(ctx *Dbcc_checkconstraintsContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_checkdb_table_option. + VisitDbcc_checkdb_table_option(ctx *Dbcc_checkdb_table_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_checkdb. + VisitDbcc_checkdb(ctx *Dbcc_checkdbContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_checkfilegroup_option. + VisitDbcc_checkfilegroup_option(ctx *Dbcc_checkfilegroup_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_checkfilegroup. + VisitDbcc_checkfilegroup(ctx *Dbcc_checkfilegroupContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_checktable. + VisitDbcc_checktable(ctx *Dbcc_checktableContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_cleantable. + VisitDbcc_cleantable(ctx *Dbcc_cleantableContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_clonedatabase_option. + VisitDbcc_clonedatabase_option(ctx *Dbcc_clonedatabase_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_clonedatabase. + VisitDbcc_clonedatabase(ctx *Dbcc_clonedatabaseContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_pdw_showspaceused. + VisitDbcc_pdw_showspaceused(ctx *Dbcc_pdw_showspaceusedContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_proccache. + VisitDbcc_proccache(ctx *Dbcc_proccacheContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_showcontig_option. + VisitDbcc_showcontig_option(ctx *Dbcc_showcontig_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_showcontig. + VisitDbcc_showcontig(ctx *Dbcc_showcontigContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_shrinklog. + VisitDbcc_shrinklog(ctx *Dbcc_shrinklogContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_dbreindex. + VisitDbcc_dbreindex(ctx *Dbcc_dbreindexContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_dll_free. + VisitDbcc_dll_free(ctx *Dbcc_dll_freeContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_dropcleanbuffers. + VisitDbcc_dropcleanbuffers(ctx *Dbcc_dropcleanbuffersContext) interface{} + + // Visit a parse tree produced by TSqlParser#dbcc_clause. + VisitDbcc_clause(ctx *Dbcc_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#execute_clause. + VisitExecute_clause(ctx *Execute_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#declare_local. + VisitDeclare_local(ctx *Declare_localContext) interface{} + + // Visit a parse tree produced by TSqlParser#table_type_definition. + VisitTable_type_definition(ctx *Table_type_definitionContext) interface{} + + // Visit a parse tree produced by TSqlParser#table_type_indices. + VisitTable_type_indices(ctx *Table_type_indicesContext) interface{} + + // Visit a parse tree produced by TSqlParser#xml_type_definition. + VisitXml_type_definition(ctx *Xml_type_definitionContext) interface{} + + // Visit a parse tree produced by TSqlParser#xml_schema_collection. + VisitXml_schema_collection(ctx *Xml_schema_collectionContext) interface{} + + // Visit a parse tree produced by TSqlParser#column_def_table_constraints. + VisitColumn_def_table_constraints(ctx *Column_def_table_constraintsContext) interface{} + + // Visit a parse tree produced by TSqlParser#column_def_table_constraint. + VisitColumn_def_table_constraint(ctx *Column_def_table_constraintContext) interface{} + + // Visit a parse tree produced by TSqlParser#column_definition. + VisitColumn_definition(ctx *Column_definitionContext) interface{} + + // Visit a parse tree produced by TSqlParser#column_definition_element. + VisitColumn_definition_element(ctx *Column_definition_elementContext) interface{} + + // Visit a parse tree produced by TSqlParser#column_modifier. + VisitColumn_modifier(ctx *Column_modifierContext) interface{} + + // Visit a parse tree produced by TSqlParser#materialized_column_definition. + VisitMaterialized_column_definition(ctx *Materialized_column_definitionContext) interface{} + + // Visit a parse tree produced by TSqlParser#column_constraint. + VisitColumn_constraint(ctx *Column_constraintContext) interface{} + + // Visit a parse tree produced by TSqlParser#column_index. + VisitColumn_index(ctx *Column_indexContext) interface{} + + // Visit a parse tree produced by TSqlParser#on_partition_or_filegroup. + VisitOn_partition_or_filegroup(ctx *On_partition_or_filegroupContext) interface{} + + // Visit a parse tree produced by TSqlParser#table_constraint. + VisitTable_constraint(ctx *Table_constraintContext) interface{} + + // Visit a parse tree produced by TSqlParser#connection_node. + VisitConnection_node(ctx *Connection_nodeContext) interface{} + + // Visit a parse tree produced by TSqlParser#primary_key_options. + VisitPrimary_key_options(ctx *Primary_key_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#foreign_key_options. + VisitForeign_key_options(ctx *Foreign_key_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#check_constraint. + VisitCheck_constraint(ctx *Check_constraintContext) interface{} + + // Visit a parse tree produced by TSqlParser#on_delete. + VisitOn_delete(ctx *On_deleteContext) interface{} + + // Visit a parse tree produced by TSqlParser#on_update. + VisitOn_update(ctx *On_updateContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_table_index_options. + VisitAlter_table_index_options(ctx *Alter_table_index_optionsContext) interface{} + + // Visit a parse tree produced by TSqlParser#alter_table_index_option. + VisitAlter_table_index_option(ctx *Alter_table_index_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#declare_cursor. + VisitDeclare_cursor(ctx *Declare_cursorContext) interface{} + + // Visit a parse tree produced by TSqlParser#declare_set_cursor_common. + VisitDeclare_set_cursor_common(ctx *Declare_set_cursor_commonContext) interface{} + + // Visit a parse tree produced by TSqlParser#declare_set_cursor_common_partial. + VisitDeclare_set_cursor_common_partial(ctx *Declare_set_cursor_common_partialContext) interface{} + + // Visit a parse tree produced by TSqlParser#fetch_cursor. + VisitFetch_cursor(ctx *Fetch_cursorContext) interface{} + + // Visit a parse tree produced by TSqlParser#set_special. + VisitSet_special(ctx *Set_specialContext) interface{} + + // Visit a parse tree produced by TSqlParser#special_list. + VisitSpecial_list(ctx *Special_listContext) interface{} + + // Visit a parse tree produced by TSqlParser#constant_LOCAL_ID. + VisitConstant_LOCAL_ID(ctx *Constant_LOCAL_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#expression. + VisitExpression(ctx *ExpressionContext) interface{} + + // Visit a parse tree produced by TSqlParser#parameter. + VisitParameter(ctx *ParameterContext) interface{} + + // Visit a parse tree produced by TSqlParser#time_zone. + VisitTime_zone(ctx *Time_zoneContext) interface{} + + // Visit a parse tree produced by TSqlParser#primitive_expression. + VisitPrimitive_expression(ctx *Primitive_expressionContext) interface{} + + // Visit a parse tree produced by TSqlParser#case_expression. + VisitCase_expression(ctx *Case_expressionContext) interface{} + + // Visit a parse tree produced by TSqlParser#unary_operator_expression. + VisitUnary_operator_expression(ctx *Unary_operator_expressionContext) interface{} + + // Visit a parse tree produced by TSqlParser#bracket_expression. + VisitBracket_expression(ctx *Bracket_expressionContext) interface{} + + // Visit a parse tree produced by TSqlParser#subquery. + VisitSubquery(ctx *SubqueryContext) interface{} + + // Visit a parse tree produced by TSqlParser#with_expression. + VisitWith_expression(ctx *With_expressionContext) interface{} + + // Visit a parse tree produced by TSqlParser#common_table_expression. + VisitCommon_table_expression(ctx *Common_table_expressionContext) interface{} + + // Visit a parse tree produced by TSqlParser#update_elem. + VisitUpdate_elem(ctx *Update_elemContext) interface{} + + // Visit a parse tree produced by TSqlParser#update_elem_merge. + VisitUpdate_elem_merge(ctx *Update_elem_mergeContext) interface{} + + // Visit a parse tree produced by TSqlParser#search_condition. + VisitSearch_condition(ctx *Search_conditionContext) interface{} + + // Visit a parse tree produced by TSqlParser#predicate. + VisitPredicate(ctx *PredicateContext) interface{} + + // Visit a parse tree produced by TSqlParser#query_expression. + VisitQuery_expression(ctx *Query_expressionContext) interface{} + + // Visit a parse tree produced by TSqlParser#sql_union. + VisitSql_union(ctx *Sql_unionContext) interface{} + + // Visit a parse tree produced by TSqlParser#query_specification. + VisitQuery_specification(ctx *Query_specificationContext) interface{} + + // Visit a parse tree produced by TSqlParser#group_by_clause. + VisitGroup_by_clause(ctx *Group_by_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#having_clause. + VisitHaving_clause(ctx *Having_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#from_table_sources. + VisitFrom_table_sources(ctx *From_table_sourcesContext) interface{} + + // Visit a parse tree produced by TSqlParser#top_clause. + VisitTop_clause(ctx *Top_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#top_percent. + VisitTop_percent(ctx *Top_percentContext) interface{} + + // Visit a parse tree produced by TSqlParser#top_count. + VisitTop_count(ctx *Top_countContext) interface{} + + // Visit a parse tree produced by TSqlParser#order_by_clause. + VisitOrder_by_clause(ctx *Order_by_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#select_order_by_clause. + VisitSelect_order_by_clause(ctx *Select_order_by_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#for_clause. + VisitFor_clause(ctx *For_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#xml_common_directives. + VisitXml_common_directives(ctx *Xml_common_directivesContext) interface{} + + // Visit a parse tree produced by TSqlParser#order_by_expression. + VisitOrder_by_expression(ctx *Order_by_expressionContext) interface{} + + // Visit a parse tree produced by TSqlParser#grouping_sets_item. + VisitGrouping_sets_item(ctx *Grouping_sets_itemContext) interface{} + + // Visit a parse tree produced by TSqlParser#group_by_item. + VisitGroup_by_item(ctx *Group_by_itemContext) interface{} + + // Visit a parse tree produced by TSqlParser#option_clause. + VisitOption_clause(ctx *Option_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#option. + VisitOption(ctx *OptionContext) interface{} + + // Visit a parse tree produced by TSqlParser#optimize_for_arg. + VisitOptimize_for_arg(ctx *Optimize_for_argContext) interface{} + + // Visit a parse tree produced by TSqlParser#select_list. + VisitSelect_list(ctx *Select_listContext) interface{} + + // Visit a parse tree produced by TSqlParser#udt_method_arguments. + VisitUdt_method_arguments(ctx *Udt_method_argumentsContext) interface{} + + // Visit a parse tree produced by TSqlParser#asterisk. + VisitAsterisk(ctx *AsteriskContext) interface{} + + // Visit a parse tree produced by TSqlParser#udt_elem. + VisitUdt_elem(ctx *Udt_elemContext) interface{} + + // Visit a parse tree produced by TSqlParser#expression_elem. + VisitExpression_elem(ctx *Expression_elemContext) interface{} + + // Visit a parse tree produced by TSqlParser#select_list_elem. + VisitSelect_list_elem(ctx *Select_list_elemContext) interface{} + + // Visit a parse tree produced by TSqlParser#table_sources. + VisitTable_sources(ctx *Table_sourcesContext) interface{} + + // Visit a parse tree produced by TSqlParser#table_source. + VisitTable_source(ctx *Table_sourceContext) interface{} + + // Visit a parse tree produced by TSqlParser#table_source_item. + VisitTable_source_item(ctx *Table_source_itemContext) interface{} + + // Visit a parse tree produced by TSqlParser#open_xml. + VisitOpen_xml(ctx *Open_xmlContext) interface{} + + // Visit a parse tree produced by TSqlParser#open_json. + VisitOpen_json(ctx *Open_jsonContext) interface{} + + // Visit a parse tree produced by TSqlParser#json_declaration. + VisitJson_declaration(ctx *Json_declarationContext) interface{} + + // Visit a parse tree produced by TSqlParser#json_column_declaration. + VisitJson_column_declaration(ctx *Json_column_declarationContext) interface{} + + // Visit a parse tree produced by TSqlParser#schema_declaration. + VisitSchema_declaration(ctx *Schema_declarationContext) interface{} + + // Visit a parse tree produced by TSqlParser#column_declaration. + VisitColumn_declaration(ctx *Column_declarationContext) interface{} + + // Visit a parse tree produced by TSqlParser#change_table. + VisitChange_table(ctx *Change_tableContext) interface{} + + // Visit a parse tree produced by TSqlParser#change_table_changes. + VisitChange_table_changes(ctx *Change_table_changesContext) interface{} + + // Visit a parse tree produced by TSqlParser#change_table_version. + VisitChange_table_version(ctx *Change_table_versionContext) interface{} + + // Visit a parse tree produced by TSqlParser#join_part. + VisitJoin_part(ctx *Join_partContext) interface{} + + // Visit a parse tree produced by TSqlParser#join_on. + VisitJoin_on(ctx *Join_onContext) interface{} + + // Visit a parse tree produced by TSqlParser#cross_join. + VisitCross_join(ctx *Cross_joinContext) interface{} + + // Visit a parse tree produced by TSqlParser#apply_. + VisitApply_(ctx *Apply_Context) interface{} + + // Visit a parse tree produced by TSqlParser#pivot. + VisitPivot(ctx *PivotContext) interface{} + + // Visit a parse tree produced by TSqlParser#unpivot. + VisitUnpivot(ctx *UnpivotContext) interface{} + + // Visit a parse tree produced by TSqlParser#pivot_clause. + VisitPivot_clause(ctx *Pivot_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#unpivot_clause. + VisitUnpivot_clause(ctx *Unpivot_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#full_column_name_list. + VisitFull_column_name_list(ctx *Full_column_name_listContext) interface{} + + // Visit a parse tree produced by TSqlParser#rowset_function. + VisitRowset_function(ctx *Rowset_functionContext) interface{} + + // Visit a parse tree produced by TSqlParser#bulk_option. + VisitBulk_option(ctx *Bulk_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#derived_table. + VisitDerived_table(ctx *Derived_tableContext) interface{} + + // Visit a parse tree produced by TSqlParser#RANKING_WINDOWED_FUNC. + VisitRANKING_WINDOWED_FUNC(ctx *RANKING_WINDOWED_FUNCContext) interface{} + + // Visit a parse tree produced by TSqlParser#AGGREGATE_WINDOWED_FUNC. + VisitAGGREGATE_WINDOWED_FUNC(ctx *AGGREGATE_WINDOWED_FUNCContext) interface{} + + // Visit a parse tree produced by TSqlParser#ANALYTIC_WINDOWED_FUNC. + VisitANALYTIC_WINDOWED_FUNC(ctx *ANALYTIC_WINDOWED_FUNCContext) interface{} + + // Visit a parse tree produced by TSqlParser#BUILT_IN_FUNC. + VisitBUILT_IN_FUNC(ctx *BUILT_IN_FUNCContext) interface{} + + // Visit a parse tree produced by TSqlParser#SCALAR_FUNCTION. + VisitSCALAR_FUNCTION(ctx *SCALAR_FUNCTIONContext) interface{} + + // Visit a parse tree produced by TSqlParser#FREE_TEXT. + VisitFREE_TEXT(ctx *FREE_TEXTContext) interface{} + + // Visit a parse tree produced by TSqlParser#PARTITION_FUNC. + VisitPARTITION_FUNC(ctx *PARTITION_FUNCContext) interface{} + + // Visit a parse tree produced by TSqlParser#HIERARCHYID_METHOD. + VisitHIERARCHYID_METHOD(ctx *HIERARCHYID_METHODContext) interface{} + + // Visit a parse tree produced by TSqlParser#partition_function. + VisitPartition_function(ctx *Partition_functionContext) interface{} + + // Visit a parse tree produced by TSqlParser#freetext_function. + VisitFreetext_function(ctx *Freetext_functionContext) interface{} + + // Visit a parse tree produced by TSqlParser#freetext_predicate. + VisitFreetext_predicate(ctx *Freetext_predicateContext) interface{} + + // Visit a parse tree produced by TSqlParser#json_key_value. + VisitJson_key_value(ctx *Json_key_valueContext) interface{} + + // Visit a parse tree produced by TSqlParser#json_null_clause. + VisitJson_null_clause(ctx *Json_null_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#APP_NAME. + VisitAPP_NAME(ctx *APP_NAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#APPLOCK_MODE. + VisitAPPLOCK_MODE(ctx *APPLOCK_MODEContext) interface{} + + // Visit a parse tree produced by TSqlParser#APPLOCK_TEST. + VisitAPPLOCK_TEST(ctx *APPLOCK_TESTContext) interface{} + + // Visit a parse tree produced by TSqlParser#ASSEMBLYPROPERTY. + VisitASSEMBLYPROPERTY(ctx *ASSEMBLYPROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#COL_LENGTH. + VisitCOL_LENGTH(ctx *COL_LENGTHContext) interface{} + + // Visit a parse tree produced by TSqlParser#COL_NAME. + VisitCOL_NAME(ctx *COL_NAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#COLUMNPROPERTY. + VisitCOLUMNPROPERTY(ctx *COLUMNPROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATABASEPROPERTYEX. + VisitDATABASEPROPERTYEX(ctx *DATABASEPROPERTYEXContext) interface{} + + // Visit a parse tree produced by TSqlParser#DB_ID. + VisitDB_ID(ctx *DB_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#DB_NAME. + VisitDB_NAME(ctx *DB_NAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#FILE_ID. + VisitFILE_ID(ctx *FILE_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#FILE_IDEX. + VisitFILE_IDEX(ctx *FILE_IDEXContext) interface{} + + // Visit a parse tree produced by TSqlParser#FILE_NAME. + VisitFILE_NAME(ctx *FILE_NAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#FILEGROUP_ID. + VisitFILEGROUP_ID(ctx *FILEGROUP_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#FILEGROUP_NAME. + VisitFILEGROUP_NAME(ctx *FILEGROUP_NAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#FILEGROUPPROPERTY. + VisitFILEGROUPPROPERTY(ctx *FILEGROUPPROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#FILEPROPERTY. + VisitFILEPROPERTY(ctx *FILEPROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#FILEPROPERTYEX. + VisitFILEPROPERTYEX(ctx *FILEPROPERTYEXContext) interface{} + + // Visit a parse tree produced by TSqlParser#FULLTEXTCATALOGPROPERTY. + VisitFULLTEXTCATALOGPROPERTY(ctx *FULLTEXTCATALOGPROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#FULLTEXTSERVICEPROPERTY. + VisitFULLTEXTSERVICEPROPERTY(ctx *FULLTEXTSERVICEPROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#INDEX_COL. + VisitINDEX_COL(ctx *INDEX_COLContext) interface{} + + // Visit a parse tree produced by TSqlParser#INDEXKEY_PROPERTY. + VisitINDEXKEY_PROPERTY(ctx *INDEXKEY_PROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#INDEXPROPERTY. + VisitINDEXPROPERTY(ctx *INDEXPROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#NEXT_VALUE_FOR. + VisitNEXT_VALUE_FOR(ctx *NEXT_VALUE_FORContext) interface{} + + // Visit a parse tree produced by TSqlParser#OBJECT_DEFINITION. + VisitOBJECT_DEFINITION(ctx *OBJECT_DEFINITIONContext) interface{} + + // Visit a parse tree produced by TSqlParser#OBJECT_ID. + VisitOBJECT_ID(ctx *OBJECT_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#OBJECT_NAME. + VisitOBJECT_NAME(ctx *OBJECT_NAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#OBJECT_SCHEMA_NAME. + VisitOBJECT_SCHEMA_NAME(ctx *OBJECT_SCHEMA_NAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#OBJECTPROPERTY. + VisitOBJECTPROPERTY(ctx *OBJECTPROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#OBJECTPROPERTYEX. + VisitOBJECTPROPERTYEX(ctx *OBJECTPROPERTYEXContext) interface{} + + // Visit a parse tree produced by TSqlParser#ORIGINAL_DB_NAME. + VisitORIGINAL_DB_NAME(ctx *ORIGINAL_DB_NAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#PARSENAME. + VisitPARSENAME(ctx *PARSENAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#SCHEMA_ID. + VisitSCHEMA_ID(ctx *SCHEMA_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#SCHEMA_NAME. + VisitSCHEMA_NAME(ctx *SCHEMA_NAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#SCOPE_IDENTITY. + VisitSCOPE_IDENTITY(ctx *SCOPE_IDENTITYContext) interface{} + + // Visit a parse tree produced by TSqlParser#SERVERPROPERTY. + VisitSERVERPROPERTY(ctx *SERVERPROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#STATS_DATE. + VisitSTATS_DATE(ctx *STATS_DATEContext) interface{} + + // Visit a parse tree produced by TSqlParser#TYPE_ID. + VisitTYPE_ID(ctx *TYPE_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#TYPE_NAME. + VisitTYPE_NAME(ctx *TYPE_NAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#TYPEPROPERTY. + VisitTYPEPROPERTY(ctx *TYPEPROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#ASCII. + VisitASCII(ctx *ASCIIContext) interface{} + + // Visit a parse tree produced by TSqlParser#CHAR. + VisitCHAR(ctx *CHARContext) interface{} + + // Visit a parse tree produced by TSqlParser#CHARINDEX. + VisitCHARINDEX(ctx *CHARINDEXContext) interface{} + + // Visit a parse tree produced by TSqlParser#CONCAT. + VisitCONCAT(ctx *CONCATContext) interface{} + + // Visit a parse tree produced by TSqlParser#CONCAT_WS. + VisitCONCAT_WS(ctx *CONCAT_WSContext) interface{} + + // Visit a parse tree produced by TSqlParser#DIFFERENCE. + VisitDIFFERENCE(ctx *DIFFERENCEContext) interface{} + + // Visit a parse tree produced by TSqlParser#FORMAT. + VisitFORMAT(ctx *FORMATContext) interface{} + + // Visit a parse tree produced by TSqlParser#LEFT. + VisitLEFT(ctx *LEFTContext) interface{} + + // Visit a parse tree produced by TSqlParser#LEN. + VisitLEN(ctx *LENContext) interface{} + + // Visit a parse tree produced by TSqlParser#LOWER. + VisitLOWER(ctx *LOWERContext) interface{} + + // Visit a parse tree produced by TSqlParser#LTRIM. + VisitLTRIM(ctx *LTRIMContext) interface{} + + // Visit a parse tree produced by TSqlParser#NCHAR. + VisitNCHAR(ctx *NCHARContext) interface{} + + // Visit a parse tree produced by TSqlParser#PATINDEX. + VisitPATINDEX(ctx *PATINDEXContext) interface{} + + // Visit a parse tree produced by TSqlParser#QUOTENAME. + VisitQUOTENAME(ctx *QUOTENAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#REPLACE. + VisitREPLACE(ctx *REPLACEContext) interface{} + + // Visit a parse tree produced by TSqlParser#REPLICATE. + VisitREPLICATE(ctx *REPLICATEContext) interface{} + + // Visit a parse tree produced by TSqlParser#REVERSE. + VisitREVERSE(ctx *REVERSEContext) interface{} + + // Visit a parse tree produced by TSqlParser#RIGHT. + VisitRIGHT(ctx *RIGHTContext) interface{} + + // Visit a parse tree produced by TSqlParser#RTRIM. + VisitRTRIM(ctx *RTRIMContext) interface{} + + // Visit a parse tree produced by TSqlParser#SOUNDEX. + VisitSOUNDEX(ctx *SOUNDEXContext) interface{} + + // Visit a parse tree produced by TSqlParser#SPACE. + VisitSPACE(ctx *SPACEContext) interface{} + + // Visit a parse tree produced by TSqlParser#STR. + VisitSTR(ctx *STRContext) interface{} + + // Visit a parse tree produced by TSqlParser#STRINGAGG. + VisitSTRINGAGG(ctx *STRINGAGGContext) interface{} + + // Visit a parse tree produced by TSqlParser#STRING_ESCAPE. + VisitSTRING_ESCAPE(ctx *STRING_ESCAPEContext) interface{} + + // Visit a parse tree produced by TSqlParser#STUFF. + VisitSTUFF(ctx *STUFFContext) interface{} + + // Visit a parse tree produced by TSqlParser#SUBSTRING. + VisitSUBSTRING(ctx *SUBSTRINGContext) interface{} + + // Visit a parse tree produced by TSqlParser#TRANSLATE. + VisitTRANSLATE(ctx *TRANSLATEContext) interface{} + + // Visit a parse tree produced by TSqlParser#TRIM. + VisitTRIM(ctx *TRIMContext) interface{} + + // Visit a parse tree produced by TSqlParser#UNICODE. + VisitUNICODE(ctx *UNICODEContext) interface{} + + // Visit a parse tree produced by TSqlParser#UPPER. + VisitUPPER(ctx *UPPERContext) interface{} + + // Visit a parse tree produced by TSqlParser#BINARY_CHECKSUM. + VisitBINARY_CHECKSUM(ctx *BINARY_CHECKSUMContext) interface{} + + // Visit a parse tree produced by TSqlParser#CHECKSUM. + VisitCHECKSUM(ctx *CHECKSUMContext) interface{} + + // Visit a parse tree produced by TSqlParser#COMPRESS. + VisitCOMPRESS(ctx *COMPRESSContext) interface{} + + // Visit a parse tree produced by TSqlParser#CONNECTIONPROPERTY. + VisitCONNECTIONPROPERTY(ctx *CONNECTIONPROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#CONTEXT_INFO. + VisitCONTEXT_INFO(ctx *CONTEXT_INFOContext) interface{} + + // Visit a parse tree produced by TSqlParser#CURRENT_REQUEST_ID. + VisitCURRENT_REQUEST_ID(ctx *CURRENT_REQUEST_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#CURRENT_TRANSACTION_ID. + VisitCURRENT_TRANSACTION_ID(ctx *CURRENT_TRANSACTION_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#DECOMPRESS. + VisitDECOMPRESS(ctx *DECOMPRESSContext) interface{} + + // Visit a parse tree produced by TSqlParser#ERROR_LINE. + VisitERROR_LINE(ctx *ERROR_LINEContext) interface{} + + // Visit a parse tree produced by TSqlParser#ERROR_MESSAGE. + VisitERROR_MESSAGE(ctx *ERROR_MESSAGEContext) interface{} + + // Visit a parse tree produced by TSqlParser#ERROR_NUMBER. + VisitERROR_NUMBER(ctx *ERROR_NUMBERContext) interface{} + + // Visit a parse tree produced by TSqlParser#ERROR_PROCEDURE. + VisitERROR_PROCEDURE(ctx *ERROR_PROCEDUREContext) interface{} + + // Visit a parse tree produced by TSqlParser#ERROR_SEVERITY. + VisitERROR_SEVERITY(ctx *ERROR_SEVERITYContext) interface{} + + // Visit a parse tree produced by TSqlParser#ERROR_STATE. + VisitERROR_STATE(ctx *ERROR_STATEContext) interface{} + + // Visit a parse tree produced by TSqlParser#FORMATMESSAGE. + VisitFORMATMESSAGE(ctx *FORMATMESSAGEContext) interface{} + + // Visit a parse tree produced by TSqlParser#GET_FILESTREAM_TRANSACTION_CONTEXT. + VisitGET_FILESTREAM_TRANSACTION_CONTEXT(ctx *GET_FILESTREAM_TRANSACTION_CONTEXTContext) interface{} + + // Visit a parse tree produced by TSqlParser#GETANSINULL. + VisitGETANSINULL(ctx *GETANSINULLContext) interface{} + + // Visit a parse tree produced by TSqlParser#HOST_ID. + VisitHOST_ID(ctx *HOST_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#HOST_NAME. + VisitHOST_NAME(ctx *HOST_NAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#ISNULL. + VisitISNULL(ctx *ISNULLContext) interface{} + + // Visit a parse tree produced by TSqlParser#ISNUMERIC. + VisitISNUMERIC(ctx *ISNUMERICContext) interface{} + + // Visit a parse tree produced by TSqlParser#MIN_ACTIVE_ROWVERSION. + VisitMIN_ACTIVE_ROWVERSION(ctx *MIN_ACTIVE_ROWVERSIONContext) interface{} + + // Visit a parse tree produced by TSqlParser#NEWID. + VisitNEWID(ctx *NEWIDContext) interface{} + + // Visit a parse tree produced by TSqlParser#NEWSEQUENTIALID. + VisitNEWSEQUENTIALID(ctx *NEWSEQUENTIALIDContext) interface{} + + // Visit a parse tree produced by TSqlParser#ROWCOUNT_BIG. + VisitROWCOUNT_BIG(ctx *ROWCOUNT_BIGContext) interface{} + + // Visit a parse tree produced by TSqlParser#SESSION_CONTEXT. + VisitSESSION_CONTEXT(ctx *SESSION_CONTEXTContext) interface{} + + // Visit a parse tree produced by TSqlParser#XACT_STATE. + VisitXACT_STATE(ctx *XACT_STATEContext) interface{} + + // Visit a parse tree produced by TSqlParser#CAST. + VisitCAST(ctx *CASTContext) interface{} + + // Visit a parse tree produced by TSqlParser#TRY_CAST. + VisitTRY_CAST(ctx *TRY_CASTContext) interface{} + + // Visit a parse tree produced by TSqlParser#CONVERT. + VisitCONVERT(ctx *CONVERTContext) interface{} + + // Visit a parse tree produced by TSqlParser#COALESCE. + VisitCOALESCE(ctx *COALESCEContext) interface{} + + // Visit a parse tree produced by TSqlParser#CURSOR_ROWS. + VisitCURSOR_ROWS(ctx *CURSOR_ROWSContext) interface{} + + // Visit a parse tree produced by TSqlParser#FETCH_STATUS. + VisitFETCH_STATUS(ctx *FETCH_STATUSContext) interface{} + + // Visit a parse tree produced by TSqlParser#CURSOR_STATUS. + VisitCURSOR_STATUS(ctx *CURSOR_STATUSContext) interface{} + + // Visit a parse tree produced by TSqlParser#CERT_ID. + VisitCERT_ID(ctx *CERT_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATALENGTH. + VisitDATALENGTH(ctx *DATALENGTHContext) interface{} + + // Visit a parse tree produced by TSqlParser#IDENT_CURRENT. + VisitIDENT_CURRENT(ctx *IDENT_CURRENTContext) interface{} + + // Visit a parse tree produced by TSqlParser#IDENT_INCR. + VisitIDENT_INCR(ctx *IDENT_INCRContext) interface{} + + // Visit a parse tree produced by TSqlParser#IDENT_SEED. + VisitIDENT_SEED(ctx *IDENT_SEEDContext) interface{} + + // Visit a parse tree produced by TSqlParser#IDENTITY. + VisitIDENTITY(ctx *IDENTITYContext) interface{} + + // Visit a parse tree produced by TSqlParser#SQL_VARIANT_PROPERTY. + VisitSQL_VARIANT_PROPERTY(ctx *SQL_VARIANT_PROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#CURRENT_DATE. + VisitCURRENT_DATE(ctx *CURRENT_DATEContext) interface{} + + // Visit a parse tree produced by TSqlParser#CURRENT_TIMESTAMP. + VisitCURRENT_TIMESTAMP(ctx *CURRENT_TIMESTAMPContext) interface{} + + // Visit a parse tree produced by TSqlParser#CURRENT_TIMEZONE. + VisitCURRENT_TIMEZONE(ctx *CURRENT_TIMEZONEContext) interface{} + + // Visit a parse tree produced by TSqlParser#CURRENT_TIMEZONE_ID. + VisitCURRENT_TIMEZONE_ID(ctx *CURRENT_TIMEZONE_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATE_BUCKET. + VisitDATE_BUCKET(ctx *DATE_BUCKETContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATEADD. + VisitDATEADD(ctx *DATEADDContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATEDIFF. + VisitDATEDIFF(ctx *DATEDIFFContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATEDIFF_BIG. + VisitDATEDIFF_BIG(ctx *DATEDIFF_BIGContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATEFROMPARTS. + VisitDATEFROMPARTS(ctx *DATEFROMPARTSContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATENAME. + VisitDATENAME(ctx *DATENAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATEPART. + VisitDATEPART(ctx *DATEPARTContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATETIME2FROMPARTS. + VisitDATETIME2FROMPARTS(ctx *DATETIME2FROMPARTSContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATETIMEFROMPARTS. + VisitDATETIMEFROMPARTS(ctx *DATETIMEFROMPARTSContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATETIMEOFFSETFROMPARTS. + VisitDATETIMEOFFSETFROMPARTS(ctx *DATETIMEOFFSETFROMPARTSContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATETRUNC. + VisitDATETRUNC(ctx *DATETRUNCContext) interface{} + + // Visit a parse tree produced by TSqlParser#DAY. + VisitDAY(ctx *DAYContext) interface{} + + // Visit a parse tree produced by TSqlParser#EOMONTH. + VisitEOMONTH(ctx *EOMONTHContext) interface{} + + // Visit a parse tree produced by TSqlParser#GETDATE. + VisitGETDATE(ctx *GETDATEContext) interface{} + + // Visit a parse tree produced by TSqlParser#GETUTCDATE. + VisitGETUTCDATE(ctx *GETUTCDATEContext) interface{} + + // Visit a parse tree produced by TSqlParser#ISDATE. + VisitISDATE(ctx *ISDATEContext) interface{} + + // Visit a parse tree produced by TSqlParser#MONTH. + VisitMONTH(ctx *MONTHContext) interface{} + + // Visit a parse tree produced by TSqlParser#SMALLDATETIMEFROMPARTS. + VisitSMALLDATETIMEFROMPARTS(ctx *SMALLDATETIMEFROMPARTSContext) interface{} + + // Visit a parse tree produced by TSqlParser#SWITCHOFFSET. + VisitSWITCHOFFSET(ctx *SWITCHOFFSETContext) interface{} + + // Visit a parse tree produced by TSqlParser#SYSDATETIME. + VisitSYSDATETIME(ctx *SYSDATETIMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#SYSDATETIMEOFFSET. + VisitSYSDATETIMEOFFSET(ctx *SYSDATETIMEOFFSETContext) interface{} + + // Visit a parse tree produced by TSqlParser#SYSUTCDATETIME. + VisitSYSUTCDATETIME(ctx *SYSUTCDATETIMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#TIMEFROMPARTS. + VisitTIMEFROMPARTS(ctx *TIMEFROMPARTSContext) interface{} + + // Visit a parse tree produced by TSqlParser#TODATETIMEOFFSET. + VisitTODATETIMEOFFSET(ctx *TODATETIMEOFFSETContext) interface{} + + // Visit a parse tree produced by TSqlParser#YEAR. + VisitYEAR(ctx *YEARContext) interface{} + + // Visit a parse tree produced by TSqlParser#NULLIF. + VisitNULLIF(ctx *NULLIFContext) interface{} + + // Visit a parse tree produced by TSqlParser#PARSE. + VisitPARSE(ctx *PARSEContext) interface{} + + // Visit a parse tree produced by TSqlParser#XML_DATA_TYPE_FUNC. + VisitXML_DATA_TYPE_FUNC(ctx *XML_DATA_TYPE_FUNCContext) interface{} + + // Visit a parse tree produced by TSqlParser#IIF. + VisitIIF(ctx *IIFContext) interface{} + + // Visit a parse tree produced by TSqlParser#ISJSON. + VisitISJSON(ctx *ISJSONContext) interface{} + + // Visit a parse tree produced by TSqlParser#JSON_OBJECT. + VisitJSON_OBJECT(ctx *JSON_OBJECTContext) interface{} + + // Visit a parse tree produced by TSqlParser#JSON_ARRAY. + VisitJSON_ARRAY(ctx *JSON_ARRAYContext) interface{} + + // Visit a parse tree produced by TSqlParser#JSON_VALUE. + VisitJSON_VALUE(ctx *JSON_VALUEContext) interface{} + + // Visit a parse tree produced by TSqlParser#JSON_QUERY. + VisitJSON_QUERY(ctx *JSON_QUERYContext) interface{} + + // Visit a parse tree produced by TSqlParser#JSON_MODIFY. + VisitJSON_MODIFY(ctx *JSON_MODIFYContext) interface{} + + // Visit a parse tree produced by TSqlParser#JSON_PATH_EXISTS. + VisitJSON_PATH_EXISTS(ctx *JSON_PATH_EXISTSContext) interface{} + + // Visit a parse tree produced by TSqlParser#ABS. + VisitABS(ctx *ABSContext) interface{} + + // Visit a parse tree produced by TSqlParser#ACOS. + VisitACOS(ctx *ACOSContext) interface{} + + // Visit a parse tree produced by TSqlParser#ASIN. + VisitASIN(ctx *ASINContext) interface{} + + // Visit a parse tree produced by TSqlParser#ATAN. + VisitATAN(ctx *ATANContext) interface{} + + // Visit a parse tree produced by TSqlParser#ATN2. + VisitATN2(ctx *ATN2Context) interface{} + + // Visit a parse tree produced by TSqlParser#CEILING. + VisitCEILING(ctx *CEILINGContext) interface{} + + // Visit a parse tree produced by TSqlParser#COS. + VisitCOS(ctx *COSContext) interface{} + + // Visit a parse tree produced by TSqlParser#COT. + VisitCOT(ctx *COTContext) interface{} + + // Visit a parse tree produced by TSqlParser#DEGREES. + VisitDEGREES(ctx *DEGREESContext) interface{} + + // Visit a parse tree produced by TSqlParser#EXP. + VisitEXP(ctx *EXPContext) interface{} + + // Visit a parse tree produced by TSqlParser#FLOOR. + VisitFLOOR(ctx *FLOORContext) interface{} + + // Visit a parse tree produced by TSqlParser#LOG. + VisitLOG(ctx *LOGContext) interface{} + + // Visit a parse tree produced by TSqlParser#LOG10. + VisitLOG10(ctx *LOG10Context) interface{} + + // Visit a parse tree produced by TSqlParser#PI. + VisitPI(ctx *PIContext) interface{} + + // Visit a parse tree produced by TSqlParser#POWER. + VisitPOWER(ctx *POWERContext) interface{} + + // Visit a parse tree produced by TSqlParser#RADIANS. + VisitRADIANS(ctx *RADIANSContext) interface{} + + // Visit a parse tree produced by TSqlParser#RAND. + VisitRAND(ctx *RANDContext) interface{} + + // Visit a parse tree produced by TSqlParser#ROUND. + VisitROUND(ctx *ROUNDContext) interface{} + + // Visit a parse tree produced by TSqlParser#MATH_SIGN. + VisitMATH_SIGN(ctx *MATH_SIGNContext) interface{} + + // Visit a parse tree produced by TSqlParser#SIN. + VisitSIN(ctx *SINContext) interface{} + + // Visit a parse tree produced by TSqlParser#SQRT. + VisitSQRT(ctx *SQRTContext) interface{} + + // Visit a parse tree produced by TSqlParser#SQUARE. + VisitSQUARE(ctx *SQUAREContext) interface{} + + // Visit a parse tree produced by TSqlParser#TAN. + VisitTAN(ctx *TANContext) interface{} + + // Visit a parse tree produced by TSqlParser#GREATEST. + VisitGREATEST(ctx *GREATESTContext) interface{} + + // Visit a parse tree produced by TSqlParser#LEAST. + VisitLEAST(ctx *LEASTContext) interface{} + + // Visit a parse tree produced by TSqlParser#CERTENCODED. + VisitCERTENCODED(ctx *CERTENCODEDContext) interface{} + + // Visit a parse tree produced by TSqlParser#CERTPRIVATEKEY. + VisitCERTPRIVATEKEY(ctx *CERTPRIVATEKEYContext) interface{} + + // Visit a parse tree produced by TSqlParser#CURRENT_USER. + VisitCURRENT_USER(ctx *CURRENT_USERContext) interface{} + + // Visit a parse tree produced by TSqlParser#DATABASE_PRINCIPAL_ID. + VisitDATABASE_PRINCIPAL_ID(ctx *DATABASE_PRINCIPAL_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#HAS_DBACCESS. + VisitHAS_DBACCESS(ctx *HAS_DBACCESSContext) interface{} + + // Visit a parse tree produced by TSqlParser#HAS_PERMS_BY_NAME. + VisitHAS_PERMS_BY_NAME(ctx *HAS_PERMS_BY_NAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#IS_MEMBER. + VisitIS_MEMBER(ctx *IS_MEMBERContext) interface{} + + // Visit a parse tree produced by TSqlParser#IS_ROLEMEMBER. + VisitIS_ROLEMEMBER(ctx *IS_ROLEMEMBERContext) interface{} + + // Visit a parse tree produced by TSqlParser#IS_SRVROLEMEMBER. + VisitIS_SRVROLEMEMBER(ctx *IS_SRVROLEMEMBERContext) interface{} + + // Visit a parse tree produced by TSqlParser#LOGINPROPERTY. + VisitLOGINPROPERTY(ctx *LOGINPROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#ORIGINAL_LOGIN. + VisitORIGINAL_LOGIN(ctx *ORIGINAL_LOGINContext) interface{} + + // Visit a parse tree produced by TSqlParser#PERMISSIONS. + VisitPERMISSIONS(ctx *PERMISSIONSContext) interface{} + + // Visit a parse tree produced by TSqlParser#PWDENCRYPT. + VisitPWDENCRYPT(ctx *PWDENCRYPTContext) interface{} + + // Visit a parse tree produced by TSqlParser#PWDCOMPARE. + VisitPWDCOMPARE(ctx *PWDCOMPAREContext) interface{} + + // Visit a parse tree produced by TSqlParser#SESSION_USER. + VisitSESSION_USER(ctx *SESSION_USERContext) interface{} + + // Visit a parse tree produced by TSqlParser#SESSIONPROPERTY. + VisitSESSIONPROPERTY(ctx *SESSIONPROPERTYContext) interface{} + + // Visit a parse tree produced by TSqlParser#SUSER_ID. + VisitSUSER_ID(ctx *SUSER_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#SUSER_SNAME. + VisitSUSER_SNAME(ctx *SUSER_SNAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#SUSER_SID. + VisitSUSER_SID(ctx *SUSER_SIDContext) interface{} + + // Visit a parse tree produced by TSqlParser#SYSTEM_USER. + VisitSYSTEM_USER(ctx *SYSTEM_USERContext) interface{} + + // Visit a parse tree produced by TSqlParser#USER. + VisitUSER(ctx *USERContext) interface{} + + // Visit a parse tree produced by TSqlParser#USER_ID. + VisitUSER_ID(ctx *USER_IDContext) interface{} + + // Visit a parse tree produced by TSqlParser#USER_NAME. + VisitUSER_NAME(ctx *USER_NAMEContext) interface{} + + // Visit a parse tree produced by TSqlParser#xml_data_type_methods. + VisitXml_data_type_methods(ctx *Xml_data_type_methodsContext) interface{} + + // Visit a parse tree produced by TSqlParser#dateparts_9. + VisitDateparts_9(ctx *Dateparts_9Context) interface{} + + // Visit a parse tree produced by TSqlParser#dateparts_12. + VisitDateparts_12(ctx *Dateparts_12Context) interface{} + + // Visit a parse tree produced by TSqlParser#dateparts_15. + VisitDateparts_15(ctx *Dateparts_15Context) interface{} + + // Visit a parse tree produced by TSqlParser#dateparts_datetrunc. + VisitDateparts_datetrunc(ctx *Dateparts_datetruncContext) interface{} + + // Visit a parse tree produced by TSqlParser#value_method. + VisitValue_method(ctx *Value_methodContext) interface{} + + // Visit a parse tree produced by TSqlParser#value_call. + VisitValue_call(ctx *Value_callContext) interface{} + + // Visit a parse tree produced by TSqlParser#query_method. + VisitQuery_method(ctx *Query_methodContext) interface{} + + // Visit a parse tree produced by TSqlParser#query_call. + VisitQuery_call(ctx *Query_callContext) interface{} + + // Visit a parse tree produced by TSqlParser#exist_method. + VisitExist_method(ctx *Exist_methodContext) interface{} + + // Visit a parse tree produced by TSqlParser#exist_call. + VisitExist_call(ctx *Exist_callContext) interface{} + + // Visit a parse tree produced by TSqlParser#modify_method. + VisitModify_method(ctx *Modify_methodContext) interface{} + + // Visit a parse tree produced by TSqlParser#modify_call. + VisitModify_call(ctx *Modify_callContext) interface{} + + // Visit a parse tree produced by TSqlParser#hierarchyid_call. + VisitHierarchyid_call(ctx *Hierarchyid_callContext) interface{} + + // Visit a parse tree produced by TSqlParser#hierarchyid_static_method. + VisitHierarchyid_static_method(ctx *Hierarchyid_static_methodContext) interface{} + + // Visit a parse tree produced by TSqlParser#nodes_method. + VisitNodes_method(ctx *Nodes_methodContext) interface{} + + // Visit a parse tree produced by TSqlParser#switch_section. + VisitSwitch_section(ctx *Switch_sectionContext) interface{} + + // Visit a parse tree produced by TSqlParser#switch_search_condition_section. + VisitSwitch_search_condition_section(ctx *Switch_search_condition_sectionContext) interface{} + + // Visit a parse tree produced by TSqlParser#as_column_alias. + VisitAs_column_alias(ctx *As_column_aliasContext) interface{} + + // Visit a parse tree produced by TSqlParser#as_table_alias. + VisitAs_table_alias(ctx *As_table_aliasContext) interface{} + + // Visit a parse tree produced by TSqlParser#table_alias. + VisitTable_alias(ctx *Table_aliasContext) interface{} + + // Visit a parse tree produced by TSqlParser#with_table_hints. + VisitWith_table_hints(ctx *With_table_hintsContext) interface{} + + // Visit a parse tree produced by TSqlParser#deprecated_table_hint. + VisitDeprecated_table_hint(ctx *Deprecated_table_hintContext) interface{} + + // Visit a parse tree produced by TSqlParser#sybase_legacy_hints. + VisitSybase_legacy_hints(ctx *Sybase_legacy_hintsContext) interface{} + + // Visit a parse tree produced by TSqlParser#sybase_legacy_hint. + VisitSybase_legacy_hint(ctx *Sybase_legacy_hintContext) interface{} + + // Visit a parse tree produced by TSqlParser#table_hint. + VisitTable_hint(ctx *Table_hintContext) interface{} + + // Visit a parse tree produced by TSqlParser#index_value. + VisitIndex_value(ctx *Index_valueContext) interface{} + + // Visit a parse tree produced by TSqlParser#column_alias_list. + VisitColumn_alias_list(ctx *Column_alias_listContext) interface{} + + // Visit a parse tree produced by TSqlParser#column_alias. + VisitColumn_alias(ctx *Column_aliasContext) interface{} + + // Visit a parse tree produced by TSqlParser#table_value_constructor. + VisitTable_value_constructor(ctx *Table_value_constructorContext) interface{} + + // Visit a parse tree produced by TSqlParser#expression_list_. + VisitExpression_list_(ctx *Expression_list_Context) interface{} + + // Visit a parse tree produced by TSqlParser#ranking_windowed_function. + VisitRanking_windowed_function(ctx *Ranking_windowed_functionContext) interface{} + + // Visit a parse tree produced by TSqlParser#aggregate_windowed_function. + VisitAggregate_windowed_function(ctx *Aggregate_windowed_functionContext) interface{} + + // Visit a parse tree produced by TSqlParser#analytic_windowed_function. + VisitAnalytic_windowed_function(ctx *Analytic_windowed_functionContext) interface{} + + // Visit a parse tree produced by TSqlParser#all_distinct_expression. + VisitAll_distinct_expression(ctx *All_distinct_expressionContext) interface{} + + // Visit a parse tree produced by TSqlParser#over_clause. + VisitOver_clause(ctx *Over_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#row_or_range_clause. + VisitRow_or_range_clause(ctx *Row_or_range_clauseContext) interface{} + + // Visit a parse tree produced by TSqlParser#window_frame_extent. + VisitWindow_frame_extent(ctx *Window_frame_extentContext) interface{} + + // Visit a parse tree produced by TSqlParser#window_frame_bound. + VisitWindow_frame_bound(ctx *Window_frame_boundContext) interface{} + + // Visit a parse tree produced by TSqlParser#window_frame_preceding. + VisitWindow_frame_preceding(ctx *Window_frame_precedingContext) interface{} + + // Visit a parse tree produced by TSqlParser#window_frame_following. + VisitWindow_frame_following(ctx *Window_frame_followingContext) interface{} + + // Visit a parse tree produced by TSqlParser#create_database_option. + VisitCreate_database_option(ctx *Create_database_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#database_filestream_option. + VisitDatabase_filestream_option(ctx *Database_filestream_optionContext) interface{} + + // Visit a parse tree produced by TSqlParser#database_file_spec. + VisitDatabase_file_spec(ctx *Database_file_specContext) interface{} + + // Visit a parse tree produced by TSqlParser#file_group. + VisitFile_group(ctx *File_groupContext) interface{} + + // Visit a parse tree produced by TSqlParser#file_spec. + VisitFile_spec(ctx *File_specContext) interface{} + + // Visit a parse tree produced by TSqlParser#entity_name. + VisitEntity_name(ctx *Entity_nameContext) interface{} + + // Visit a parse tree produced by TSqlParser#entity_name_for_azure_dw. + VisitEntity_name_for_azure_dw(ctx *Entity_name_for_azure_dwContext) interface{} + + // Visit a parse tree produced by TSqlParser#entity_name_for_parallel_dw. + VisitEntity_name_for_parallel_dw(ctx *Entity_name_for_parallel_dwContext) interface{} + + // Visit a parse tree produced by TSqlParser#full_table_name. + VisitFull_table_name(ctx *Full_table_nameContext) interface{} + + // Visit a parse tree produced by TSqlParser#dotID. + VisitDotID(ctx *DotIDContext) interface{} + + // Visit a parse tree produced by TSqlParser#doubleDotID. + VisitDoubleDotID(ctx *DoubleDotIDContext) interface{} + + // Visit a parse tree produced by TSqlParser#table_name. + VisitTable_name(ctx *Table_nameContext) interface{} + + // Visit a parse tree produced by TSqlParser#simple_name. + VisitSimple_name(ctx *Simple_nameContext) interface{} + + // Visit a parse tree produced by TSqlParser#func_proc_name_schema. + VisitFunc_proc_name_schema(ctx *Func_proc_name_schemaContext) interface{} + + // Visit a parse tree produced by TSqlParser#func_proc_name_database_schema. + VisitFunc_proc_name_database_schema(ctx *Func_proc_name_database_schemaContext) interface{} + + // Visit a parse tree produced by TSqlParser#func_proc_name_server_database_schema. + VisitFunc_proc_name_server_database_schema(ctx *Func_proc_name_server_database_schemaContext) interface{} + + // Visit a parse tree produced by TSqlParser#ddl_object. + VisitDdl_object(ctx *Ddl_objectContext) interface{} + + // Visit a parse tree produced by TSqlParser#full_column_name. + VisitFull_column_name(ctx *Full_column_nameContext) interface{} + + // Visit a parse tree produced by TSqlParser#column_name_list_with_order. + VisitColumn_name_list_with_order(ctx *Column_name_list_with_orderContext) interface{} + + // Visit a parse tree produced by TSqlParser#column_name_with_order. + VisitColumn_name_with_order(ctx *Column_name_with_orderContext) interface{} + + // Visit a parse tree produced by TSqlParser#insert_column_name_list. + VisitInsert_column_name_list(ctx *Insert_column_name_listContext) interface{} + + // Visit a parse tree produced by TSqlParser#insert_column_id. + VisitInsert_column_id(ctx *Insert_column_idContext) interface{} + + // Visit a parse tree produced by TSqlParser#column_name_list. + VisitColumn_name_list(ctx *Column_name_listContext) interface{} + + // Visit a parse tree produced by TSqlParser#cursor_name. + VisitCursor_name(ctx *Cursor_nameContext) interface{} + + // Visit a parse tree produced by TSqlParser#on_off. + VisitOn_off(ctx *On_offContext) interface{} + + // Visit a parse tree produced by TSqlParser#clustered. + VisitClustered(ctx *ClusteredContext) interface{} + + // Visit a parse tree produced by TSqlParser#null_notnull. + VisitNull_notnull(ctx *Null_notnullContext) interface{} + + // Visit a parse tree produced by TSqlParser#scalar_function_name. + VisitScalar_function_name(ctx *Scalar_function_nameContext) interface{} + + // Visit a parse tree produced by TSqlParser#begin_conversation_timer. + VisitBegin_conversation_timer(ctx *Begin_conversation_timerContext) interface{} + + // Visit a parse tree produced by TSqlParser#begin_conversation_dialog. + VisitBegin_conversation_dialog(ctx *Begin_conversation_dialogContext) interface{} + + // Visit a parse tree produced by TSqlParser#contract_name. + VisitContract_name(ctx *Contract_nameContext) interface{} + + // Visit a parse tree produced by TSqlParser#service_name. + VisitService_name(ctx *Service_nameContext) interface{} + + // Visit a parse tree produced by TSqlParser#end_conversation. + VisitEnd_conversation(ctx *End_conversationContext) interface{} + + // Visit a parse tree produced by TSqlParser#waitfor_conversation. + VisitWaitfor_conversation(ctx *Waitfor_conversationContext) interface{} + + // Visit a parse tree produced by TSqlParser#get_conversation. + VisitGet_conversation(ctx *Get_conversationContext) interface{} + + // Visit a parse tree produced by TSqlParser#queue_id. + VisitQueue_id(ctx *Queue_idContext) interface{} + + // Visit a parse tree produced by TSqlParser#send_conversation. + VisitSend_conversation(ctx *Send_conversationContext) interface{} + + // Visit a parse tree produced by TSqlParser#data_type. + VisitData_type(ctx *Data_typeContext) interface{} + + // Visit a parse tree produced by TSqlParser#constant. + VisitConstant(ctx *ConstantContext) interface{} + + // Visit a parse tree produced by TSqlParser#primitive_constant. + VisitPrimitive_constant(ctx *Primitive_constantContext) interface{} + + // Visit a parse tree produced by TSqlParser#keyword. + VisitKeyword(ctx *KeywordContext) interface{} + + // Visit a parse tree produced by TSqlParser#id_. + VisitId_(ctx *Id_Context) interface{} + + // Visit a parse tree produced by TSqlParser#simple_id. + VisitSimple_id(ctx *Simple_idContext) interface{} + + // Visit a parse tree produced by TSqlParser#id_or_string. + VisitId_or_string(ctx *Id_or_stringContext) interface{} + + // Visit a parse tree produced by TSqlParser#comparison_operator. + VisitComparison_operator(ctx *Comparison_operatorContext) interface{} + + // Visit a parse tree produced by TSqlParser#assignment_operator. + VisitAssignment_operator(ctx *Assignment_operatorContext) interface{} + + // Visit a parse tree produced by TSqlParser#file_size. + VisitFile_size(ctx *File_sizeContext) interface{} +}